WIP

Author: Mateusz

fix_test_failures_todo.md

@@ -0,0 +1,36 @@
+# Test Failures Fix Plan
+
+## Issues Summary
+- [ ] 1. Documentation Index Issue - `inline-python-steering.md` not listed in user_guide/index.md
+- [ ] 2. Ruff Linting Issues - F821 and RUF005 violations  
+- [ ] 3. DI Container Violations - CommandExtractionService direct instantiation
+- [ ] 4. MyPy Type Checking Issues - ConfiguredRulesPolicy undefined and union attribute
+
+## Implementation Steps
+
+### Phase 1: Fix Overlapping Issues (High Priority)
+- [ ] 1.1 Fix undefined `ConfiguredRulesPolicy` in steering.py:160
+- [ ] 1.2 Fix mypy union attribute issue in unified_tool_security_handler.py:274
+- [ ] 1.3 Fix ruff concatenation issue in unified_security_config.py:86
+
+### Phase 2: Fix DI Container Violations
+- [ ] 2.1 Fix CommandExtractionService instantiation in inline_python_steering_handler.py:59
+- [ ] 2.2 Fix CommandExtractionService instantiation in inline_python_policy.py:48
+
+### Phase 3: Fix Documentation Issues
+- [ ] 3.1 Add missing `inline-python-steering.md` link to user_guide/index.md
+
+### Phase 4: Verification
+- [ ] 4.1 Run ruff linting test to verify fixes
+- [ ] 4.2 Run mypy validation test to verify fixes
+- [ ] 4.3 Run DI container test to verify fixes
+- [ ] 4.4 Run documentation structure test to verify fixes
+- [ ] 4.5 Run all failing tests together to confirm complete resolution
+
+## Files to Modify
+1. `src/core/app/stages/steering.py` - Fix ConfiguredRulesPolicy import
+2. `src/core/services/unified_tool_security_handler.py` - Fix union attribute
+3. `src/core/domain/configuration/unified_security_config.py` - Fix concatenation
+4. `src/core/services/tool_call_handlers/inline_python_steering_handler.py` - Fix DI violation
+5. `src/services/steering/policies/inline_python_policy.py` - Fix DI violation
+6. `docs/user_guide/index.md` - Add missing documentation link

src/core/app/application_builder.py

@@ -139,11 +139,15 @@ def add_default_stages(self) -> ApplicationBuilder:
             CoreServicesStage,
             InfrastructureStage,
             ProcessorStage,
