teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/action_factory.py

@@ -0,0 +1,197 @@
+from typing import Any, Dict, Optional
+from teddy_executor.core.domain.models.action_ports import ActionPorts
+from teddy_executor.core.domain.models.plan import DEFAULT_SIMILARITY_THRESHOLD
+from teddy_executor.core.services.action_dispatcher import IAction, IActionFactory
+
+
+class ActionFactory(IActionFactory):
+    """
+    A protocol-compliant factory that resolves action handlers from injected ports.
+    """
+
+    # Maps uppercase verbs from Markdown plans to the internal, descriptive keys.
+    _MARKDOWN_ACTION_MAP = {
+        "CREATE": "create_file",
+        "EDIT": "edit",
+        "READ": "read",
+        "EXECUTE": "execute",
+        "MESSAGE": "message",
+        "RESEARCH": "research",
+    }
+
+    def __init__(self, ports: ActionPorts):
+        self._shell_executor = ports.shell_executor
+        self._file_system_manager = ports.file_system_manager
+        self._user_interactor = ports.user_interactor
+        self._web_scraper = ports.web_scraper
+        self._web_searcher = ports.web_searcher
+        self._config_service = ports.config_service
+        self._standalone_actions: set[str] = set()
+        self._action_map: Dict[str, Any] = {
+            "execute": self._shell_executor,
+            "create_file": self._file_system_manager,
+            "edit": self._file_system_manager,
+            "read_file": self._file_system_manager,
+            "message": self._user_interactor,
+            "research": self._web_searcher,
+        }
+
+    def _normalize_action_type(self, action_type: str) -> str:
+        """
+        Normalizes action types from different plan formats to the internal key format.
+        """
+        # First, check the explicit mapping for Markdown verbs.
+        if action_type in self._MARKDOWN_ACTION_MAP:
+            return self._MARKDOWN_ACTION_MAP[action_type]
+        # Fallback to lowercasing for YAML/other formats.
+        return action_type.lower()
+
+    def _create_read_action(self, params: Optional[dict] = None) -> IAction:
+        """Handles the special routing for the READ action."""
+        safe_params = params or {}
+        resource = safe_params.get("resource", safe_params.get("path", ""))
+        if resource.startswith("http"):
+            # Return a wrapper instead of monkeypatching the adapter
+            class WebReadAction:
+                def __init__(self, scraper):
+                    self._scraper = scraper
+
+                def execute(self, **kwargs: Any) -> Any:
+                    return self._scraper.get_content(url=kwargs["path"])
+
+            return WebReadAction(self._web_scraper)
+
+        if safe_params.get("lines"):
+            # Lines-aware read: use read_raw_file (bypass truncation) and extract range
+            from teddy_executor.core.utils.string import extract_lines_range  # noqa: PLC0415
+
+            class LinesAwareReadAction:
+                def __init__(self, fs):
+                    self._fs = fs
+
+                def execute(self, **kwargs: Any) -> Any:
+                    path = kwargs.get("path", kwargs.get("resource", ""))
+                    content = self._fs.read_raw_file(path=path)
+                    lines_spec = kwargs.get("lines", "")
+                    return extract_lines_range(content, lines_spec)
+
+            return LinesAwareReadAction(self._file_system_manager)
+
+        # Fall through to the standard file system handler for local files
+        return self._create_standard_action("read_file", params)
+
+    def _get_action_wrapper(self, handler: Any, method_name: str) -> IAction:
+        """Returns an IAction wrapper around an adapter method."""
+        original_method = getattr(handler, method_name)
+
+        class ActionWrapper:
+            def __init__(self, factory, method):
+                self._factory = factory
+                self._method = method
+
+            def execute(self, **kwargs: Any) -> Any:
+                if "resource" in kwargs and "path" not in kwargs:
+                    kwargs["path"] = kwargs.pop("resource")
+
+                if method_name == "execute":
+                    return self._factory._handle_execute_protocol(self._method, kwargs)
+                if method_name == "edit_file":
+                    return self._factory._handle_edit_protocol(self._method, kwargs)
+                if method_name == "ask_question":
+                    return self._factory._handle_message_protocol(self._method, kwargs)
+                return self._method(**kwargs)
+
+        return ActionWrapper(self, original_method)
+
+    def _handle_execute_protocol(self, method: Any, kwargs: dict) -> Any:
+        """Handles the complex parameter injection for the EXECUTE action."""
+        execute_params = {
+            k: v
+            for k, v in kwargs.items()
+            if k in ("command", "cwd", "env", "background", "timeout", "max_lines")
+            and v is not None
+        }
+        if "command" not in execute_params:
+            raise ValueError("'command' parameter is required for the execute action.")
+
+        # Extract Tail override from action params and convert to max_lines
+        tail = kwargs.get("tail")
+        if tail is not None:
+            try:
+                tail_int = int(tail)
+                if tail_int > 0:
+                    execute_params["max_lines"] = tail_int
+            except (ValueError, TypeError):
+                pass  # Invalid tail value, fall back to default
+
+        # Inject global timeout if not already specified in kwargs
+        if "timeout" not in execute_params and self._config_service:
+            # Safe-by-Default: Provide hardcoded 60.0 fallback if config is missing
+            default_timeout = self._config_service.get_setting(
+                "execution.default_timeout_seconds", 60.0
+            )
+            if default_timeout is not None:
+                execute_params["timeout"] = float(default_timeout)
+
+        return method(**execute_params)
+
+    def _handle_edit_protocol(self, method: Any, kwargs: dict) -> Any:
+        """Handles the similarity threshold injection for the EDIT action."""
+        # 1. Inject from config if missing
+        if "similarity_threshold" not in kwargs and self._config_service:
+            # Safe-by-Default: Provide domain default if config is missing
+            global_threshold = self._config_service.get_setting(
+                "execution.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
+            )
+            if global_threshold is not None:
+                kwargs["similarity_threshold"] = float(global_threshold)
+        return method(**kwargs)
+
+    def _handle_message_protocol(self, method: Any, kwargs: dict) -> Any:
+        """Handles the positional argument mapping for the MESSAGE action."""
+        prompt = kwargs.get("prompt", kwargs.get("content", "")) or ""
+        return method(
+            prompt,
+            resources=kwargs.get("handoff_resources"),
+            agent_name=kwargs.get("agent_name"),
+        )
+
+    def _create_standard_action(
+        self, action_type: str, params: Optional[dict] = None
+    ) -> IAction:
+        """Creates an action handler for any action other than 'read'."""
+        action_type_key = self._normalize_action_type(action_type)
+        if action_type_key not in self._action_map:
+            raise ValueError(f"Unknown action type: '{action_type}'")
+
+        action_handler = self._action_map[action_type_key]
+        if action_handler in self._standalone_actions:
+            return action_handler()
+
+        method_map = {
+            "create_file": "create_file",
+            "edit": "edit_file",
+            "read_file": "read_file",
+            "message": "ask_question",
+            "research": "search",
+            "execute": "execute",
+        }
+
+        if action_type_key not in method_map:
+            if not hasattr(action_handler, "execute"):
+                raise NotImplementedError(
+                    f"Adapter for {action_type} does not have a mapped method "
+                    "or a default 'execute' method."
+                )
+            return action_handler
+
+        return self._get_action_wrapper(action_handler, method_map[action_type_key])
+
+    def create_action(self, action_type: str, params: Optional[dict] = None) -> IAction:
+        """
+        Looks up the adapter protocol for the given action type and binds the correct
+        adapter method to the `execute` method required by the IAction protocol.
+        """
+        if action_type.lower() == "read":
+            return self._create_read_action(params)
+        return self._create_standard_action(action_type, params)

