teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/action_changeset_builder.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+from teddy_executor.core.domain.models.change_set import ChangeSet
+from teddy_executor.core.services.validation_rules.helpers import (
+    resolve_similarity_threshold,
+)
+
+if TYPE_CHECKING:
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.core.ports.outbound import (
+        IFileSystemManager,
+        IConfigService,
+    )
+    from teddy_executor.core.ports.inbound.edit_simulator import IEditSimulator
+
+
+class ActionChangeSetBuilder:
+    """
+    Shared service to build ChangeSet objects for CREATE and EDIT actions.
+    Ensures DRY logic between executors and reviewers.
+    """
+
+    @staticmethod
+    def format_action_prompt(action: "ActionData") -> str:
+        """Generates a detailed prompt string for an action."""
+        prompt_parts = [
+            "---",
+            f"Action: {action.type}",
+            f"Description: {action.description}" if action.description else "",
+        ]
+        display_map = {"handoff_resources": "Reference Files"}
+        param_str = "\n".join(
+            f"  - {display_map.get(k, k)}: {v}"
+            for k, v in action.params.items()
+            if k.lower() not in ("edits", "content")
+        )
+        if param_str:
+            prompt_parts.extend(["Parameters:", param_str])
+        prompt_parts.append("---")
+        return "\n".join(filter(None, prompt_parts))
+
+    def __init__(
+        self,
+        file_system_manager: IFileSystemManager,
+        config_service: IConfigService,
+        edit_simulator: IEditSimulator,
+    ):
+        self._file_system_manager = file_system_manager
+        self._config_service = config_service
+        self._edit_simulator = edit_simulator
+
+    def create_change_set(self, action: "ActionData") -> Optional[ChangeSet]:
+        """Creates a ChangeSet for file operations."""
+        action_type = action.type.upper()
+        if action_type not in ("CREATE", "EDIT"):
+            return None
+
+        path_str = action.params.get("path") or action.params.get("File Path")
+        if not path_str:
+            return None
+
+        before_content = (
+            self._file_system_manager.read_raw_file(path_str)
+            if self._file_system_manager.path_exists(path_str)
+            else ""
+        )
+        path = Path(path_str)
+
+        if action_type == "EDIT":
+            threshold = resolve_similarity_threshold(
+                self._config_service, action.params
+            )
+
+            match_all = action.params.get("match_all", False)
+            after_content, _ = self._edit_simulator.simulate_edits(
+                before_content,
+                action.params.get("edits", []),
+                threshold=threshold,
+                match_all=match_all,
+            )
+        else:  # CREATE
+            after_content = action.params.get("content", "")
+
+        return ChangeSet(
+            path=path,
+            before_content=before_content,
+            after_content=after_content,
+            action_type=action_type,
+        )

teddy_executor/core/services/action_diff_manager.py

@@ -0,0 +1,110 @@
+from typing import Optional
+from teddy_executor.core.domain.models import (
+    ActionLog,
+    ActionStatus,
+    ChangeSet,
+)
+from teddy_executor.core.utils.diff import generate_unified_diff
+
+# Constant for perfect match detection to avoid floating point noise
+PERFECT_MATCH_THRESHOLD = 0.99999
+
+
+class ActionDiffManager:
+    """Helper class to manage diff injection and suppression logic."""
+
+    @staticmethod
+    def inject_diff(
+        action, action_log: ActionLog, change_set: Optional[ChangeSet]
+    ) -> ActionLog:
+        """Injects or suppresses diffs in the ActionLog based on outcome."""
+        if ActionDiffManager._should_suppress(action, action_log, change_set):
+            return ActionDiffManager._clean_log(action_log)
+
+        diff = ActionDiffManager._generate_diff(action, change_set)
+        if not diff:
+            return action_log
+
+        details = action_log.details
+        new_details = {"diff": diff}
+        if isinstance(details, dict):
+            new_details.update(details)
+
+        return ActionLog(
+            status=action_log.status,
+            action_type=action_log.action_type,
+            params=action_log.params,
+            details=new_details,
+            modified=action_log.modified,
+            modified_fields=action_log.modified_fields,
+        )
+
+    @staticmethod
+    def _should_suppress(
+        action, action_log: ActionLog, change_set: Optional[ChangeSet]
+    ) -> bool:
+        """Determines if a diff should be suppressed."""
+        if action_log.status != ActionStatus.SUCCESS:
+            return True
+
+        is_create_ovr = (
+            action.type.upper() == "CREATE"
+            and (action.params.get("overwrite") or action.params.get("Overwrite"))
+            and change_set
+            and change_set.before_content
+        )
+        is_edit = action.type.upper() == "EDIT"
+
+        if not (is_create_ovr or is_edit):
+            return True
+
+        if is_edit:
+            details = action_log.details
+            if not isinstance(details, dict):
+                return True
+            scores = details.get("similarity_scores") or [
+                details.get("similarity_score", 1.0)
+            ]
+            if all(s >= PERFECT_MATCH_THRESHOLD for s in scores):
+                return True
+
+        return not (
+            change_set
+            and isinstance(change_set.before_content, str)
+            and isinstance(change_set.after_content, str)
+        )
+
+    @staticmethod
+    def _clean_log(action_log: ActionLog) -> ActionLog:
+        """Removes pre-injected diffs from the log."""
+        if isinstance(action_log.details, dict) and "diff" in action_log.details:
+            new_details = action_log.details.copy()
+            new_details.pop("diff")
+            return ActionLog(
+                status=action_log.status,
+                action_type=action_log.action_type,
+                params=action_log.params,
+                details=new_details,
+                modified=action_log.modified,
+                modified_fields=action_log.modified_fields,
+            )
+        return action_log
+
+    @staticmethod
+    def _generate_diff(action, change_set: Optional[ChangeSet]) -> Optional[str]:
+        """Generates the actual diff string."""
+        if not change_set:
+            return None
+
+        from teddy_executor.core.utils.diff import generate_character_diff
+
+        if action.type.upper() == "EDIT":
+            return generate_character_diff(
+                change_set.before_content, change_set.after_content
+            )
+
+        return generate_unified_diff(
+            change_set.before_content,
+            change_set.after_content,
+            change_set.path.name,
+        )

