teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/session_pruning_service.py

@@ -0,0 +1,438 @@
+import re
+from dataclasses import is_dataclass, replace
+from typing import Any, Dict, Optional
+
+from teddy_executor.core.domain.models import ProjectContext
+from teddy_executor.core.ports.outbound.config_service import IConfigService
+from teddy_executor.core.ports.outbound.file_system_manager import IFileSystemManager
+
+
+class SessionPruningService:
+    """
+    Encapsulates auto-pruning heuristics for session context.
+    """
+
+    def __init__(
+        self,
+        config_service: IConfigService,
+        file_system_manager: IFileSystemManager,
+    ):
+        self._config_service = config_service
+        self._file_system_manager = file_system_manager
+        self._read_cache: Dict[str, str] = {}
+
+    def prune(
+        self, context: ProjectContext, current_status: Optional[str] = None
+    ) -> ProjectContext:
+        """Applies configured auto-pruning heuristics to the project context."""
+        self._read_cache.clear()
+        try:
+            if not self._config_service.get_setting("auto_pruning.enabled", True):
+                return context
+
+            # Handle MagicMocks in unit tests
+            if not is_dataclass(context):
+                return context
+
+            items = list(context.items)
+
+            # 1. Prune by status/validation failure (Heuristics 3 & 4)
+            turns_to_prune = self._identify_turns_to_prune(items, current_status)
+
+            for i, item in enumerate(items):
+                new_item = self._process_context_item(item, turns_to_prune)
+                if new_item is not item:
+                    items[i] = new_item
+
+            # 2. Heuristic 6: Retention Limit
+            items = self._apply_retention_limit(items)
+
+            # 3. Heuristic 2: Global Budget
+            items = self._apply_global_budget(
+                items,
+            )
+
+            return replace(context, items=items)
+        except Exception as e:
+            # Failure Transparency: Log and re-raise or return original context
+            import sys
+
+            print(f"[ERROR] PruningService failure: {e}", file=sys.stderr)
+            return context
+
+    def _process_context_item(self, item: Any, turns_to_prune: Dict[str, str]) -> Any:
+        """Processes an individual context item for pruning."""
+        if item.scope != "Turn":
+            return item
+
+        if item.git_status == "D":
+            return replace(
+                item, selected=False, auto_prune_reason="File deleted from disk"
+            )
+
+        # Normalize path for consistent string matching
+        posix_path = item.path.replace("\\", "/").removeprefix("./").lstrip("/")
+
+        # Match numeric turn directories (e.g. '01', '02')
+        turn_id = self._extract_turn_id(posix_path)
+        if turn_id:
+            # Check both raw string and integer-normalized version
+            reason = turns_to_prune.get(turn_id) or turns_to_prune.get(
+                str(int(turn_id))
+            )
+            if reason:
+                return replace(
+                    item,
+                    selected=False,
+                    auto_prune_reason=reason,
+                )
+
+        return item
+
+    def _extract_turn_id(self, path: str) -> Optional[str]:
+        """Extracts the last numeric directory segment from the path."""
+        if not isinstance(path, str):
+            return None
+        # Normalize to forward slashes and strip prefixes for consistent matching
+        normalized = path.replace("\\", "/").removeprefix("./").lstrip("/")
+        # Turn IDs are typically 1-3 digits. 4+ digits usually represent years or other data.
+        matches = re.findall(r"(?:^|/)(\d{1,3})(?=/|$)", normalized)
+        return matches[-1] if matches else None
+
+    def _identify_turns_to_prune(
+        self, items, current_status: Optional[str] = None
+    ) -> Dict[str, str]:
+        """Identifies turns that should be pruned based on failure status."""
+        prune_non_green = bool(
+            self._config_service.get_setting("auto_pruning.prune_failure_history", True)
+        )
+        prune_validation = bool(
+            self._config_service.get_setting(
+                "auto_pruning.prune_validation_failures", True
+            )
+        )
+
+        turn_statuses, validation_failures, non_vf_reports = (
+            self._collect_turn_metadata(items, prune_non_green, prune_validation)
+        )
+
+        turns_to_prune = self._apply_pruning_heuristics(
+            turn_statuses,
+            validation_failures,
+            prune_non_green,
+            current_status,
+            non_vf_reports,
+        )
+
+        return turns_to_prune
+
+    def _collect_turn_metadata(
+        self,
+        items,
+        prune_non_green: bool,
+        prune_validation: bool,
+    ) -> tuple[Dict[int, bool], set[int], set[int]]:
+        """Scans items to determine turn statuses, validation failures, and non-VF reports."""
+        turn_statuses: Dict[int, bool] = {}
+        validation_failures: set[int] = set()
+        non_vf_reports: set[int] = set()
+        checked_paths = set()
+
+        for item in items:
+            if item.scope != "Turn" or item.path in checked_paths:
+                continue
+
+            posix_path = item.path.replace("\\", "/")
+            turn_id_str = self._extract_turn_id(posix_path)
+            if not turn_id_str:
+                continue
+
+            turn_id = int(turn_id_str)
+            checked_paths.add(item.path)
+
+            self._update_turn_metadata_from_item(
+                item,
+                posix_path,
+                turn_id,
+                {
+                    "statuses": turn_statuses,
+                    "validation_fails": validation_failures,
+                    "non_vf_reports": non_vf_reports,
+                },
+                {
+                    "non_green": prune_non_green,
+                    "validation": prune_validation,
+                },
+            )
+
+        return turn_statuses, validation_failures, non_vf_reports
+
+    def _update_turn_metadata_from_item(
+        self,
+        item: Any,
+        posix_path: str,
+        turn_id: int,
+        state: Dict[str, Any],
+        config: Dict[str, bool],
+    ) -> None:
+        """Processes a single item to update turn-level metadata."""
+        self._update_metadata_from_report(item, posix_path, turn_id, state, config)
+        self._update_metadata_from_plan(item, posix_path, turn_id, state, config)
+
+    def _update_metadata_from_report(
+        self,
+        item: Any,
+        posix_path: str,
+        turn_id: int,
+        state: Dict[str, Any],
+        config: Dict[str, bool],
+    ) -> None:
+        """Processes a report.md item for validation failure and sparing metadata."""
+        if not posix_path.endswith("report.md"):
+            return
+
+        # Heuristic 4: Validation failure
+        if config.get("validation") and self._check_report_failed_validation(item.path):
+            state["validation_fails"].add(turn_id)
+
+        # Non-VF reports for Heuristic 4 guard
+        if self._check_report_is_non_vf_report(item.path):
+            state["non_vf_reports"].add(turn_id)
+
+    def _update_metadata_from_plan(
+        self,
+        item: Any,
+        posix_path: str,
+        turn_id: int,
+        state: Dict[str, Any],
+        config: Dict[str, bool],
+    ) -> None:
+        """Processes a plan.md item for status and message sparing metadata."""
+        if not posix_path.endswith("plan.md"):
+            return
+
+        # Heuristic 3: Non-green state
+        is_failed = self._check_plan_failed(item.path)
+        if config["non_green"]:
+            is_green = not is_failed
+            # If any file in turn is non-green, the whole turn is non-green
+            state["statuses"][turn_id] = (
+                state["statuses"].get(turn_id, True) and is_green
+            )
+
+    def _check_plan_failed(self, path: str) -> bool:
+        """Checks if a plan file contains a failure status emoji on the status line."""
+        content = self._safe_read(path)
+        if content:
+            # Anchored to start of line to avoid matches in rationales or code blocks
+            return bool(re.search(r"^- \*\*Status:\*\*.*[🔴🟡]", content, re.MULTILINE))
+        return False
+
+    def _check_report_failed_validation(self, path: str) -> bool:
+        """Checks if a report file contains the official validation failure status."""
+        content = self._safe_read(path)
+        if content:
+            # Anchored to target the standardized overall status line
+            return bool(
+                re.search(
+                    r"^- \*\*Overall Status:\*\* Validation Failed",
+                    content,
+                    re.MULTILINE,
+                )
+            )
+        return False
+
+    def _check_report_is_non_vf_report(self, path: str) -> bool:
+        """Checks if a report file exists and does NOT have validation failure status."""
+        content = self._safe_read(path)
+        if content:
+            return not bool(
+                re.search(
+                    r"^- \*\*Overall Status:\*\* Validation Failed",
+                    content,
+                    re.MULTILINE,
+                )
+            )
+        return False
+
+    def _check_report_is_success(self, path: str) -> bool:
+        """Checks if a report file contains the official success status."""
+        content = self._safe_read(path)
+        if content:
+            # Anchored to target the standardized overall status line
+            return bool(
+                re.search(
+                    r"^- \*\*Overall Status:\*\* SUCCESS",
+                    content,
+                    re.MULTILINE,
+                )
+            )
+        return False
+
+    def _safe_read(self, path: str) -> Optional[str]:
+        """Reads a file with caching and error handling."""
+        if path in self._read_cache:
+            return self._read_cache[path]
+        try:
+            if self._file_system_manager.path_exists(path):
+                content = self._file_system_manager.read_file(path)
+                self._read_cache[path] = content
+                return content
+        except (FileNotFoundError, OSError):
+            pass
+        return None
+
+    def _check_file_contains(self, path: str, patterns: str | tuple[str, ...]) -> bool:
+        """Safely checks if a file exists and contains specific patterns."""
+        try:
+            if self._file_system_manager.path_exists(path):
+                content = self._file_system_manager.read_file(path)
+                if isinstance(patterns, str):
+                    return patterns in content
+                return any(p in content for p in patterns)
+        except (FileNotFoundError, OSError):
+            pass
+        return False
+
+    def _apply_pruning_heuristics(
+        self,
+        turn_statuses: Dict[int, bool],
+        validation_failures: set[int],
+        prune_non_green: bool,
+        current_status: Optional[str] = None,
+        non_vf_reports: Optional[set[int]] = None,
+    ) -> Dict[str, str]:
+        """Applies heuristics to the collected metadata."""
+        turns_to_prune: Dict[str, str] = {}
+
+        # Heuristic 4: Validation Failure (guarded by non-VF report)
+        is_currently_non_vf = (
+            current_status is not None and "Validation Failed" not in current_status
+        )
+        latest_non_vf_turn = max(non_vf_reports) if non_vf_reports else -1
+
+        for tid in sorted(validation_failures):
+            prune_vf = tid < latest_non_vf_turn
+            if not prune_vf and is_currently_non_vf:
+                prune_vf = True
+            if prune_vf:
+                turns_to_prune[str(tid)] = "Plan failed validation"
+
+        # Heuristic 3: Recovery Cleanup
+        # If current_status is Green, OR if the latest turn on disk is Green, prune failures.
+        is_currently_green = current_status is not None and "🟢" in current_status
+
+        if prune_non_green and turn_statuses:
+            latest_on_disk = max(turn_statuses.keys())
+            is_latest_green = turn_statuses[latest_on_disk]
+
+            if is_currently_green or is_latest_green:
+                for tid, is_green in turn_statuses.items():
+                    if not is_green:
+                        turns_to_prune.setdefault(
+                            str(tid), "Pruned failure history after successful recovery"
+                        )
+
+        return turns_to_prune
+
+    def _apply_retention_limit(self, items):
+        """Prunes turn context items that exceed the turn retention limit."""
+        try:
+            setting = self._config_service.get_setting(
+                "auto_pruning.max_turns_retention", 0
+            )
+            limit = int(setting) if setting is not None else 0
+        except (TypeError, ValueError):
+            limit = 0
+
+        if limit <= 0:
+            return items
+
+        turn_id_map, max_id = self._map_turn_ids(items)
+        if max_id == -1:
+            return items
+
+        # Calculate threshold and prune
+        threshold = max_id - limit
+        reason = f"Turn exceeds retention limit of {limit}"
+
+        for idx, tid in turn_id_map.items():
+            if tid <= threshold:
+                items[idx] = replace(
+                    items[idx],
+                    selected=False,
+                    auto_prune_reason=reason,
+                )
+
+        return items
+
+    def _map_turn_ids(self, items) -> tuple[Dict[int, int], int]:
+        """Identifies turn IDs and the maximum ID in the context items."""
+        max_id = -1
+        turn_id_map = {}  # idx -> int_id
+
+        for i, item in enumerate(items):
+            if item.scope != "Turn":
+                continue
+
+            tid_str = self._extract_turn_id(item.path)
+            if tid_str:
+                try:
+                    tid = int(tid_str)
+                    turn_id_map[i] = tid
+                    max_id = max(max_id, tid)
+                except (ValueError, TypeError):
+                    continue
+        return turn_id_map, max_id
+
+    def _get_turn_context_threshold(self) -> int:
+        """Reads the turn context threshold from config.
+
+        Reads ``auto_pruning.turn_context_threshold`` from config.
+        Returns 0 if not set or on parse errors (skips budget heuristic).
+        """
+        try:
+            threshold = self._config_service.get_setting(
+                "auto_pruning.turn_context_threshold"
+            )
+            return int(threshold) if threshold is not None else 0
+        except (TypeError, ValueError):
+            return 0
+
+    def _apply_global_budget(self, items):
+        """Prunes turn and history context items to fit within a global token budget."""
+        threshold = self._get_turn_context_threshold()
+
+        if threshold > 0:
+            # Sum selected items to reflect Turn-scope (system_prompt_tokens excluded per spec)
+            total_tokens = sum(
+                item.token_count
+                for item in items
+                if item.selected
+                and item.scope == "Turn"
+                and isinstance(item.token_count, (int, float))
+            )
+
+            if total_tokens > threshold:
+                # Gather eligible pruning candidates: standard Turn files (which includes history files in turn.context)
+                prune_candidates = [
+                    (i, item)
+                    for i, item in enumerate(items)
+                    if item.scope == "Turn"
+                    and item.selected
+                    and isinstance(item.token_count, (int, float))
+                ]
+
+                # Sort by token count descending to prune largest files first
+                prune_candidates.sort(key=lambda x: x[1].token_count, reverse=True)
+
+                for idx, item in prune_candidates:
+                    if total_tokens <= threshold:
+                        break
+                    items[idx] = replace(
+                        item,
+                        selected=False,
+                        auto_prune_reason="Pruned to fit context budget",
+                    )
+                    total_tokens -= item.token_count
+        return items