teddy_executor/core/services/action_parser_complex.py

@@ -0,0 +1,216 @@
+from typing import Any, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+from teddy_executor.core.domain.models import ActionData, ActionType
+from teddy_executor.core.ports.inbound.plan_parser import InvalidPlanError
+from teddy_executor.core.services.parser_infrastructure import (
+    _PeekableStream,
+    get_child_text,
+    get_action_heading,
+    consume_content_until_next_action,
+)
+from teddy_executor.core.services.parser_metadata import (
+    parse_action_metadata,
+    parse_env_from_metadata,
+)
+
+
+def parse_find_replace_pair(stream: _PeekableStream) -> Optional[dict[str, Any]]:
+    from mistletoe.block_token import Heading, CodeFence, BlockCode
+
+    find_heading = stream.peek()
+    if not (
+        isinstance(find_heading, Heading) and "FIND:" in get_child_text(find_heading)
+    ):
+        return None
+
+    stream.next()
+    find_code = stream.next()
+    if not isinstance(find_code, (CodeFence, BlockCode)):
+        raise InvalidPlanError(
+            "Missing code block for FIND in EDIT action.", offending_node=find_code
+        )
+    find_content = get_child_text(find_code).rstrip("\n")
+
+    replace_heading = stream.next()
+    if not (
+        isinstance(replace_heading, Heading)
+        and "REPLACE:" in get_child_text(replace_heading)
+    ):
+        raise InvalidPlanError(
+            "Missing REPLACE block after FIND block",
+            offending_node=replace_heading,
+        )
+
+    replace_code = stream.next()
+    if not isinstance(replace_code, (CodeFence, BlockCode)):
+        raise InvalidPlanError(
+            "Missing REPLACE block after FIND block",
+            offending_node=replace_code,
+        )
+    replace_content = get_child_text(replace_code).rstrip("\n")
+
+    return {
+        "find": find_content,
+        "replace": replace_content,
+        "find_node": find_code,
+    }
+
+
+def parse_edit_action(
+    stream: _PeekableStream, valid_actions: set[str], node: Optional[Any] = None
+) -> ActionData:
+    from mistletoe.block_token import List as MdList
+
+    metadata_list = stream.next()
+    if not isinstance(metadata_list, MdList):
+        raise InvalidPlanError(
+            "EDIT action is missing metadata list.", offending_node=metadata_list
+        )
+    description, params = parse_action_metadata(
+        metadata_list,
+        link_key_map={"File Path": "path"},
+        text_key_map={
+            "Match All": "match_all",
+        },
+    )
+
+    if "match_all" in params:
+        params["match_all"] = str(params["match_all"]).lower() == "true"
+
+    edits = []
+    while stream.has_next():
+        if get_action_heading(stream.peek(), valid_actions):
+            break
+
+        pair = parse_find_replace_pair(stream)
+        if pair:
+            edits.append(pair)
+        else:
+            break
+
+    if not edits:
+        raise InvalidPlanError(
+            "EDIT action found no valid FIND/REPLACE blocks.",
+            offending_node=node,
+        )
+    params["edits"] = edits
+    return ActionData(type="EDIT", description=description, params=params, node=node)
+
+
+def parse_execute_action(
+    stream: _PeekableStream, node: Optional[Any] = None
+) -> ActionData:
+    from mistletoe.block_token import List as MdList, CodeFence
+
+    metadata_list = stream.next()
+    if not isinstance(metadata_list, MdList):
+        raise InvalidPlanError(
+            "EXECUTE action is missing metadata list.", offending_node=metadata_list
+        )
+
+    description, params = parse_action_metadata(
+        metadata_list,
+        text_key_map={
+            "Expected Outcome": "expected_outcome",
+            "cwd": "cwd",
+            "Allow Failure": "allow_failure",
+            "Background": "background",
+            "Timeout": "timeout",
+            "Tail": "tail",
+        },
+    )
+
+    if "allow_failure" in params:
+        params["allow_failure"] = params["allow_failure"].lower() == "true"
+
+    if "background" in params:
+        params["background"] = params["background"].lower() == "true"
+
+    if "timeout" in params and params["timeout"]:
+        try:
+            params["timeout"] = int(params["timeout"])
+        except ValueError:
+            # Leave as string, ActionFactory or validation will handle it
+            pass
+
+    env_from_meta = parse_env_from_metadata(metadata_list)
+    if env_from_meta:
+        params["env"] = env_from_meta
+
+    command_block = stream.next()
+    if not isinstance(command_block, CodeFence):
+        raise InvalidPlanError(
+            "EXECUTE action is missing command code block.",
+            offending_node=command_block,
+        )
+
+    params["command"] = get_child_text(command_block).strip()
+
+    return ActionData(type="EXECUTE", description=description, params=params, node=node)
+
+
+def parse_research_action(
+    stream: _PeekableStream, valid_actions: set[str], node: Optional[Any] = None
+) -> ActionData:
+    from mistletoe.block_token import List as MdList, CodeFence
+
+    metadata_list = stream.next()
+    if not isinstance(metadata_list, MdList):
+        raise InvalidPlanError("RESEARCH action is missing metadata list.")
+
+    description, _ = parse_action_metadata(metadata_list)
+    content_nodes = consume_content_until_next_action(stream, valid_actions)
+    queries = []
+    for content_node in content_nodes:
+        if isinstance(content_node, CodeFence):
+            raw_content = get_child_text(content_node)
+            for line in raw_content.splitlines():
+                query = line.strip()
+                if query:
+                    queries.append(query)
+    if not queries:
+        raise InvalidPlanError("RESEARCH action found no query code blocks.")
+    return ActionData(
+        type="RESEARCH",
+        description=description,
+        params={"queries": queries},
+        node=node,
+    )
+
+
+def parse_message_action(
+    stream: _PeekableStream,
+    node: Optional[Any] = None,
+    raw_content: Optional[str] = None,
+) -> ActionData:
+    """
+    Parses a MESSAGE action. If raw_content is provided (extracted directly
+    from the original plan text via heading line_number), use it as-is to
+    preserve blank lines and internal structure. Otherwise, fall back to
+    rendering AST nodes.
+    """
+    content = ""
+    if raw_content is not None:
+        content = raw_content.rstrip("\n")
+    elif stream.has_next():
+        from mistletoe.markdown_renderer import MarkdownRenderer
+
+        nodes = []
+        while stream.has_next():
+            nodes.append(stream.next())
+
+        if nodes:
+            with MarkdownRenderer() as renderer:
+                rendered_parts = [renderer.render(node) for node in nodes]
+                content = "".join(rendered_parts).strip()
+
+    return ActionData(
+        type=ActionType.MESSAGE,
+        description="Message to user",
+        params={"content": content},
+        node=node,
+    )