teddy_executor/core/services/action_dispatcher.py

@@ -0,0 +1,142 @@
+import logging
+from dataclasses import is_dataclass, asdict
+from typing import Protocol, Any, Optional
+
+from teddy_executor.core.domain.models import (
+    ActionData,
+    ActionLog,
+    ActionStatus,
+)
+from teddy_executor.core.domain.models.shell_output import ShellOutput
+
+
+# --- Protocols for Dependencies ---
+
+
+class IAction(Protocol):
+    """Defines the interface for any action handler."""
+
+    def execute(self, **_kwargs) -> Any: ...
+
+
+class IActionFactory(Protocol):
+    """Defines the interface for the factory that creates actions."""
+
+    def create_action(
+        self, action_type: str, params: Optional[dict] = None
+    ) -> IAction: ...
+
+
+logger = logging.getLogger(__name__)
+
+# --- Service Implementation ---
+
+
+class ActionDispatcher:
+    """
+    A service that dispatches a single action to its handler and logs the result.
+    """
+
+    def __init__(self, action_factory: IActionFactory):
+        self._action_factory = action_factory
+
+    def _prepare_execution_params(self, action_data: ActionData) -> dict[str, Any]:
+        """Handles parameter validation, translation, and cleaning."""
+        params = action_data.params.copy()
+        if not isinstance(params, dict):
+            if action_data.type == "execute":
+                return {"command": params}
+            raise TypeError(
+                f"Action type '{action_data.type}' requires dictionary parameters, but received type '{type(params).__name__}'."
+            )
+
+        param_map = {
+            "create_file": {"file_path": "path"},
+            "edit": {"file_path": "path"},
+            "read": {"source": "path", "resource": "path"},
+        }
+        type_key = action_data.type.lower()
+        if type_key == "create":
+            type_key = "create_file"
+
+        mapping = param_map.get(type_key, {})
+        for old_key, new_key in mapping.items():
+            if old_key in params:
+                params[new_key] = params.pop(old_key)
+
+        params.pop("expected_outcome", None)
+        params.pop("Description", None)
+
+        # Filter out internal metadata keys (convention: starts with 'metadata_')
+        clean_params = {
+            k: v for k, v in params.items() if not k.startswith("metadata_")
+        }
+
+        return clean_params
+
+    def _execute_and_process_result(
+        self, action_type: str, execution_params: dict[str, Any]
+    ) -> tuple[Any, ActionStatus]:
+        """Executes the action, normalizes the result, and determines status."""
+        action_handler = self._action_factory.create_action(
+            action_type, execution_params
+        )
+        result = action_handler.execute(**execution_params)
+
+        if is_dataclass(result) and not isinstance(result, type):
+            result = asdict(result)
+
+        if isinstance(result, str):
+            if action_type.lower() == "read":
+                result = {"content": result}
+        elif action_type.lower() == "edit" and isinstance(result, list):
+            # edit_file now returns a list of scores
+            result = {"similarity_scores": result}
+
+        status = ActionStatus.SUCCESS
+        if isinstance(result, dict) and "return_code" in result:
+            shell_output: ShellOutput = result  # type: ignore
+            if shell_output["return_code"] != 0:
+                status = ActionStatus.FAILURE
+        return result, status
+
+    def dispatch_and_execute(
+        self, action_data: ActionData, agent_name: Optional[str] = None
+    ) -> ActionLog:
+        """
+        Takes an ActionData object, finds the corresponding action handler
+        via the factory, executes it, and returns the result as an ActionLog.
+        """
+        action_name = action_data.type.upper()
+        log_desc = f" - {action_data.description}" if action_data.description else ""
+        is_message_action = action_data.type.upper() == "MESSAGE"
+        if not is_message_action:
+            logger.info(f"{action_name}{log_desc}")
+
+        log_params = action_data.params.copy()
+        if action_data.description and "Description" not in log_params:
+            log_params["Description"] = action_data.description
+
+        log_data: dict = {
+            "action_type": action_data.type,
+            "params": log_params,
+            "modified": action_data.modified,
+            "modified_fields": action_data.modified_fields,
+        }
+
+        try:
+            execution_params = self._prepare_execution_params(action_data)
+            details, status = self._execute_and_process_result(
+                action_data.type, execution_params
+            )
+            log_data["details"] = details
+            log_data["status"] = status
+            if not is_message_action:
+                logger.info(status.value.upper())
+        except Exception as e:
+            log_data["status"] = ActionStatus.FAILURE
+            log_data["details"] = str(e)
+            if not is_message_action:
+                logger.info("FAILURE")
+
+        return ActionLog(**log_data)

