teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/outbound/shell_adapter.py

@@ -0,0 +1,344 @@
+import os
+import subprocess  # nosec
+import sys
+from typing import Optional, Dict, List, Any
+
+from teddy_executor.core.domain.models.shell_output import ShellOutput
+from teddy_executor.core.ports.outbound.shell_executor import IShellExecutor
+from teddy_executor.adapters.outbound.shell_command_builder import ShellCommandBuilder
+from teddy_executor.core.utils.string import truncate_lines
+
+import re
+
+
+class ShellAdapter(IShellExecutor):
+    TIMEOUT_EXIT_CODE = 124
+    INTERACTIVE_PROMPT_MESSAGE = "FAILURE: Interactive prompt detected"
+
+    def __init__(
+        self,
+        command_builder: ShellCommandBuilder = None,  # type: ignore
+        max_execute_lines: int = 100,
+    ):
+        self._command_builder = command_builder or ShellCommandBuilder()
+        self.max_execute_lines = max_execute_lines
+        self._popen = subprocess.Popen
+
+    def _sanitize_output(self, text: str) -> str:
+        """Strips ALL ANSI escape sequences to prevent playback corruption and garbled reports."""
+        if not text:
+            return text
+        # Remove Operating System Commands (like window title changes)
+        text = re.sub(r"\x1b\][^\x07\x1b]*?(?:\x07|\x1b\\)", "", text)
+        # Remove all CSI escape sequences (including colors, cursor moves, alt-screens)
+        text = re.sub(r"\x1b\[[0-9;?><\$]*[a-zA-Z]", "", text)
+        return text
+
+    def _validate_cwd(self, cwd: Optional[str]) -> str:
+        """Validates and resolves the working directory."""
+        project_root = os.path.realpath(os.getcwd())
+        if not cwd:
+            return project_root
+
+        if os.path.isabs(cwd):
+            # Absolute paths are explicit user choices; skip project root check.
+            return os.path.realpath(cwd)
+
+        validated_cwd = os.path.realpath(os.path.join(project_root, cwd))
+
+        if not validated_cwd.startswith(project_root):
+            raise ValueError(
+                f"Validation failed: `cwd` path '{cwd}' resolves to '{validated_cwd}', which is outside the project directory '{project_root}'."
+            )
+        return validated_cwd
+
+    def _log_debug_pre_execution(
+        self, command: str, command_args: str | List[str], cwd: str, use_shell: bool
+    ):
+        if os.getenv("TEDDY_DEBUG"):  # pragma: no cover
+            print("--- ShellAdapter Debug ---", file=sys.stderr)
+            print(f"Platform: {sys.platform}", file=sys.stderr)
+            print(f"Original command: {command!r}", file=sys.stderr)
+            print(f"Tokenized/Command args: {command_args}", file=sys.stderr)
+            print(f"CWD: {cwd}", file=sys.stderr)
+            print(f"Shell: {use_shell}", file=sys.stderr)
+            print("--------------------------", file=sys.stderr)
+
+    def _log_debug_result(self, result: subprocess.CompletedProcess):
+        if os.getenv("TEDDY_DEBUG"):  # pragma: no cover
+            print("--- ShellAdapter Result ---", file=sys.stderr)
+            print(f"Return Code: {result.returncode}", file=sys.stderr)
+            print(f"STDOUT:\n{result.stdout}", file=sys.stderr)
+            print(f"STDERR:\n{result.stderr}", file=sys.stderr)
+            print("---------------------------", file=sys.stderr)
+
+    def _log_debug_error(self, error: Exception):
+        if os.getenv("TEDDY_DEBUG"):  # pragma: no cover
+            print("--- ShellAdapter Error ---", file=sys.stderr)
+            print(f"Error: {error}", file=sys.stderr)
+            print("--------------------------", file=sys.stderr)
+
+    def _restore_terminal_state(self):
+        """Hard-resets terminal state to clear corruption from killed TUIs."""
+        if "PYTEST_CURRENT_TEST" in os.environ:
+            return  # Prevent terminal corruption during test suite execution
+
+        reset_seq = "\x1b[?1000l\x1b[?1003l\x1b[?1049l\x1b[?25h"
+        # 1. Attempt to write directly to the controlling terminal (bypasses pipes)
+        try:
+            with open("/dev/tty", "w", encoding="utf-8") as tty:
+                tty.write(reset_seq)
+                tty.flush()
+        except OSError:
+            pass
+
+        # 2. Fallback to stdout/stderr if /dev/tty is unavailable but they are TTYs
+        if sys.stdout.isatty():
+            sys.stdout.write(reset_seq)
+            sys.stdout.flush()
+        elif sys.stderr.isatty():
+            sys.stderr.write(reset_seq)
+            sys.stderr.flush()
+
+    def _prepare_subprocess_kwargs(
+        self, use_shell: bool, cwd: str, env: Dict[str, str]
+    ) -> Dict[str, Any]:
+        """Prepares the keyword arguments for subprocess.Popen."""
+        kwargs: Dict[str, Any] = {
+            "shell": use_shell,
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.PIPE,
+            "stdin": subprocess.DEVNULL,
+            "text": True,
+            "cwd": cwd,
+            "env": env,
+        }
+        if sys.platform != "win32":
+            import signal
+
+            # ISOLATION: Severing stdin from the TTY is required to prevent SIGTTIN
+            # suspension when running in a new process group.
+
+            def preexec_fn():
+                # Create a new session to detach from controlling terminal.
+                # This causes /dev/tty access (e.g. getpass.getpass) to fail fast.
+                if hasattr(os, "setsid"):
+                    os.setsid()
+                else:
+                    os.setpgrp()
+                # Prevent OS from suspending background process group when querying TTY
+                signal.signal(signal.SIGTTOU, signal.SIG_IGN)
+                signal.signal(signal.SIGTTIN, signal.SIG_IGN)
+
+            kwargs["preexec_fn"] = preexec_fn
+        return kwargs
+
+    def _handle_timeout(self, process: subprocess.Popen, timeout: float) -> ShellOutput:
+        """Handles a subprocess timeout by terminating the process and gathering output."""
+        if sys.platform != "win32":
+            import signal
+
+            try:
+                # Jidoka/Poka-Yoke: Anti-Suicide Guard.
+                if not isinstance(process.pid, int) or process.pid <= 1:
+                    process.kill()
+                else:
+                    os.killpg(process.pid, signal.SIGKILL)
+            except OSError:
+                pass
+        else:
+            process.kill()
+
+        try:
+            # Give the OS a moment to close pipes naturally after SIGKILL.
+            stdout, stderr = process.communicate(timeout=0.5)
+        except subprocess.TimeoutExpired:
+            stdout, stderr = "", ""
+
+        sanitized_stderr = self._sanitize_output(stderr) or ""
+        if self._detect_interactive_prompt(sanitized_stderr, stdout):
+            return {
+                "stdout": self.INTERACTIVE_PROMPT_MESSAGE,
+                "stderr": sanitized_stderr,
+                "return_code": self.TIMEOUT_EXIT_CODE,
+            }
+
+        self._log_debug_error(Exception(f"TimeoutExpired: {timeout} seconds"))
+        warning = f"[ERROR: Command timed out after {timeout} seconds]"
+        return {
+            "stdout": f"{warning}\n{self._sanitize_output(stdout)}".strip()
+            if stdout
+            else warning,
+            "stderr": sanitized_stderr,
+            "return_code": self.TIMEOUT_EXIT_CODE,
+        }
+
+    def _process_execution_results(
+        self,
+        stdout: str,
+        stderr: str,
+        return_code: int,
+        max_lines: Optional[int] = None,
+    ) -> ShellOutput:
+        """Processes the raw execution results into a structured ShellOutput."""
+        sanitized_stdout = self._sanitize_output(stdout)
+
+        effective_max_lines = (
+            max_lines if max_lines is not None else self.max_execute_lines
+        )
+        truncated_stdout = truncate_lines(
+            sanitized_stdout,
+            max_lines=effective_max_lines,
+            direction="tail",
+            action_type="execute",
+        )
+
+        output: ShellOutput = {
+            "stdout": truncated_stdout,
+            "stderr": self._sanitize_output(stderr),
+            "return_code": return_code,
+        }
+
+        marker = "FAILED_COMMAND: "
+        if marker in stderr:
+            for line in stderr.splitlines():
+                if marker in line:
+                    failed_cmd = line.split(marker)[1].strip()
+                    # On Windows, we sometimes have to unescape carets or handle quote swaps
+                    # that were forced by the cmd /c wrapper.
+                    if sys.platform == "win32":
+                        failed_cmd = failed_cmd.replace("^^", "^")
+                    output["failed_command"] = failed_cmd
+                    break
+
+        # Dual-channel interactive detection (post-execution)
+        if return_code != 0 and self._detect_interactive_prompt(stderr, stdout):
+            output["stdout"] = self.INTERACTIVE_PROMPT_MESSAGE
+            output["stderr"] = ""
+            return output
+
+        # Heuristic: Windows silent exit with code 1 and empty output => likely interactive
+        if sys.platform == "win32" and return_code == 1 and not stdout and not stderr:
+            output["stdout"] = self.INTERACTIVE_PROMPT_MESSAGE
+            output["stderr"] = ""
+            return output
+
+        return output
+
+    @staticmethod
+    def _detect_interactive_prompt(stderr: str, stdout: str = "") -> bool:
+        """
+        Detect if a command failure was due to an interactive prompt
+        by checking both stderr and stdout for common patterns.
+        """
+        patterns = [
+            "EOFError",
+            "input(",
+            "is not a TTY",
+            "not a tty",
+            "stdin is not a terminal",
+            "read error",
+            "Input/output error",
+            "Inappropriate ioctl",
+            "Input required",
+            "Unexpected EOF",
+            "cannot read input",
+        ]
+        combined = f"{stdout}\n{stderr}"
+        return any(p in combined for p in patterns)
+
+    def _run_subprocess(  # noqa: PLR0913
+        self,
+        command_args: str | List[str],
+        use_shell: bool,
+        cwd: str,
+        env: Dict[str, str],
+        timeout: Optional[float] = None,
+        background: bool = False,
+        max_lines: Optional[int] = None,
+    ) -> ShellOutput:
+        """Executes the command in a subprocess and handles errors."""
+        try:
+            if background:
+                process = self._popen(  # nosec B602
+                    command_args,
+                    shell=use_shell,  # nosec B604
+                    cwd=cwd,
+                    env=env,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                )
+                return {
+                    "stdout": f"[SUCCESS: Background process started with PID {process.pid}]",
+                    "stderr": "",
+                    "return_code": 0,
+                }
+
+            kwargs = self._prepare_subprocess_kwargs(use_shell, cwd, env)
+            process = self._popen(command_args, **kwargs)  # nosec
+
+            try:
+                # Type cast is required because Mypy cannot infer str types when
+                # text=True is passed via **kwargs.
+                from typing import cast
+
+                comm_res = process.communicate(timeout=timeout)
+                stdout, stderr = cast(tuple[str, str], comm_res)
+            except subprocess.TimeoutExpired:
+                return self._handle_timeout(process, timeout or 0)
+
+            self._log_debug_result(
+                subprocess.CompletedProcess(
+                    args=command_args,
+                    returncode=process.returncode,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
+            )
+
+            return self._process_execution_results(
+                stdout, stderr, process.returncode, max_lines=max_lines
+            )
+        except (FileNotFoundError, OSError) as e:
+            self._log_debug_error(e)
+            return {
+                "stdout": "",
+                "stderr": str(e),
+                "return_code": getattr(e, "errno", 1),
+            }
+
+    # jscpd:ignore-start
+    def execute(
+        self,
+        command: str,
+        cwd: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        timeout: Optional[float] = None,
+        background: bool = False,
+        max_lines: Optional[int] = None,
+    ) -> ShellOutput:
+        # jscpd:ignore-end
+        """Executes a command via subprocess, returning ShellOutput."""
+        current_cwd = self._validate_cwd(cwd)
+        current_env = os.environ.copy()
+        if env:
+            current_env.update(env)
+
+        # Directives (cd, export) are now pre-processed by the parser.
+        # The adapter's responsibility is to execute a single, final command.
+
+        command_args, use_shell = self._command_builder.prepare(command)
+        self._log_debug_pre_execution(command, command_args, current_cwd, use_shell)
+        result = self._run_subprocess(
+            command_args,
+            use_shell,
+            current_cwd,
+            current_env,
+            timeout=timeout,
+            background=background,
+            max_lines=max_lines,
+        )
+
+        return result

teddy_executor/adapters/outbound/shell_command_builder.py

@@ -0,0 +1,105 @@
+import shutil
+import sys
+from typing import List, Union
+
+
+class ShellCommandBuilder:
+    """
+    Handles OS-specific command preparation, wrapping, and script generation.
+    """
+
+    def __init__(self, platform: str = sys.platform):
+        self._platform = platform
+
+    def prepare(self, command: str) -> tuple[Union[str, List[str]], bool]:
+        """Determines command arguments and shell usage based on the platform."""
+        command = command.strip()
+        is_multiline = "\n" in command
+
+        # Check for shell operators to enable granular reporting for single-line chains.
+        # Includes redirection, pipes, chaining, variables, globs, and subshells.
+        # This ensures any command requiring shell interpretation is correctly flagged.
+        if self._platform == "win32":
+            ops = ["&&", "||", "&", "|", ">", "<", "%", "*", "?", "(", ")"]
+        else:
+            ops = [
+                "&&",
+                "||",
+                ";",
+                "|",
+                ">",
+                "<",
+                "$",
+                "*",
+                "?",
+                "(",
+                ")",
+                "[",
+                "]",
+                "~",
+                "`",
+            ]
+        has_chaining = any(op in command for op in ops)
+        is_complex = is_multiline or has_chaining
+
+        if self._platform == "win32":
+            return self._prepare_windows(command, is_complex)
+
+        return self._prepare_posix(command, is_complex, is_multiline)
+
+    def _prepare_windows(self, command: str, is_complex: bool) -> tuple[str, bool]:
+        """Prepares commands for Windows cmd.exe."""
+        # For Windows, we wrap complex commands if they don't look like
+        # a single multiline script (e.g., using triple quotes).
+        is_likely_single_script = "'''" in command or '"""' in command
+        if is_complex and not is_likely_single_script:
+            lines = [line.strip() for line in command.split("\n") if line.strip()]
+            wrapped_parts = []
+            for line in lines:
+                safe_line = (
+                    line.replace('"', "'")
+                    .replace("^", "^^")
+                    .replace("(", "^(")
+                    .replace(")", "^)")
+                    .replace("&", "^&")
+                    .replace("|", "^|")
+                    .replace(">", "^>")
+                    .replace("<", "^<")
+                )
+                prefix = "cmd /c" if line.strip().lower().startswith("exit") else "call"
+                cmd_part = f'"{line}"' if prefix == "cmd /c" else line
+
+                wrapped_parts.append(
+                    f'({prefix} {cmd_part} || cmd /c "echo FAILED_COMMAND: {safe_line} >&2 & exit 1")'
+                )
+            wrapped = " && ".join(wrapped_parts)
+            return wrapped, True
+
+        first_word = command.split()[0]
+        if shutil.which(first_word):
+            return command, False  # It's a file, run directly.
+        return command, True  # It's a shell built-in.
+
+    def _prepare_posix(
+        self, command: str, is_complex: bool, is_multiline: bool
+    ) -> tuple[Union[str, List[str]], bool]:
+        """Prepares commands for POSIX systems (prefers bash for complex commands)."""
+        if is_complex and shutil.which("bash"):
+            script = (
+                "__teddy_report() { "
+                "RET=$?; "
+                "if [ $RET -ne 0 ]; then "
+                'echo "FAILED_COMMAND: $TEDDY_LAST_CMD" >&2; '
+                "fi; "
+                "exit $RET; "
+                "}\n"
+                "trap 'TEDDY_LAST_CMD=$BASH_COMMAND' DEBUG\n"
+                "trap '__teddy_report' EXIT\n"
+                "set -e\n"
+                f"{command}"
+            )
+            return ["bash", "-c", script], False
+
+        # Fallback for simple single-line or when bash is missing
+        prefix = "set -e; " if is_multiline else ""
+        return f"{prefix}{command}", True

teddy_executor/adapters/outbound/system_environment_adapter.py

@@ -0,0 +1,62 @@
+import os
+import shutil
+import subprocess  # nosec
+import tempfile
+from typing import List, Optional
+from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
+
+
+class SystemEnvironmentAdapter(ISystemEnvironment):
+    def which(self, command: str) -> Optional[str]:
+        return shutil.which(command)
+
+    def get_env(self, key: str) -> Optional[str]:
+        return os.getenv(key)
+
+    def run_command(
+        self, args: List[str], check: bool = True, background: bool = False
+    ) -> None:
+        """Wraps subprocess.run (synchronous) or subprocess.Popen (background)."""
+        import sys
+
+        if background:
+            # We don't wait for the result
+            subprocess.Popen(  # nosec B603
+                args,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            return
+
+        try:
+            subprocess.run(args, check=check, stdin=subprocess.DEVNULL)  # nosec B603
+        finally:
+            # Emergency TTY restore for Darwin/Linux.
+            # We guard against running during tests to prevent SIGTTOU hangs in CI workers.
+            if (
+                sys.platform != "win32"
+                and sys.stdin.isatty()
+                and "PYTEST_CURRENT_TEST" not in os.environ
+            ):
+                try:
+                    import termios
+
+                    fd = sys.stdin.fileno()
+                    attrs = termios.tcgetattr(fd)
+                    attrs[0] |= termios.ICRNL
+                    attrs[3] |= termios.ICANON | termios.ECHO
+                    termios.tcsetattr(fd, termios.TCSAFLUSH, attrs)
+                except Exception as e:
+                    import logging
+
+                    logging.getLogger(__name__).debug("Failed to restore TTY: %s", e)
+
+    def create_temp_file(self, suffix: str = "", mode: str = "w") -> str:
+        with tempfile.NamedTemporaryFile(mode=mode, suffix=suffix, delete=False) as tf:
+            return tf.name
+
+    def delete_file(self, path: str) -> None:
+        if os.path.exists(path):
+            os.unlink(path)

teddy_executor/adapters/outbound/system_environment_inspector.py

@@ -0,0 +1,54 @@
+import os
+import platform
+import subprocess  # nosec B404
+import sys
+from datetime import datetime
+from typing import Optional
+
+from teddy_executor.core.ports.outbound.environment_inspector import (
+    IEnvironmentInspector,
+)
+
+
+from typing import Any, Callable
+
+
+class SystemEnvironmentInspector(IEnvironmentInspector):
+    """
+    An adapter that inspects the real system environment using standard
+    Python libraries.
+    """
+
+    def __init__(self, run_func: Optional[Callable[..., Any]] = None):
+        self._run_func = run_func or subprocess.run
+
+    def get_environment_info(self) -> dict[str, str]:
+        """
+        Gathers key information about the system environment.
+        """
+        now = datetime.now()
+        return {
+            "os_name": platform.system(),
+            "os_version": platform.release(),
+            "python_version": sys.version,
+            "cwd": os.getcwd(),
+            "shell": os.getenv("SHELL", "unknown"),
+            "current_date": now.strftime("%Y-%m-%d"),
+            "current_time": now.strftime("%H:%M:%S"),
+        }
+
+    def get_git_status(self) -> Optional[str]:
+        """
+        Gathers the current Git status of the working directory.
+        """
+        try:
+            result = self._run_func(  # nosec B603 B607
+                ["git", "status", "-s"],
+                capture_output=True,
+                text=True,
+                check=True,
+                stdin=subprocess.DEVNULL,
+            )
+            return result.stdout.rstrip() if result.stdout else ""
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return None

teddy_executor/adapters/outbound/system_time_adapter.py

@@ -0,0 +1,22 @@
+from datetime import datetime, timezone
+from teddy_executor.core.ports.outbound.time_service import ITimeService
+
+
+class SystemTimeAdapter(ITimeService):
+    """
+    Production implementation of ITimeService using the standard library.
+    """
+
+    def now(self) -> datetime:
+        """Returns current local time."""
+        return datetime.now()
+
+    def now_utc(self) -> datetime:
+        """Returns current UTC time."""
+        return datetime.now(timezone.utc)
+
+    def sleep(self, seconds: float) -> None:
+        """Suspends execution for the given number of seconds."""
+        import time
+
+        time.sleep(seconds)