teddy_executor/core/services/action_parser_strategies.py

@@ -0,0 +1,84 @@
+from typing import Any, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+from teddy_executor.core.domain.models import ActionData
+from teddy_executor.core.ports.inbound.plan_parser import InvalidPlanError
+from teddy_executor.core.services.parser_infrastructure import (
+    _PeekableStream,
+)
+from teddy_executor.core.services.parser_metadata import (
+    parse_action_metadata,
+)
+
+
+def parse_create_action(
+    stream: _PeekableStream, node: Optional[Any] = None
+) -> ActionData:
+    from mistletoe.block_token import List as MdList, CodeFence
+
+    metadata_list = stream.next()
+    if not isinstance(metadata_list, MdList):
+        raise InvalidPlanError(
+            "CREATE action is missing metadata list.", offending_node=metadata_list
+        )
+
+    description, params = parse_action_metadata(
+        metadata_list,
+        link_key_map={"File Path": "path"},
+        text_key_map={"Overwrite": "overwrite"},
+    )
+
+    if "overwrite" in params:
+        params["overwrite"] = params["overwrite"].lower() == "true"
+
+    code_block = stream.next()
+    if not isinstance(code_block, CodeFence):
+        raise InvalidPlanError(
+            "CREATE action is missing a content code block.", offending_node=code_block
+        )
+
+    params["content"] = ""
+    if code_block.children:
+        children = list(code_block.children)
+        if children:
+            child = children[0]
+            if hasattr(child, "content"):
+                params["content"] = child.content.rstrip("\n")
+
+    return ActionData(type="CREATE", description=description, params=params, node=node)
+
+
+def parse_resource_action(
+    stream: _PeekableStream, action_type: str, node: Optional[Any] = None
+) -> ActionData:
+    from mistletoe.block_token import List as MdList
+
+    metadata_list = stream.next()
+    if not isinstance(metadata_list, MdList):
+        raise InvalidPlanError(
+            f"{action_type} action is missing metadata list.",
+            offending_node=metadata_list,
+        )
+
+    description, params = parse_action_metadata(
+        metadata_list,
+        link_key_map={"Resource": "resource", "File Path": "path_alias"},
+        text_key_map={"Lines": "lines"},
+    )
+
+    if "path_alias" in params:
+        params["resource"] = params.pop("path_alias")
+        params["metadata_used_file_path_alias"] = True
+
+    return ActionData(
+        type=action_type, description=description, params=params, node=node
+    )
+
+
+def parse_read_action(
+    stream: _PeekableStream, node: Optional[Any] = None
+) -> ActionData:
+    return parse_resource_action(stream, "READ", node=node)