teddy_executor/core/services/session_replanner.py

@@ -0,0 +1,105 @@
+from datetime import datetime, timezone
+from typing import Any, Sequence
+
+from teddy_executor.core.domain.models.execution_report import (
+    ExecutionReport,
+    RunStatus,
+    RunSummary,
+)
+
+
+class SessionReplanner:
+    """
+    Orchestrates the feedback and planning logic for the Automated Re-plan Loop.
+    """
+
+    def __init__(self, file_system_manager, planning_service):
+        self._file_system_manager = file_system_manager
+        self._planning_service = planning_service
+
+    def build_failure_report(  # noqa: PLR0913
+        self,
+        errors: list[str],
+        title: str,
+        rationale: str,
+        failed_resources: dict[str, str],
+        validation_ast: str | None = None,
+        original_actions: Sequence[Any] | None = None,
+        is_session: bool = False,
+    ) -> ExecutionReport:
+        """Creates a validation failure report."""
+        now = datetime.now(timezone.utc)
+        summary = RunSummary(
+            status=RunStatus.VALIDATION_FAILED,
+            start_time=now,
+            end_time=now,
+            error="Plan validation failed.",
+        )
+        return ExecutionReport(
+            run_summary=summary,
+            plan_title=title,
+            rationale=rationale,
+            original_actions=original_actions or [],
+            action_logs=[],
+            validation_result=errors,
+            validation_ast=validation_ast,
+            failed_resources=failed_resources,
+            is_session=is_session,
+        )
+
+    def trigger_replan_turn(
+        self,
+        next_turn_dir: str,
+        errors: list[str],
+        original_content: str,
+        validation_ast: str | None = None,
+    ) -> None:
+        """Generates the feedback message and triggers the planning phase."""
+        feedback = self._build_feedback_message(
+            errors, original_content, validation_ast
+        )
+        self._planning_service.generate_plan(
+            user_message=feedback, turn_dir=next_turn_dir
+        )
+
+    def _build_feedback_message(
+        self, errors: list[str], original_content: str, validation_ast: str | None
+    ) -> str:
+        """Constructs the feedback message for the AI."""
+        error_msgs = [e.strip() for e in errors]
+        ast_section = f"\n{validation_ast}\n" if validation_ast else ""
+
+        return (
+            "The previous plan failed validation. Please review the errors and "
+            "the original plan, then generate a corrected version.\n\n"
+            "## Validation Errors:\n"
+            + "\n\n---\n\n".join(error_msgs)
+            + "\n"
+            + ast_section
+            + "\n"
+            f"## Original Faulty Plan:\n"
+            f"````````````markdown\n{original_content}\n````````````"
+        )
+
+    def gather_failed_resources(
+        self, errors: list, is_session: bool = False
+    ) -> dict[str, str]:
+        """Collects the contents of files that caused validation errors.
+        If is_session is True, skip I/O since Resource Contents are already in input.md.
+        """
+        if is_session:
+            return {}
+        resources = {}
+        for error in errors:
+            path = getattr(error, "file_path", None)
+            if path:
+                try:
+                    clean_path = path.lstrip("/")
+                    if self._file_system_manager.path_exists(clean_path):
+                        resources[path] = self._file_system_manager.read_file(
+                            clean_path
+                        )
+                except Exception:  # nosec B112
+                    # Best effort resource gathering; skip if file is unreadable
+                    continue
+        return resources