I've analyzed the code changes and found several type annotation issues and potential bugs that need to be fixed. Here's my commit:

Fixed type annotations and potential bugs throughout codeflow_engine

This commit addresses multiple type annotation issues and potential bugs:

1. Added proper type annotations for functions and variables
2. Fixed imports to use proper aliases for renamed classes
3. Fixed potential None reference issues with proper null checks
4. Improved error handling in several functions
5. Fixed comparison operations to check for compatible types
6. Made Redis storage more robust with better error handling
7. Fixed workflow condition evaluation to handle type mismatches safely
8. Added proper return types for functions that were missing them

The changes maintain backward compatibility while improving type safety
and reducing the potential for runtime errors.

Author: JustAGhosT

engine/codeflow_engine/actions/__init__.py

@@ -13,70 +13,31 @@
 - maintenance: Maintenance tasks
 """
 
+import importlib
+from types import ModuleType
 from typing import Any
 
 from codeflow_engine.actions.registry import ActionRegistry
 
-# Import category modules with error handling for optional dependencies
-ai_actions = None
-try:
-    from codeflow_engine.actions import ai_actions
-except (ImportError, OSError):
-    pass
-
-analysis = None
-try:
-    from codeflow_engine.actions import analysis
-except (ImportError, OSError):
-    pass
-
-base = None
-try:
-    from codeflow_engine.actions import base
-except (ImportError, OSError):
-    pass
-
-generation = None
-try:
-    from codeflow_engine.actions import generation
-except (ImportError, OSError):
-    pass
 
-git = None
-try:
-    from codeflow_engine.actions import git
-except (ImportError, OSError):
-    pass
+def _optional_module(module_name: str) -> ModuleType | None:
+    try:
+        return importlib.import_module(module_name)
+    except (ImportError, OSError):
+        return None
 
-issues = None
-try:
-    from codeflow_engine.actions import issues
-except (ImportError, OSError):
-    pass
 
-maintenance = None
-try:
-    from codeflow_engine.actions import maintenance
-except (ImportError, OSError):
-    pass
-
-platform = None
-try:
-    from codeflow_engine.actions import platform
-except (ImportError, OSError):
-    pass
-
-quality = None
-try:
-    from codeflow_engine.actions import quality
-except (ImportError, OSError):
-    pass
-
-scripts = None
-try:
-    from codeflow_engine.actions import scripts
-except (ImportError, OSError):
-    pass
+# Import category modules with error handling for optional dependencies
+ai_actions: ModuleType | None = _optional_module("codeflow_engine.actions.ai_actions")
+analysis: ModuleType | None = _optional_module("codeflow_engine.actions.analysis")
+base: ModuleType | None = _optional_module("codeflow_engine.actions.base")
+generation: ModuleType | None = _optional_module("codeflow_engine.actions.generation")
+git: ModuleType | None = _optional_module("codeflow_engine.actions.git")
+issues: ModuleType | None = _optional_module("codeflow_engine.actions.issues")
+maintenance: ModuleType | None = _optional_module("codeflow_engine.actions.maintenance")
+platform: ModuleType | None = _optional_module("codeflow_engine.actions.platform")
+quality: ModuleType | None = _optional_module("codeflow_engine.actions.quality")
+scripts: ModuleType | None = _optional_module("codeflow_engine.actions.scripts")
 
 # Re-export commonly used actions for backward compatibility
 # Analysis
@@ -187,11 +148,7 @@
     pass
 
 # Create llm alias for backward compatibility (codeflow_engine.actions.llm)
-llm = None
-try:
-    from codeflow_engine.actions.ai_actions import llm
-except ImportError:
-    pass
+llm: ModuleType | None = _optional_module("codeflow_engine.actions.ai_actions.llm")
 
 # Platform
 PlatformDetector: type[Any] | None = None

engine/codeflow_engine/actions/ai_actions/__init__.py

@@ -2,10 +2,14 @@
 
 from codeflow_engine.actions.autogen_implementation import AutoGenImplementation
 from codeflow_engine.actions.autogen_multi_agent import AutoGenAgentSystem
-from codeflow_engine.actions.configurable_llm_provider import ConfigurableLLMProvider
+from codeflow_engine.actions.configurable_llm_provider import (
+    LLMProviderManager as ConfigurableLLMProvider,
+)
 from codeflow_engine.actions.learning_memory_system import LearningMemorySystem
 from codeflow_engine.actions.mem0_memory_integration import Mem0MemoryManager
-from codeflow_engine.actions.summarize_pr_with_ai import SummarizePRWithAI
+from codeflow_engine.actions.summarize_pr_with_ai import (
+    SummarizePrWithAI as SummarizePRWithAI,
+)
 
 from . import autogen, llm
 
@@ -18,4 +22,4 @@
     "SummarizePRWithAI",
     "autogen",
     "llm",
-]
+]

engine/codeflow_engine/actions/ai_linting_fixer/ai_fix_applier.py

@@ -8,15 +8,17 @@
 from typing import Any
 
 from codeflow_engine.actions.ai_linting_fixer.backup_manager import BackupManager
-from codeflow_engine.actions.ai_linting_fixer.file_persistence import \
-    FilePersistenceManager
+from codeflow_engine.actions.ai_linting_fixer.file_persistence import (
+    FilePersistenceManager,
+)
 from codeflow_engine.actions.ai_linting_fixer.fix_strategy import StrategySelector
 from codeflow_engine.actions.ai_linting_fixer.llm_client import LLMClient
-from codeflow_engine.actions.ai_linting_fixer.models import (LintingIssue)
+from codeflow_engine.actions.ai_linting_fixer.models import LintingIssue
 from codeflow_engine.actions.ai_linting_fixer.response_parser import ResponseParser
 from codeflow_engine.actions.ai_linting_fixer.validation_manager import (
-    ValidationConfig, ValidationManager)
-from codeflow_engine.ai.core.providers.manager import LLMProviderManager
+    ValidationConfig,
+    ValidationManager,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -26,7 +28,7 @@ class AIFixApplier:
 
     def __init__(
         self,
-        llm_manager: LLMProviderManager,
+        llm_manager: Any,
         backup_manager: BackupManager | None = None,
         validation_config: ValidationConfig | None = None,
     ):
@@ -51,7 +53,9 @@ def __init__(
         self.llm_client = LLMClient(llm_manager)
         self.response_parser = ResponseParser()
         self.persistence_manager = FilePersistenceManager(backup_manager)
-        self.validation_manager = ValidationManager(validation_config or ValidationConfig())
+        self.validation_manager = ValidationManager(
+            validation_config or ValidationConfig()
+        )
 
         # Initialize strategy selector
         self.strategy_selector = StrategySelector(
@@ -61,7 +65,7 @@ def __init__(
             self.validation_manager,
         )
 
-        self.session_id = None
+        self.session_id: str | None = None
 
     async def apply_specialist_fix_with_validation(
         self,

engine/codeflow_engine/actions/ai_linting_fixer/code_analyzer.py

@@ -6,6 +6,7 @@
 
 import ast
 import logging
+from typing import Any
 
 
 try:
@@ -156,7 +157,7 @@ def count_lines_of_code(self, content: str) -> dict[str, int]:
         docstring_lines = 0
 
         in_docstring = False
-        docstring_quotes = None
+        docstring_quotes: str | None = None
 
         for line in lines:
             stripped = line.strip()
@@ -175,7 +176,7 @@ def count_lines_of_code(self, content: str) -> dict[str, int]:
                     docstring_lines += 1
                 else:
                     # End of docstring
-                    if docstring_quotes in stripped:
+                    if docstring_quotes and docstring_quotes in stripped:
                         in_docstring = False
                         docstring_quotes = None
                     docstring_lines += 1
@@ -223,7 +224,7 @@ def get_cpu_usage(self) -> float:
             logger.debug(f"Error getting CPU usage: {e}")
             return 0.0
 
-    def analyze_function_complexity(self, content: str) -> list[dict[str, any]]:
+    def analyze_function_complexity(self, content: str) -> list[dict[str, Any]]:
         """Analyze complexity of individual functions."""
         try:
             tree = ast.parse(content)
@@ -245,7 +246,9 @@ def analyze_function_complexity(self, content: str) -> list[dict[str, any]]:
             logger.debug(f"Error analyzing function complexity: {e}")
             return []
 
-    def _calculate_function_complexity(self, node: ast.FunctionDef) -> int:
+    def _calculate_function_complexity(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> int:
         """Calculate cyclomatic complexity of a function."""
         complexity = 1  # Base complexity
 
@@ -266,7 +269,7 @@ def _calculate_function_complexity(self, node: ast.FunctionDef) -> int:
 
         return complexity
 
-    def detect_code_smells(self, content: str) -> list[dict[str, any]]:
+    def detect_code_smells(self, content: str) -> list[dict[str, Any]]:
         """Detect common code smells and anti-patterns."""
         smells = []
 
@@ -313,7 +316,7 @@ def detect_code_smells(self, content: str) -> list[dict[str, any]]:
 
         return smells
 
-    def get_code_metrics(self, content: str) -> dict[str, any]:
+    def get_code_metrics(self, content: str) -> dict[str, Any]:
         """Get comprehensive code metrics."""
         return {
             "complexity": self.calculate_file_complexity(content),

engine/codeflow_engine/actions/ai_linting_fixer/core.py

@@ -12,9 +12,10 @@
 from codeflow_engine.actions.ai_linting_fixer.database import AIInteractionDB
 from codeflow_engine.actions.ai_linting_fixer.metrics import MetricsCollector
 from codeflow_engine.actions.ai_linting_fixer.queue_manager import IssueQueueManager
-from codeflow_engine.actions.ai_linting_fixer.workflow import (WorkflowContext,
-                                                      WorkflowIntegrationMixin)
-from codeflow_engine.ai.core.providers.manager import LLMProviderManager
+from codeflow_engine.actions.ai_linting_fixer.workflow import (
+    WorkflowContext,
+    WorkflowIntegrationMixin,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +39,7 @@ class AILintingFixer(WorkflowIntegrationMixin):
 
     def __init__(
         self,
-        llm_manager: LLMProviderManager | None = None,
+        llm_manager: Any | None = None,
         max_workers: int = DEFAULT_MAX_WORKERS,
         workflow_context: WorkflowContext | None = None,
     ):
@@ -82,8 +83,11 @@ def _generate_session_id(self) -> str:
         """Generate a unique session identifier."""
         import random
         import string
+
         timestamp = self.metrics.session_metrics.start_time.strftime("%Y%m%d_%H%M%S")
-        random_suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+        random_suffix = "".join(
+            random.choices(string.ascii_lowercase + string.digits, k=6)
+        )
         return f"ai_lint_{timestamp}_{random_suffix}"
 
     def queue_detected_issues(self, issues: list, quiet: bool = False) -> int:
@@ -92,7 +96,7 @@ def queue_detected_issues(self, issues: list, quiet: bool = False) -> int:
             return 0
 
         # Ensure session_id exists
-        if not hasattr(self, 'session_id') or not self.session_id:
+        if not hasattr(self, "session_id") or not self.session_id:
             msg = "Session ID is required but not available"
             raise ValueError(msg)
 
@@ -126,9 +130,7 @@ async def process_queued_issues(
             # Get next batch of issues
             batch_size = min(max_fixes - processed_count, max_fixes)
             issues = self.queue_manager.get_next_issues(
-                limit=batch_size,
-                worker_id=self.session_id,
-                filter_types=filter_types
+                limit=batch_size, worker_id=self.session_id, filter_types=filter_types
             )
 
             if not issues:
@@ -157,14 +159,16 @@ async def process_queued_issues(
                         self.queue_manager.update_issue_status(
                             issue_id=int(issue_id),
                             status=status,
-                            fix_result=fix_result.get("details", {})
+                            fix_result=fix_result.get("details", {}),
                         )
 
                     results["processed"] += 1
                     processed_count += 1
                 except Exception as e:
                     if not quiet:
-                        logger.exception("Error processing issue %s", issue.get('id', 'unknown'))
+                        logger.exception(
+                            "Error processing issue %s", issue.get("id", "unknown")
+                        )
                     results["failed"] += 1
                     results["processed"] += 1
                     processed_count += 1
@@ -175,7 +179,7 @@ async def process_queued_issues(
                         self.queue_manager.update_issue_status(
                             issue_id=int(issue_id),
                             status="failed",
-                            fix_result={"error": str(e)}
+                            fix_result={"error": str(e)},
                         )
 
         # Update stats
@@ -204,15 +208,12 @@ async def _attempt_issue_fix(self, issue: dict[str, Any]) -> dict[str, Any]:
                     "line_number": line_number,
                     "error_code": error_code,
                     "message": message,
-                    "fix_applied": f"Applied fix for {error_code}"
-                }
+                    "fix_applied": f"Applied fix for {error_code}",
+                },
             }
         except Exception as e:
             logger.exception("Error in _attempt_issue_fix")
-            return {
-                "success": False,
-                "details": {"error": str(e)}
-            }
+            return {"success": False, "details": {"error": str(e)}}
         else:
             return fix_result
 
@@ -223,7 +224,9 @@ def get_session_results(self) -> dict[str, Any]:
 
         # Calculate success rate
         total_issues = self.stats["issues_processed"]
-        success_rate = 0.0 if total_issues == 0 else self.stats["issues_fixed"] / total_issues
+        success_rate = (
+            0.0 if total_issues == 0 else self.stats["issues_fixed"] / total_issues
+        )
 
         return {
             "session_id": self.session_id,