+            SteeringStage,
         )
 
         return (
             self.add_stage(InfrastructureStage())
             .add_stage(CoreServicesStage())
+            .add_stage(
+                SteeringStage()
+            )  # After core services, before backends to ensure handlers are available
             .add_stage(BackendStage())
             .add_stage(CommandStage())
             .add_stage(ProcessorStage())

src/core/app/stages/__init__.py

@@ -7,6 +7,7 @@
 from .health_check import HealthCheckStage
 from .infrastructure import InfrastructureStage
 from .processor import ProcessorStage
+from .steering import SteeringStage
 from .test_stages import RealBackendTestStage
 
 __all__ = [
@@ -19,5 +20,6 @@
     "InfrastructureStage",
     "InitializationStage",
     "ProcessorStage",
+    "SteeringStage",
     "RealBackendTestStage",
 ]

src/core/app/stages/application_stages.py

@@ -12,6 +12,7 @@
 from .health_check import HealthCheckStage
 from .infrastructure import InfrastructureStage
 from .processor import ProcessorStage
+from .steering import SteeringStage
 
 
 class DefaultApplicationStages:
@@ -21,6 +22,7 @@ def __init__(self) -> None:
         self._stages: tuple[InitializationStage, ...] = (
             InfrastructureStage(),
             CoreServicesStage(),
+            SteeringStage(),  # After core services, before backends
             BackendStage(),
             HealthCheckStage(),  # After backends so we can monitor their URLs
             CommandStage(),

src/core/app/stages/steering.py

@@ -0,0 +1,277 @@
+"""
+Steering services initialization stage.
+
+This stage registers unified steering framework services:
+- Session state store
+- Steering policies
+- Unified steering handler
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from src.core.config.app_config import AppConfig
+from src.core.di.container import ServiceCollection
+from src.core.interfaces.di_interface import IServiceProvider
+
+# Import at module level to avoid undefined name issues
+from src.services.steering.policies import ConfiguredRulesPolicy
+
+from .base import InitializationStage
+
+logger = logging.getLogger(__name__)
+
+
+class SteeringStage(InitializationStage):
+    """Stage for registering unified steering framework services."""
+
+    @property
+    def name(self) -> str:
+        return "steering"
+
+    def get_dependencies(self) -> list[str]:
+        return ["core_services"]
+
+    def get_description(self) -> str:
+        return "Register unified steering framework (session store, policies, handler)"
+
+    async def execute(self, services: ServiceCollection, config: AppConfig) -> None:
+        """Register steering services."""
+        if logger.isEnabledFor(logging.INFO):
+            logger.info("Initializing steering services...")
+
+        # Register session state store
+        self._register_session_state_store(services, config)
+
+        # Register policies
+        self._register_steering_policies(services, config)
+
+        # Register unified steering handler
+        self._register_unified_steering_handler(services, config)
+
+        if logger.isEnabledFor(logging.INFO):
+            logger.info("Steering services initialized successfully")
+
+    async def validate(self, services: ServiceCollection, config: AppConfig) -> bool:
+        """Validate that steering services can be registered."""
+        try:
+            # Check that reactor config exists
+            if not hasattr(config.session, "tool_call_reactor"):
+                if logger.isEnabledFor(logging.WARNING):
+                    logger.warning("Config missing tool_call_reactor section")
+                return False
+
+            return True
+        except ImportError as e:
+            if logger.isEnabledFor(logging.ERROR):
+                logger.error(f"Steering services validation failed: {e}")
+            return False
+
+    def _register_session_state_store(
+        self, services: ServiceCollection, config: AppConfig
+    ) -> None:
+        """Register session state store as singleton."""
+        try:
+            from src.services.steering import SessionStateStore
+
+            reactor_config = config.session.tool_call_reactor
+
+            # Use configured settings or legacy-compatible defaults
+            ttl_seconds = getattr(reactor_config, "steering_session_ttl_seconds", 1800)
+            max_sessions = getattr(reactor_config, "steering_max_sessions", 1024)
+
+            services.add_singleton(
+                SessionStateStore,
+                implementation_factory=lambda provider: SessionStateStore(
+                    ttl_seconds=ttl_seconds, max_sessions=max_sessions
+                ),
+            )
+
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(
+                    "Registered SessionStateStore (ttl=%ds, max=%d)",
+                    ttl_seconds,
+                    max_sessions,
+                )
+        except Exception as e:
+            if logger.isEnabledFor(logging.WARNING):
+                logger.warning(f"Could not register SessionStateStore: {e}")
+
+    def _register_steering_policies(
+        self, services: ServiceCollection, config: AppConfig
+    ) -> None:
+        """Register steering policies as singletons."""
+        try:
+            from src.services.steering.policies import (
+                InlinePythonPolicy,
+                PytestFullSuitePolicy,
+            )
+
+            reactor_config = config.session.tool_call_reactor
+
+            # Register InlinePythonPolicy
+            services.add_singleton(
+                InlinePythonPolicy,
+                implementation_factory=lambda provider: InlinePythonPolicy(
+                    message=getattr(
+                        reactor_config, "inline_python_steering_message", None
+                    ),
+                    enabled=getattr(
+                        reactor_config, "inline_python_steering_enabled", True
+                    ),
+                    prompt_override_path=Path(
+                        "config/prompts/steering_inline_python.md"
+                    ),
+                ),
+            )
+
+            # Register PytestFullSuitePolicy
+            from src.services.steering import SessionStateStore
+
+            services.add_singleton(
+                PytestFullSuitePolicy,
+                implementation_factory=lambda provider: PytestFullSuitePolicy(
+                    session_store=provider.get_required_service(SessionStateStore),
+                    message=reactor_config.pytest_full_suite_steering_message,
+                    enabled=reactor_config.pytest_full_suite_steering_enabled,
+                    prompt_override_path=Path(
+                        "config/prompts/steering_pytest_full_suite.md"
+                    ),
+                ),
+            )
+
+            # Register ConfiguredRulesPolicy
+            services.add_singleton(
+                ConfiguredRulesPolicy,
+                implementation_factory=lambda provider: self._create_configured_rules_policy(
+                    provider, reactor_config
+                ),
+            )
+
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("Registered steering policies")
+        except Exception as e:
+            if logger.isEnabledFor(logging.WARNING):
+                logger.warning(f"Could not register steering policies: {e}")
+
+    def _create_configured_rules_policy(
+        self, provider: IServiceProvider, reactor_config: Any
+    ) -> ConfiguredRulesPolicy:
+        """Create ConfiguredRulesPolicy with synthesized legacy rules."""
+        from src.services.steering import SessionStateStore
+
+        # Build effective rules from config
+        effective_rules = (
+            (reactor_config.steering_rules or []).copy()
+            if reactor_config.steering_rules
+            else []
+        )
+
+        # Synthesize legacy apply_diff rule if enabled and missing
+        if getattr(reactor_config, "apply_diff_steering_enabled", True):
+            has_apply_rule = False
+            for r in effective_rules:
+                triggers = (r or {}).get("triggers") or {}
+                tnames = triggers.get("tool_names") or []
+                phrases = triggers.get("phrases") or []
+                if "apply_diff" in tnames or any(
+                    isinstance(p, str) and "apply_diff" in p for p in phrases
+                ):
+                    has_apply_rule = True
+                    break
+
+            if not has_apply_rule:
+                # Check for override file
+                apply_diff_msg = reactor_config.apply_diff_steering_message
+                override_path = Path("config/prompts/steering_apply_diff.md")
+
+                if not apply_diff_msg and override_path.is_file():
+                    try:
+                        apply_diff_msg = override_path.read_text(encoding="utf-8")
+                        if logger.isEnabledFor(logging.DEBUG):
+                            logger.debug(
+                                "Loaded apply_diff steering prompt from %s",
+                                override_path,
+                            )
+                    except Exception:
+                        logger.warning(
+                            "Failed to read apply_diff steering prompt from %s, using default.",
+                            override_path,
+                            exc_info=True,
+                        )
+
+                effective_rules.append(
+                    {
+                        "name": "apply_diff_to_patch_file",
+                        "enabled": True,
+                        "priority": 100,
+                        "triggers": {
+                            "tool_names": ["apply_diff"],
+                            "phrases": [],
+                        },
+                        "message": (
+                            apply_diff_msg
+                            or (
+                                "You tried to use apply_diff tool. Please prefer to use patch_file tool instead, "
+                                "as it is superior to apply_diff and provides automated Python QA checks."
+                            )
+                        ),
+                        "rate_limit": {
+                            "calls_per_window": 1,
+                            "window_seconds": reactor_config.apply_diff_steering_rate_limit_seconds,
+                        },
+                    }
+                )
+
+        return ConfiguredRulesPolicy(
+            session_store=provider.get_required_service(SessionStateStore),
+            rules=effective_rules,
+            enabled=True,
+        )
+
+    def _register_unified_steering_handler(
+        self, services: ServiceCollection, config: AppConfig
+    ) -> None:
+        """Register unified steering handler with policies."""
+        try:
+            from src.services.steering import UnifiedSteeringHandler
+            from src.services.steering.policies import (
+                InlinePythonPolicy,
+                PytestFullSuitePolicy,
+            )
+
+            def handler_factory(provider: IServiceProvider) -> UnifiedSteeringHandler:
+                """Factory for creating unified steering handler with policies."""
+                policies = [
+                    provider.get_required_service(InlinePythonPolicy),
+                    provider.get_required_service(PytestFullSuitePolicy),
+                    provider.get_required_service(ConfiguredRulesPolicy),
+                ]
+
+                reactor_config = config.session.tool_call_reactor
+                priority_overrides = getattr(
+                    reactor_config, "steering_policy_priorities", None
+                )
+                emit_legacy_log_enabled = getattr(
+                    reactor_config, "emit_legacy_steering_log", False
+                )
+
+                return UnifiedSteeringHandler(
+                    policies=policies,
+                    enabled=True,
+                    priority_overrides=priority_overrides,
+                    emit_legacy_log_enabled=emit_legacy_log_enabled,
+                )
+
+            services.add_singleton(
+                UnifiedSteeringHandler, implementation_factory=handler_factory
+            )
+
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("Registered UnifiedSteeringHandler")
+        except Exception as e:
+            if logger.isEnabledFor(logging.WARNING):
+                logger.warning(f"Could not register UnifiedSteeringHandler: {e}")

src/core/config/app_config.py

@@ -364,6 +364,21 @@ class ToolCallReactorConfig(DomainModel):
     enabled: bool = True
     """Whether the Tool Call Reactor is enabled."""
 
+    unified_steering_enabled: bool = True
+    """Whether to use the unified steering handler (replacing legacy handlers)."""
+
+    emit_legacy_steering_log: bool = True
+    """Whether to emit a legacy-formatted steering log for compatibility."""
+
+    steering_policy_priorities: dict[str, int] | None = None
+    """Overrides for steering policy priorities. Map of policy name to priority integer."""
+
+    steering_session_ttl_seconds: int = 1800
+    """TTL in seconds for steering session state (default 30 mins)."""
+
+    steering_max_sessions: int = 1024
+    """Maximum number of sessions to track in steering state store."""
+
     apply_diff_steering_enabled: bool = True
     """Whether the legacy apply_diff steering handler is enabled."""
 
@@ -386,6 +401,12 @@ class ToolCallReactorConfig(DomainModel):
     pytest_full_suite_steering_message: str | None = None
     """Optional custom steering message when detecting full pytest suite runs."""
 
+    inline_python_steering_enabled: bool = True
+    """Whether inline Python execution steering is enabled."""
+
+    inline_python_steering_message: str | None = None
+    """Optional custom steering message for inline Python execution."""
+
     pytest_context_saving_enabled: bool = False
     """Whether pytest context-saving command rewrites are enabled."""