teddy_executor/core/services/action_executor.py

@@ -0,0 +1,209 @@
+import hashlib
+import logging
+from typing import Optional
+
+from teddy_executor.core.domain.models import (
+    ActionLog,
+    ActionStatus,
+    ChangeSet,
+)
+from teddy_executor.core.ports.inbound.edit_simulator import IEditSimulator
+from teddy_executor.core.services.action_diff_manager import ActionDiffManager
+from teddy_executor.core.services.action_changeset_builder import ActionChangeSetBuilder
+from teddy_executor.core.ports.outbound import (
+    IConfigService,
+    IFileSystemManager,
+    IUserInteractor,
+)
+from teddy_executor.core.services.action_dispatcher import ActionDispatcher
+
+logger = logging.getLogger(__name__)
+
+# Constant for perfect match detection to avoid floating point noise
+PERFECT_MATCH_THRESHOLD = 0.99999
+
+
+class ActionExecutor:
+    """
+    Handles the execution logic for a single action, including isolation,
+    interception, and user confirmation.
+    """
+
+    def __init__(
+        self,
+        action_dispatcher: ActionDispatcher,
+        user_interactor: IUserInteractor,
+        file_system_manager: IFileSystemManager,
+        edit_simulator: IEditSimulator,
+        config_service: IConfigService,
+    ):
+        self._action_dispatcher = action_dispatcher
+        self._user_interactor = user_interactor
+        self._file_system_manager = file_system_manager
+        self._changeset_builder = ActionChangeSetBuilder(
+            file_system_manager, config_service, edit_simulator
+        )
+        self._file_hashes: dict[str, str] = {}
+
+    def _create_intercepted_log(
+        self, action, status: ActionStatus, details: str
+    ) -> ActionLog:
+        """Creates an ActionLog for an intercepted action (skip or handoff)."""
+        log_params = action.params.copy()
+        if action.description:
+            log_params["Description"] = action.description
+        return ActionLog(
+            status=status,
+            action_type=action.type,
+            params=log_params,
+            details=details,
+            modified=action.modified,
+            modified_fields=action.modified_fields,
+        )
+
+    def _compute_file_hash(self, path: str) -> str:
+        """Computes SHA256 hash of file content for mid-execution consistency checks."""
+        content = self._file_system_manager.read_file(path)
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def _handle_skipped_action(self, action, reason: str) -> ActionLog:
+        """Creates an ActionLog for a skipped action."""
+        return self._create_intercepted_log(action, ActionStatus.SKIPPED, reason)
+
+    def _enrich_failed_log(self, action, action_log: ActionLog) -> ActionLog:
+        """If a CREATE or EDIT action failed, enrich the log with file content."""
+        if action.type not in ("CREATE", "EDIT"):
+            return action_log
+
+        path = action.params.get("path") or action.params.get("File Path")
+        if not path:
+            return action_log
+
+        try:
+            content = self._file_system_manager.read_file(path)
+            new_details = (
+                action_log.details
+                if isinstance(action_log.details, dict)
+                else {"original_details": action_log.details}
+            )
+            new_details["content"] = content
+            return ActionLog(
+                status=action_log.status,
+                action_type=action_log.action_type,
+                params=action_log.params,
+                details=new_details,
+                modified=action_log.modified,
+                modified_fields=action_log.modified_fields,
+            )
+        except Exception as e:
+            logger.debug(
+                "Failed to enrich failed log with file content for %s: %s", path, e
+            )
+            return action_log
+
+    def _create_change_set(self, action) -> ChangeSet | None:
+        """Creates a ChangeSet for file operations."""
+        return self._changeset_builder.create_change_set(action)
+
+    def _get_interactive_confirmation(self, action) -> tuple[bool, str]:
+        """Prompts the user for confirmation of an action."""
+        prompt = ActionChangeSetBuilder.format_action_prompt(action)
+
+        change_set = self._create_change_set(action)
+
+        return self._user_interactor.confirm_action(
+            action=action, action_prompt=prompt, change_set=change_set
+        )
+
+    def confirm_and_dispatch(  # noqa: PLR0913, C901
+        self,
+        action,
+        interactive: bool,
+        total_actions: int,
+        agent_name: Optional[str] = None,
+        is_session: bool = False,
+        skip_isolation: bool = False,
+    ) -> tuple[ActionLog, str]:
+        """Handles user confirmation and dispatches a single action."""
+        # Capture the change set BEFORE execution for diff reporting
+        change_set = self._create_change_set(action)
+
+        should_dispatch, reason = True, ""
+        # Communication actions (MESSAGE) bypass the interactive confirmation
+        # to ensure a fluid conversational flow.
+        is_communication = action.type.upper() == "MESSAGE"
+
+        if interactive and not is_communication:
+            should_dispatch, reason = self._get_interactive_confirmation(action)
+
+        if not should_dispatch:
+            return (
+                self._handle_skipped_action(
+                    action, f"User skipped this action. Reason: {reason}"
+                ),
+                "",
+            )
+
+        # Mid-execution consistency: pre-check hash for EDIT actions
+        path = action.params.get("path")
+        if action.type.upper() == "EDIT" and path and path in self._file_hashes:
+            try:
+                current_hash = self._compute_file_hash(path)
+                if current_hash != self._file_hashes[path]:
+                    logger.error(
+                        "EDIT pre-check failed: file content modified during "
+                        "execution for %s",
+                        path,
+                    )
+                    return (
+                        ActionLog(
+                            status=ActionStatus.FAILURE,
+                            action_type="EDIT",
+                            params=action.params.copy(),
+                            details="File content modified during execution",
+                        ),
+                        reason,
+                    )
+            except OSError:  # safe to ignore
+                # If we can't read the file, proceed with normal dispatch
+                pass
+
+        action_log = self._action_dispatcher.dispatch_and_execute(
+            action, agent_name=agent_name
+        )
+
+        if action_log.status == ActionStatus.FAILURE:
+            return self._enrich_failed_log(action, action_log), reason
+
+        # Post-dispatch: update hash for EDIT, clear for EXECUTE
+        if action.type.upper() == "EDIT" and path:
+            try:
+                self._file_hashes[path] = self._compute_file_hash(path)
+            except OSError:  # safe to ignore
+                pass
+        elif action.type.upper() == "EXECUTE":
+            self._file_hashes.clear()
+
+        # For success, we still want to return the message captured via 'm'
+        # For MESSAGE actions, return the user's typed message from action_log.details
+        # instead of the empty reason string.
+        captured_message = action_log.details if is_communication else reason
+        return (
+            ActionDiffManager.inject_diff(action, action_log, change_set),
+            captured_message,
+        )
+
+    def handle_skipped_action(self, action, reason: str) -> ActionLog:
+        """Public method for skipping actions."""
+        return self._handle_skipped_action(action, reason)
+
+    def handle_failed_action(self, action, details: str) -> ActionLog:
+        """Creates an ActionLog for an action that failed during preparation."""
+        return self._create_intercepted_log(action, ActionStatus.FAILURE, details)
+
+    def reset_file_hashes(self) -> None:
+        """
+        Clears all stored file hashes. Called at the start of each plan execution
+        to prevent stale hashes from previous turns from causing false pre-check failures.
+        """
+        self._file_hashes.clear()