teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/outbound/console_interactor_ask_loop.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+import typer
+
+if TYPE_CHECKING:
+    from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
+    from teddy_executor.adapters.outbound.console_tooling import ConsoleToolingHelper
+
+
+class ConsoleAskLoop:
+    """Handles the interactive loop for capturing user response via terminal or editor."""
+
+    def __init__(self, system_env: ISystemEnvironment, tooling: ConsoleToolingHelper):
+        self._system_env = system_env
+        self._tooling = tooling
+        self._active_editor_path: Optional[str] = None
+        self._active_editor_marker: Optional[str] = None
+
+    def run(self, prompt: str) -> str:
+        """Orchestrates the interactive loop for capturing user response."""
+        while True:
+            prompt_label = "Response (type 'e' for editor) › "
+            if self._active_editor_path:
+                prompt_label = (
+                    "Editor opened. Terminal reply or [Enter] to confirm editor › "
+                )
+
+            typer.echo(prompt_label, nl=False, err=True)
+            try:
+                user_input = input().strip()
+            except EOFError:
+                self.cleanup()
+                return ""
+
+            if user_input.lower() == "e":
+                self._launch_editor_background(prompt)
+                continue
+
+            if user_input:
+                self.cleanup()
+                return user_input
+
+            response = self._handle_empty_input(prompt)
+            if response is not None:
+                return response
+
+    def _handle_empty_input(self, prompt: str) -> Optional[str]:
+        """Handles logic when Enter is pressed without terminal input."""
+        if self._active_editor_path:
+            return self._read_editor_result()
+
+        typer.echo(
+            "Press [Enter] again to confirm empty response › ",
+            nl=False,
+            err=True,
+        )
+        try:
+            confirm = input().strip()
+        except EOFError:
+            return ""
+
+        if not confirm:
+            return ""
+
+        if confirm.lower() == "e":
+            self._launch_editor_background(prompt)
+            return None
+
+        return confirm
+
+    def cleanup(self):
+        """Removes the temp file and resets active state."""
+        if self._active_editor_path:
+            self._system_env.delete_file(self._active_editor_path)
+            self._active_editor_path = None
+            self._active_editor_marker = None
+
+    def _launch_editor_background(self, prompt: str) -> None:
+        """Opens a temporary file in a non-blocking external editor."""
+        marker = "<!-- Please enter your response above this line. -->"
+        initial_content = f"\n\n{marker}\n\n{prompt}\n"
+
+        temp_path = self._system_env.create_temp_file(suffix=".md")
+        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)
+            self._system_env.delete_file(temp_path)
+            return
+
+        try:
+            cmd = editor_cmd + [temp_path]
+            self._system_env.run_command(cmd, background=True)
+            self._active_editor_path = temp_path
+            self._active_editor_marker = marker
+        except Exception as e:
+            typer.echo(f"Error: Editor launch failed: {e}", err=True)
+            self._system_env.delete_file(temp_path)
+
+    def _read_editor_result(self) -> str:
+        """Reads the content of the background editor's temp file."""
+        if not self._active_editor_path:
+            return ""
+
+        try:
+            with open(self._active_editor_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            marker = self._active_editor_marker or ""
+            if marker in content:
+                content = content.split(marker)[0]
+
+            return content.strip()
+        except Exception as e:
+            typer.echo(f"Error: Reading editor result failed: {e}", err=True)
+            return ""
+        finally:
+            self.cleanup()

teddy_executor/adapters/outbound/console_interactor_helpers.py

@@ -0,0 +1,95 @@
+import logging
+import sys
+from typing import List, Optional
+
+import typer
+
+from teddy_executor.adapters.inbound.cli_formatter import (
+    echo_handoff_details,
+    echo_skipped_action,
+)
+from teddy_executor.core.domain.models.change_set import ChangeSet
+
+logger = logging.getLogger(__name__)
+
+
+def restore_terminal_mode():
+    """Restores stdin to canonical/echo mode (Unix only)."""
+    import os
+
+    if (
+        sys.platform == "win32"
+        or "PYTEST_CURRENT_TEST" in os.environ
+        or not sys.stdin.isatty()
+    ):
+        return
+
+    try:
+        import termios
+
+        try:
+            fd = sys.stdin.fileno()
+        except Exception:
+            return
+        attrs = termios.tcgetattr(fd)
+        # iflags: Ensure ICRNL is set (Map CR to NL on input)
+        attrs[0] = attrs[0] | termios.ICRNL
+        # lflags: Re-enable canonical mode (ICANON) and echo (ECHO)
+        attrs[3] = (
+            attrs[3] | termios.ICANON | termios.ECHO | termios.ISIG | termios.IEXTEN
+        )
+        # Apply changes and FLUSH the input buffer
+        termios.tcsetattr(fd, termios.TCSAFLUSH, attrs)
+    except Exception as e:
+        logger.debug("Failed to restore terminal mode: %s", e)
+
+
+def prepare_external_preview_files(
+    system_env, change_set: ChangeSet, temp_files: List[str]
+) -> List[str]:
+    """Sets up temp files for external diff/editor."""
+    ext = "".join(change_set.path.suffixes)
+    if change_set.action_type == "CREATE":
+        preview_path = system_env.create_temp_file(suffix=f".preview{ext}")
+        temp_files.append(preview_path)
+        with open(preview_path, "w", encoding="utf-8") as f:
+            f.write(change_set.after_content)
+        return [preview_path]
+
+    before_path = system_env.create_temp_file(suffix=f".before{ext}")
+    after_path = system_env.create_temp_file(suffix=f".after{ext}")
+    temp_files.extend([before_path, after_path])
+    with open(before_path, "w", encoding="utf-8") as f:
+        f.write(change_set.before_content)
+    with open(after_path, "w", encoding="utf-8") as f:
+        f.write(change_set.after_content)
+    return [before_path, after_path]
+
+
+def display_handoff_and_confirm(
+    action_type: str,
+    target_agent: Optional[str],
+    resources: List[str],
+    message: str,
+) -> tuple[bool, str]:
+    """Displays a handoff request and asks for confirmation."""
+    echo_handoff_details(action_type, target_agent, resources, message)
+    try:
+        response = typer.prompt(
+            "Press [Enter] to approve, or type a reason for rejection",
+            default="",
+            show_default=False,
+            err=True,
+        )
+
+        if response:
+            return False, response  # Rejected
+        return True, ""  # Approved
+    except (EOFError, typer.Abort):
+        typer.echo("\nAborted.", err=True)
+        return False, "Skipped due to non-interactive session."
+
+
+def print_skipped_action(action, reason: str) -> None:
+    """Prints a colorized warning that an action was skipped."""
+    echo_skipped_action(action, reason)

teddy_executor/adapters/outbound/console_tooling.py

@@ -0,0 +1,62 @@
+import shlex
+from typing import Optional, List
+from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
+from teddy_executor.core.ports.outbound.config_service import IConfigService
+
+
+class ConsoleToolingHelper:
+    def __init__(self, system_env: ISystemEnvironment, config_service: IConfigService):
+        self._system_env = system_env
+        self._config_service = config_service
+
+    def get_diff_viewer_command(self) -> Optional[List[str]]:
+        custom_tool_str = self._system_env.get_env("TEDDY_DIFF_TOOL")
+        if custom_tool_str:
+            custom_tool_parts = shlex.split(custom_tool_str)
+            tool_name = custom_tool_parts[0]
+            if tool_path := self._system_env.which(tool_name):
+                custom_tool_parts[0] = tool_path
+                return custom_tool_parts
+            return None
+
+        if code_path := self._system_env.which("code"):
+            return [code_path, "-r", "--diff", "--wait"]
+        return None
+
+    def find_editor(self) -> Optional[List[str]]:
+        # 1. Check Config
+        if cmd := self._resolve_editor_cmd(self._config_service.get_setting("editor")):
+            return cmd
+
+        # 2. Check Env
+        env_editor = self._system_env.get_env("VISUAL") or self._system_env.get_env(
+            "EDITOR"
+        )
+        if cmd := self._resolve_editor_cmd(env_editor):
+            return cmd
+
+        # 3. Discovery Fallback
+        for fallback in ["code", "nano"]:
+            if path := self._system_env.which(fallback):
+                cmd = [path]
+                if fallback == "code":
+                    cmd.extend(["-r", "--wait"])
+                return cmd
+
+        return None
+
+    def _resolve_editor_cmd(self, editor_str: Optional[str]) -> Optional[List[str]]:
+        """Parses a command string and resolves the executable path."""
+        if not editor_str:
+            return None
+        parts = shlex.split(editor_str)
+
+        if tool_path := self._system_env.which(parts[0]):
+            parts[0] = tool_path
+            # If the tool is VS Code, ensure reuse and wait flags are present
+            if parts[0].endswith("code") and "code" in parts[0].lower():
+                for flag in ["-r", "--wait"]:
+                    if flag not in parts:
+                        parts.append(flag)
+            return parts
+        return None

teddy_executor/adapters/outbound/filesystem_helpers.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import Any, Iterator, Tuple
+
+
+def load_ignore_spec(root_dir: Path) -> Any:
+    """
+    Loads and returns a pathspec for ignores (.gitignore and .teddyignore).
+    """
+    import pathspec
+
+    default_ignores = {
+        ".git/",
+        ".venv/",
+        "__pycache__/",
+        ".teddy/",
+        ".ruff_cache/",
+    }
+    lines = list(default_ignores)
+
+    gitignore_path = root_dir / ".gitignore"
+    if gitignore_path.is_file():
+        lines.append(gitignore_path.name)
+        lines.extend(gitignore_path.read_text(encoding="utf-8").splitlines())
+
+    teddyignore_path = root_dir / ".teddyignore"
+    if teddyignore_path.is_file():
+        lines.append(teddyignore_path.name)
+        lines.extend(teddyignore_path.read_text(encoding="utf-8").splitlines())
+
+    return pathspec.PathSpec.from_lines("gitwildmatch", lines)
+
+
+def walk_recursive(
+    root_dir: Path,
+    start_dir: Path,
+    spec: Any,
+) -> Iterator[Tuple[Path, bool]]:
+    """
+    Recursively walks a directory, yielding (Path, is_dir) for non-ignored entries.
+    Yielded paths are absolute.
+    """
+    for entry in start_dir.iterdir():
+        try:
+            rel_path = entry.relative_to(root_dir)
+        except ValueError:
+            # Fallback for paths outside root (e.g. symlinks)
+            rel_path = entry
+
+        rel_path_str = str(rel_path).replace("\\", "/")
+        is_real_dir = entry.is_dir() and not entry.is_symlink()
+
+        # For directories, add a trailing slash to match gitignore behavior
+        match_path = rel_path_str + "/" if is_real_dir else rel_path_str
+
+        if spec.match_file(match_path):
+            continue
+
+        yield entry, is_real_dir
+
+        if is_real_dir:
+            yield from walk_recursive(root_dir, entry, spec)