teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/inbound/textual_plan_reviewer_previews.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+import anyio
+
+if TYPE_CHECKING:
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_app import ReviewerApp
+    from teddy_executor.core.domain.models.plan import ActionData
+
+from teddy_executor.adapters.inbound.textual_plan_reviewer_editor import (
+    launch_editor,
+    preview_edit_diff_viewer,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def do_preview_logic(app: ReviewerApp, node: Any, action: ActionData) -> None:
+    """Internal logic for previewing/modifying complex actions."""
+    if action.type == "CREATE":
+        await preview_create(app, action, node)
+    elif action.type == "EDIT":
+        await preview_edit(app, action, node)
+    elif action.type in ("EXECUTE", "RESEARCH"):
+        await preview_text_action(app, action, node)
+    elif action.type == "READ":
+        await preview_readonly(app, action)
+
+
+# Diff viewer orchestration moved to textual_plan_reviewer_editor.py
+
+
+async def preview_edit(app: ReviewerApp, action: ActionData, node: Any) -> None:
+    """Handle non-blocking preview for EDIT."""
+    if not app._file_system:
+        return
+    path_str = cast(str, action.params.get("path", ""))
+    suffix = pathlib.Path(path_str).suffix or ".txt"
+
+    try:
+        original = str(app._file_system.read_file(path_str))
+    except Exception:
+        original = ""
+    proposed, _ = app._edit_simulator.simulate_edits(
+        original, action.params.get("edits", [])
+    )
+
+    diff_viewer = app._console_tooling.get_diff_viewer_command()
+
+    is_mock_path = (
+        not isinstance(action.pending_temp_file, (str, os.PathLike))
+        and action.pending_temp_file is not None
+    )
+    if not action.pending_temp_file or (
+        not is_mock_path and not os.path.exists(action.pending_temp_file)
+    ):
+        action.pending_temp_file = app._system_env.create_temp_file(suffix=suffix)
+
+    if diff_viewer and not is_mock_path:
+        needs_refresh = await preview_edit_diff_viewer(
+            app, action, diff_viewer, original, str(proposed)
+        )
+        if needs_refresh:
+            app._refresh_node(node)
+    else:
+        final = await launch_editor(
+            app,
+            str(proposed),
+            suffix=suffix,
+            persistent_path=action.pending_temp_file,
+        )
+        if final is not None:
+            action.modified = True
+            if "edits" not in action.modified_fields:
+                action.modified_fields.append("edits")
+            if str(final) != str(proposed):
+                action.params["edits"] = [{"find": original, "replace": str(final)}]
+                action.params.pop("content", None)
+            app._refresh_node(node)
+
+
+async def preview_create(app: ReviewerApp, action: ActionData, node: Any) -> None:
+    """Handle non-blocking preview for CREATE."""
+    path_str = cast(str, action.params.get("path", ""))
+    content = cast(str, action.params.get("content", ""))
+    suffix = pathlib.Path(path_str).suffix or ".txt"
+
+    # Only trigger content editor for CREATE to avoid path-input deadlock.
+    # Users edit the path via the parameter list in the right pane.
+    if not action.pending_temp_file:
+        action.pending_temp_file = app._system_env.create_temp_file(suffix=suffix)
+
+    new_content = await launch_editor(
+        app, str(content), suffix=suffix, persistent_path=action.pending_temp_file
+    )
+
+    if new_content is not None and str(new_content) != str(content):
+        action.modified = True
+        if "content" not in action.modified_fields:
+            action.modified_fields.append("content")
+        # Content will be harvested from pending_temp_file on submit
+        app._refresh_node(node)
+
+
+async def preview_text_action(app: ReviewerApp, action: ActionData, node: Any) -> None:
+    """Handle non-blocking preview for EXECUTE/RESEARCH."""
+    key = "command" if action.type == "EXECUTE" else "queries"
+    content = action.params.get(key, "")
+    suffix = ".sh" if action.type == "EXECUTE" else ".txt"
+
+    # Ensure a persistent path exists for the harvest
+    if not action.pending_temp_file:
+        action.pending_temp_file = app._system_env.create_temp_file(suffix=suffix)
+
+    final = await launch_editor(
+        app, str(content), suffix=suffix, persistent_path=action.pending_temp_file
+    )
+
+    if final is not None:
+        action.modified = True
+        if key not in action.modified_fields:
+            action.modified_fields.append(key)
+        if str(final) != str(content):
+            action.params[key] = str(final)
+        app._refresh_node(node)
+
+
+async def preview_readonly(app: ReviewerApp, action: ActionData) -> None:
+    """Handle non-blocking preview for READ (read-only)."""
+    if not app._file_system:
+        return
+    resource = action.params.get("resource") or action.params.get("path", "")
+    try:
+        content = app._file_system.read_file(resource)
+    except Exception as e:
+        logger.debug("Failed to read resource for preview: %s", e)
+        content = f"--- Content for {resource} could not be retrieved ---"
+
+    temp_file = app._system_env.create_temp_file(
+        suffix=pathlib.Path(resource).suffix or ".txt"
+    )
+    try:
+        with open(temp_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        # Lock file as read-only
+        os.chmod(temp_file, 0o444)
+        editor_cmd = app._console_tooling.find_editor()
+        if editor_cmd:
+            # We don't use the deferred harvest pattern for READ as they are truly read-only
+            with app.suspend():
+                await anyio.to_thread.run_sync(
+                    app._system_env.run_command, editor_cmd + [temp_file]
+                )
+    finally:
+        app._system_env.delete_file(temp_file)
+
+
+async def view_details_handler(app: "ReviewerApp") -> None:
+    """Implementation for viewing action logs."""
+    from textual.widgets import Tree
+    from teddy_executor.core.domain.models.plan import ActionData
+    from teddy_executor.adapters.inbound.textual_plan_reviewer_execution import (
+        format_action_log,
+    )
+
+    tree = app.query_one(Tree)
+    node = tree.cursor_node
+    if not node or not node.data:
+        return
+
+    action = node.data
+    if not isinstance(action, ActionData) or not action.executed:
+        return
+
+    if action.action_log:
+        log_content = format_action_log(action.action_log)
+        temp_file = app._system_env.create_temp_file(suffix=".md")
+        app._log_preview_files.append(temp_file)
+        await launch_editor(
+            app,
+            log_content,
+            suffix=".md",
+            persistent_path=temp_file,
+            skip_confirm=True,
+        )
+
+
+async def view_plan_handler(app: "ReviewerApp") -> None:
+    """Implementation for viewing the full plan."""
+    content: Optional[str] = None
+    plan_path = app.plan.plan_path
+    if plan_path and app._file_system:
+        try:
+            content = app._file_system.read_file(plan_path)
+        except Exception as e:
+            logger.debug("Failed to read plan file for viewing: %s", e)
+    if not content:
+        content = app.plan.raw_content
+    if not content:
+        content = f"# Plan: {app.plan.title}\n\n{app.plan.rationale}\n\n"
+
+    if content:
+        # If we have a persistent path, we use it. We skip confirmation because
+        # 'view' is intended to be a read-only or informational action.
+        await launch_editor(
+            app,
+            content,
+            suffix=".md",
+            persistent_path=plan_path,
+            skip_confirm=True,
+        )
+
+
+async def add_message_handler(app: "ReviewerApp") -> None:
+    """Implementation for adding user instruction message."""
+    current_message = app._user_message_cache
+    if current_message is None:
+        current_message = app.plan.metadata.get("user_request") or ""
+        if app.INSTRUCTION_MARKER not in current_message:
+            current_message += app.INSTRUCTION_MARKER
+    new_message = await launch_editor(app, current_message, suffix=".md")
+    if new_message is not None and new_message != current_message:
+        app._user_message_cache = new_message

teddy_executor/adapters/inbound/textual_plan_reviewer_widgets.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing import Any
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, ListItem, ListView, Tree, Static
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+class PathInputScreen(ModalScreen[str]):
+    """Modal screen for editing a file path."""
+
+    def __init__(self, initial_path: str):
+        super().__init__()
+        self.initial_path = initial_path
+
+    def compose(self) -> ComposeResult:
+        yield Label("File path:")
+        yield Input(value=self.initial_path, id="path_input")
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value)
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            self.dismiss(None)
+
+
+class ConfirmScreen(ModalScreen[bool]):
+    """Modal screen for final confirmation."""
+
+    def __init__(self, message: str = "Do you want to apply the changes? (y/n)"):
+        super().__init__()
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.message)
+
+    def on_key(self, event) -> None:
+        if event.key == "y":
+            self.dismiss(True)
+        elif event.key == "n":
+            self.dismiss(False)
+
+
+class ParameterEditModal(ModalScreen[str]):
+    """Modal screen for editing a simple parameter string."""
+
+    def __init__(self, label: str, initial_value: str):
+        super().__init__()
+        self.label = label
+        self.initial_value = initial_value
+
+    def compose(self) -> ComposeResult:
+        yield Label(self.label)
+        yield Input(value=self.initial_value, id="param_input")
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value)
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            self.dismiss(None)
+
+
+class ActionTree(Tree):
+    """A tree that allows both space and enter to toggle selection."""
+
+    CONTEXT_ROOT = "CONTEXT_ROOT"
+    RATIONALE_ROOT = "RATIONALE_ROOT"
+    ACTION_PLAN_ROOT = "ACTION_PLAN_ROOT"
+
+    BINDINGS = [
+        Binding("enter", "select_cursor", "Toggle", show=False),
+        Binding("space", "select_cursor", "Toggle", show=False),
+        Binding(
+            "ctrl+down",
+            "app.jump_next",
+            "Next Section",
+            show=False,
+            priority=True,
+        ),
+        Binding("alt+down", "app.jump_next", "Next Section", show=False, priority=True),
+        Binding(
+            "shift+down",
+            "app.jump_next",
+            "Next Section",
+            show=False,
+            priority=True,
+        ),
+        Binding("ctrl+up", "app.jump_prev", "Prev Section", show=False, priority=True),
+        Binding("alt+up", "app.jump_prev", "Prev Section", show=False, priority=True),
+        Binding(
+            "shift+up",
+            "app.jump_prev",
+            "Prev Section",
+            show=False,
+            priority=True,
+        ),
+    ]
+
+    def jump_to_section(self, section_id: str) -> None:
+        """
+        Jump focus to a major section node.
+
+        Args:
+            section_id: The identifier for the section (e.g., RATIONALE_ROOT).
+        """
+        for child in self.root.children:
+            if child.data == section_id:
+                # Ensure the section is expanded and visible before moving cursor
+                child.expand()
+                self.move_cursor(child)
+                # Ensure parent is also expanded (root is usually invisible but its children should be shown)
+                self.root.expand()
+                return
+
+
+class RationaleDetail(VerticalScroll):
+    """A focusable scroll view for rationale."""
+
+    BINDINGS = [
+        Binding("shift+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("shift+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+        Binding("alt+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("alt+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+        Binding("ctrl+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("ctrl+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+    ]
+
+    def action_scroll_to_top(self) -> None:
+        """Scroll to the top of the content."""
+        self.scroll_home(animate=False)
+
+    def action_scroll_to_bottom(self) -> None:
+        """Scroll to the bottom of the content."""
+        self.scroll_end(animate=False)
+
+
+class ParameterDetail(ListView):
+    """A focusable list that wraps parameters."""
+
+    BINDINGS = [
+        Binding("shift+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("shift+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+        Binding("alt+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("alt+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+        Binding("ctrl+up", "scroll_to_top", "Top", show=False, priority=True),
+        Binding("ctrl+down", "scroll_to_bottom", "Bottom", show=False, priority=True),
+    ]
+
+    def action_scroll_to_top(self) -> None:
+        """Jump focus to the first item."""
+        if self.children:
+            self.index = 0
+
+    def action_scroll_to_bottom(self) -> None:
+        """Jump focus to the last item."""
+        if self.children:
+            self.index = len(self.children) - 1
+
+
+class DetailItem(ListItem):
+    """A focusable item in the parameter list."""
+
+    MAX_PREVIEW_LENGTH = 20000
+    TRUNCATE_HALFWAY = 10000
+
+    def __init__(self, key: str, val: Any):
+        super().__init__()
+        # Truncate extremely large values to prevent TUI freeze during layout
+        display_val = str(val)
+        if len(display_val) > self.MAX_PREVIEW_LENGTH:
+            display_val = (
+                display_val[: self.TRUNCATE_HALFWAY]
+                + "\n\n... [TRUNCATED FOR PREVIEW] ...\n\n"
+                + display_val[-self.TRUNCATE_HALFWAY :]
+            )
+        self.data = {"key": key, "val": val, "display_val": display_val}
+
+    def compose(self) -> ComposeResult:
+        """Compose the list item with a wrapping static widget."""
+        # Use Static instead of Label for performance on large content
+        content = self.data["display_val"]
+        if self.data["key"]:
+            content = f"[bold]{self.data['key']}:[/] {content}"
+        yield Static(content, expand=True)
+
+
+TUI_CSS = """
+#main-container {
+    layout: horizontal;
+    height: 1fr;
+}
+#left-pane {
+    width: 65%;
+}
+#right-pane {
+    width: 35%;
+    border-left: vkey $foreground 15%;
+    padding: 0;
+    background: $surface;
+}
+#right-pane:focus-within {
+    background: $surface-lighten-1;
+}
+Tree {
+    height: 1fr;
+}
+ListView {
+    background: transparent;
+    height: 1fr;
+    border: none;
+}
+VerticalScroll {
+    background: transparent;
+}
+#rationale-content {
+    padding: 1 2;
+    background: transparent;
+}
+ListItem {
+    height: auto;
+    padding: 0 1;
+}
+ListItem.--highlight {
+    background: $accent 30%;
+    color: $text;
+    text-style: bold;
+}
+Static {
+    width: 100%;
+    height: auto;
+}
+"""

teddy_executor/adapters/outbound/__init__.py

@@ -0,0 +1,7 @@
+from .litellm_adapter import LiteLLMAdapter
+from .yaml_config_adapter import YamlConfigAdapter
+
+__all__ = [
+    "LiteLLMAdapter",
+    "YamlConfigAdapter",
+]

teddy_executor/adapters/outbound/console_interactor.py

@@ -0,0 +1,212 @@
+import shlex
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+
+from teddy_executor.adapters.inbound.cli_formatter import (
+    echo_diff_preview,
+    echo_plan_summary,
+)
+from teddy_executor.core.domain.models.change_set import ChangeSet
+from teddy_executor.core.domain.models.plan import ActionData, Plan
+from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
+from teddy_executor.core.ports.outbound.config_service import IConfigService
+from teddy_executor.core.ports.outbound.user_interactor import IUserInteractor
+from teddy_executor.adapters.outbound.console_tooling import ConsoleToolingHelper
+from teddy_executor.adapters.outbound.console_interactor_ask_loop import (
+    ConsoleAskLoop,
+)
+from teddy_executor.adapters.outbound.console_interactor_helpers import (
+    display_handoff_and_confirm,
+    prepare_external_preview_files,
+    print_skipped_action,
+    restore_terminal_mode,
+)
+
+
+class ConsoleInteractorAdapter(IUserInteractor):
+    def __init__(self, system_env: ISystemEnvironment, config_service: IConfigService):
+        self._system_env = system_env
+        self._config_service = config_service
+        self._tooling = ConsoleToolingHelper(system_env, config_service)
+        self._console = Console(stderr=True)
+        self._ask_loop = ConsoleAskLoop(self._system_env, self._tooling)
+
+    def _restore_terminal(self):
+        """Restores stdin to canonical/echo mode (Unix only)."""
+        restore_terminal_mode()
+
+    def prompt(self, text: str, default: str = "") -> str:
+        """Prompts the user using typer.prompt."""
+        return typer.prompt(text, default=default, show_default=False, err=True)
+
+    def prompt_for_message(
+        self, initial_message: Optional[str] = None
+    ) -> Optional[str]:
+        """Opens the external editor to capture a user message."""
+        import os
+
+        mock_output = os.environ.get("TEDDY_TEST_MOCK_EDITOR_OUTPUT")
+        if mock_output:
+            return mock_output
+
+        return self._launch_editor_synchronous(initial_message or "")
+
+    def display_message(self, message: str) -> None:
+        """Displays a message using Rich console to ensure consistent coloring."""
+        self._console.print(message)
+
+    def ask_question(
+        self,
+        prompt: str,
+        resources: list[str] | None = None,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """
+        Presents a prompt to the user on the console and captures their input.
+        Allows falling back to an external editor for multi-line text.
+        """
+        self._display_ask_header(prompt, resources, agent_name)
+        self._ask_loop.cleanup()
+        return self._ask_loop.run(prompt)
+
+    def _display_ask_header(
+        self, prompt: str, resources: list[str] | None, agent_name: Optional[str]
+    ) -> None:
+        """Displays the formatted message header and reference files."""
+        display_name = agent_name if agent_name else "TeDDy"
+        header = f"\n--- MESSAGE from {display_name} ---"
+        typer.secho(header, fg=typer.colors.CYAN, err=True)
+        typer.echo(prompt, err=True)
+
+        if resources:
+            typer.echo("\n▶ Reference Files:", err=True)
+            typer.echo("\n".join(resources), err=True)
+        typer.echo("", err=True)  # Spacer
+
+    def _launch_editor_synchronous(self, initial_content: str) -> str:
+        """Opens a temporary file in an external editor and waits for it to close."""
+        import os
+
+        mock_output = os.environ.get("TEDDY_TEST_MOCK_EDITOR_OUTPUT")
+        if mock_output:
+            return mock_output
+
+        temp_path = self._system_env.create_temp_file(suffix=".md")
+        try:
+            with open(temp_path, "w", encoding="utf-8") as f:
+                f.write(initial_content)
+
+            editor_cmd = self._tooling.find_editor()
+            if not editor_cmd:
+                typer.echo("Error: No suitable editor found.", err=True)
+                return ""
+
+            cmd = editor_cmd + [temp_path]
+            self._system_env.run_command(cmd)
+            self._restore_terminal()
+
+            with open(temp_path, "r", encoding="utf-8") as f:
+                return f.read().strip()
+        except Exception as e:
+            typer.echo(f"Error: Editor launch failed: {e}", err=True)
+            return ""
+        finally:
+            self._system_env.delete_file(temp_path)
+
+    def confirm_plan_review(self, plan: Plan) -> bool:
+        """Displays a summary of the plan and asks for bulk confirmation."""
+        echo_plan_summary(plan)
+        try:
+            prompt = "\nExecute this plan? (y/n): "
+            response = typer.prompt(prompt, default="n", show_default=False, err=True)
+            return response.lower().strip().startswith("y")
+        except (EOFError, typer.Abort):
+            return False
+
+    def _handle_external_preview(
+        self, change_set: ChangeSet, diff_command: List[str], temp_files: List[str]
+    ) -> None:
+        """Sets up temp files and launches external diff/editor (Non-blocking)."""
+        paths = prepare_external_preview_files(self._system_env, change_set, temp_files)
+
+        if change_set.action_type == "CREATE":
+            cmd = [c for c in diff_command if c.lower() not in ("--diff", "-d")]
+            self._system_env.run_command(cmd + paths, background=True)
+        else:
+            self._system_env.run_command(diff_command + paths, background=True)
+
+    def confirm_action(
+        self,
+        action: ActionData,
+        action_prompt: str,
+        change_set: Optional[ChangeSet] = None,
+    ) -> tuple[bool, str]:
+        # Always restore TTY before starting an interaction block
+        self._restore_terminal()
+        temp_files: List[str] = []
+        try:
+            if change_set:
+                diff_command = self._tooling.get_diff_viewer_command()
+                if not diff_command:
+                    # Check if failure was due to a missing custom tool
+                    custom_tool = self._system_env.get_env("TEDDY_DIFF_TOOL")
+                    if custom_tool:
+                        tool_name = shlex.split(custom_tool)[0]
+                        typer.echo(
+                            f"Warning: Custom diff tool '{tool_name}' not found. "
+                            "Falling back to in-terminal diff.",
+                            err=True,
+                        )
+                    echo_diff_preview(change_set)
+                else:
+                    self._handle_external_preview(change_set, diff_command, temp_files)
+                    self._restore_terminal()
+
+            message = ""
+            while True:
+                prompt = f"{action_prompt}\nApprove? (y/n/m): "
+                # Use typer.prompt which handles echoing to stderr correctly
+                response = (
+                    typer.prompt(prompt, default="n", show_default=False, err=True)
+                    .lower()
+                    .strip()
+                )
+
+                if response.startswith("y"):
+                    return True, message
+
+                if response.startswith("m"):
+                    message = self._launch_editor_synchronous("")
+                    continue
+
+                return False, ""
+        except (EOFError, typer.Abort):
+            # If input stream is closed (e.g., in non-interactive script),
+            # default to denying the action.
+            typer.echo("\nAborted.", err=True)
+            return False, "Skipped due to non-interactive session."
+        finally:
+            for file_path in temp_files:
+                self._system_env.delete_file(file_path)
+
+    def notify_skipped_action(self, action: ActionData, reason: str) -> None:
+        """Prints a colorized warning that an action was skipped."""
+        print_skipped_action(action, reason)
+
+    def notify_warning(self, message: str) -> None:
+        """Prints a colorized warning message to stderr."""
+        self._console.print(f"[bold yellow]WARNING:[/] {message}")
+
+    def confirm_manual_handoff(
+        self,
+        action_type: str,
+        target_agent: str | None,
+        resources: list[str],
+        message: str,
+    ) -> tuple[bool, str]:
+        """Displays a handoff request and asks for confirmation."""
+        return display_handoff_and_confirm(
+            action_type, target_agent, resources, message
+        )