chcode 0.1.0__py3-none-any.whl

chcode/utils/shell/output.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+import tempfile
+import uuid
+from dataclasses import dataclass
+
+MAX_OUTPUT_LINES = 2000
+MAX_OUTPUT_BYTES = 51200
+MAX_PERSISTED_BYTES = 64 * 1024 * 1024
+
+
+@dataclass
+class TruncatedOutput:
+    content: str
+    truncated: bool = False
+    persisted_path: str | None = None
+    total_bytes: int = 0
+
+
+def truncate_output(stdout: str) -> TruncatedOutput:
+    total_bytes = len(stdout.encode("utf-8", errors="replace"))
+    lines = stdout.splitlines(keepends=True)
+    needs_line_trunc = len(lines) > MAX_OUTPUT_LINES
+    needs_byte_trunc = total_bytes > MAX_OUTPUT_BYTES
+
+    if not needs_line_trunc and not needs_byte_trunc:
+        return TruncatedOutput(content=stdout, total_bytes=total_bytes)
+
+    persisted_path = _persist_to_file(stdout)
+
+    preview_lines = lines[:MAX_OUTPUT_LINES]
+    preview = "".join(preview_lines)
+    if len(preview.encode("utf-8", errors="replace")) > MAX_OUTPUT_BYTES:
+        preview = preview[:MAX_OUTPUT_BYTES]
+
+    truncation_notice = (
+        f"\n\n[Output truncated: {len(lines)} lines, {total_bytes} bytes total. "
+        f"Full output saved to: {persisted_path}]"
+    )
+
+    return TruncatedOutput(
+        content=preview + truncation_notice,
+        truncated=True,
+        persisted_path=persisted_path,
+        total_bytes=total_bytes,
+    )
+
+
+def _persist_to_file(content: str) -> str:
+    output_dir = os.path.join(tempfile.gettempdir(), "chcode-output")
+    os.makedirs(output_dir, exist_ok=True)
+    file_id = uuid.uuid4().hex[:8]
+    path = os.path.join(output_dir, f"output-{file_id}.txt")
+
+    encoded = content.encode("utf-8", errors="replace")
+    if len(encoded) > MAX_PERSISTED_BYTES:
+        encoded = encoded[:MAX_PERSISTED_BYTES]
+
+    with open(path, "wb") as f:
+        f.write(encoded)
+
+    return path

chcode/utils/shell/provider.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import tempfile
+import uuid
+from abc import ABC, abstractmethod
+
+
+class ShellProvider(ABC):
+    @property
+    @abstractmethod
+    def shell_path(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def is_available(self) -> bool: ...
+
+    @property
+    @abstractmethod
+    def display_name(self) -> str: ...
+
+    @abstractmethod
+    def build_command(self, command: str, cwd_file: str) -> str: ...
+
+    @abstractmethod
+    def get_spawn_args(self, command_string: str) -> list[str]: ...
+
+    def get_env_overrides(self) -> dict[str, str]:
+        return {}
+
+    def create_cwd_file(self) -> str:
+        tmpdir = tempfile.gettempdir()
+        file_id = uuid.uuid4().hex[:8]
+        return os.path.join(tmpdir, f"chcode-cwd-{file_id}")
+
+    def read_cwd_file(self, cwd_file: str) -> str | None:
+        try:
+            with open(cwd_file, encoding="utf-8-sig") as f:
+                return f.read().strip()
+        except OSError:
+            return None
+
+    def cleanup_cwd_file(self, cwd_file: str) -> None:
+        with contextlib.suppress(OSError):
+            os.unlink(cwd_file)
+
+
+class BashProvider(ShellProvider):
+    def __init__(self) -> None:
+        self._shell = self._detect_shell()
+
+    @property
+    def shell_path(self) -> str:
+        return self._shell
+
+    @property
+    def is_available(self) -> bool:
+        return self._shell != ""
+
+    @property
+    def display_name(self) -> str:
+        return "bash"
+
+    def _detect_shell(self) -> str:
+        if os.name == "nt":
+            git_path = shutil.which("git")
+            if git_path:
+                git_bin = os.path.dirname(git_path)
+                candidate = os.path.join(git_bin, "bash.exe")
+                if os.path.isfile(candidate):
+                    return candidate
+                candidate = os.path.join(git_bin, "..", "bin", "bash.exe")  # pragma: no cover
+                if os.path.isfile(candidate):  # pragma: no cover
+                    return os.path.normpath(candidate)  # pragma: no cover
+            bash_path = shutil.which("bash")  # pragma: no cover
+            if bash_path and os.path.isfile(bash_path):  # pragma: no cover
+                return bash_path  # pragma: no cover
+            return ""
+        env_shell = os.environ.get("SHELL", "")
+        if env_shell and os.path.isfile(env_shell):
+            return env_shell
+        for candidate in ["/bin/bash", "/usr/bin/bash", "/bin/zsh", "/usr/bin/zsh"]:
+            if os.path.isfile(candidate):
+                return candidate
+        return shutil.which("bash") or shutil.which("zsh") or ""
+
+    def build_command(self, command: str, cwd_file: str) -> str:
+        escaped_cwd = cwd_file.replace("'", "'\\''")
+        escaped_cmd = command.replace("'", "'\\''")
+        return f"eval '{escaped_cmd}' && pwd -P >| '{escaped_cwd}'"
+
+    def get_spawn_args(self, command_string: str) -> list[str]:
+        return ["-c", command_string]
+
+
+class PowerShellProvider(ShellProvider):
+    @property
+    def shell_path(self) -> str:
+        return "powershell"
+
+    @property
+    def is_available(self) -> bool:
+        import platform
+
+        return platform.system() == "Windows" and shutil.which("powershell") is not None
+
+    @property
+    def display_name(self) -> str:
+        return "powershell"
+
+    def build_command(self, command: str, cwd_file: str) -> str:
+        escaped = cwd_file.replace("'", "''")
+        return (
+            f"{command}\n"
+            f"; $_ec = if ($null -ne $LASTEXITCODE) {{ $LASTEXITCODE }} "
+            f"elseif ($?) {{ 0 }} else {{ 1 }}\n"
+            f"; (Get-Location).Path | Out-File -FilePath '{escaped}' "
+            f"-Encoding utf8 -NoNewline\n"
+            f"; exit $_ec"
+        )
+
+    def get_spawn_args(self, command_string: str) -> list[str]:
+        return ["-NoProfile", "-NonInteractive", "-Command", command_string]
+
+    def get_env_overrides(self) -> dict[str, str]:
+        return {"PSMODULEPATH": ""}

chcode/utils/shell/result.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ShellResult:
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+    interrupted: bool = False
+    timed_out: bool = False
+    output_file_path: str | None = None
+    output_file_size: int | None = None

chcode/utils/shell/semantics.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class Interpretation:
+    is_error: bool
+    message: str | None = None
+
+
+_RULES: list[tuple[list[str], dict[int, str]]] = [
+    (["grep", "rg", "ag", "ack", "findstr", "select-string"], {1: "No matches found"}),
+    (["diff", "compare-object", "fc"], {1: "Files or inputs differ"}),
+    (["test", "["], {1: "Test condition evaluated to false"}),
+    (["ping"], {1: "Host unreachable or no response"}),
+    (["which", "where", "where.exe", "command", "get-command"], {1: "Command not found"}),
+    (["type", "cat", "get-content"], {1: "File not found or unreadable"}),
+    (["mkdir"], {1: "Directory creation failed"}),
+    (["robocopy"], {1: "Files copied successfully (robocopy exit 1 = success)"}),
+]
+
+
+def _get_base_command(command: str) -> str:
+    segments = re.split(r"[|;&]", command)
+    last = segments[-1].strip()
+    for op in ["&&", "||"]:
+        parts = last.split(op)
+        last = parts[-1].strip()
+    tokens = last.split()
+    if not tokens:
+        return ""
+    base = tokens[0]
+    if "/" in base or "\\" in base:
+        base = base.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+    return base.lower()
+
+
+def interpret_command_result(command: str, exit_code: int) -> Interpretation:
+    if exit_code == 0:
+        return Interpretation(is_error=False)
+
+    base = _get_base_command(command)
+    if not base:
+        return Interpretation(is_error=True, message=f"Exit code {exit_code}")
+
+    for commands, exit_map in _RULES:
+        if base in commands or base.removesuffix("exe") in commands:
+            if exit_code in exit_map:
+                return Interpretation(is_error=False, message=exit_map[exit_code])
+            if 1 in exit_map and exit_code > 1:
+                return Interpretation(is_error=True, message=f"Exit code {exit_code}")
+
+    return Interpretation(is_error=True, message=f"Exit code {exit_code}")

chcode/utils/shell/session.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import contextlib
+import locale
+import os
+import re
+import signal
+import subprocess
+
+from charset_normalizer import from_bytes
+
+from chcode.utils.shell.output import TruncatedOutput, truncate_output
+from chcode.utils.shell.provider import ShellProvider
+from chcode.utils.shell.result import ShellResult
+
+
+class ShellSession:
+    def __init__(self, provider: ShellProvider) -> None:
+        self._provider = provider
+        self._cwd: str = os.getcwd()
+
+    @property
+    def cwd(self) -> str:
+        return self._cwd
+
+    @cwd.setter
+    def cwd(self, value: str) -> None:
+        if os.path.isdir(value):
+            self._cwd = value
+
+    @property
+    def provider_name(self) -> str:
+        return self._provider.display_name
+
+    def execute(
+        self,
+        command: str,
+        timeout: int | None = 120000,
+        workdir: str | None = None,
+    ) -> tuple[ShellResult, TruncatedOutput]:
+        cwd_file = self._provider.create_cwd_file()
+        full_command = self._provider.build_command(command, cwd_file)
+
+        exec_cwd = workdir or self._cwd
+        if not os.path.isdir(exec_cwd):
+            exec_cwd = self._cwd
+
+        spawn_args = self._provider.get_spawn_args(full_command)
+        env = {**os.environ, **self._provider.get_env_overrides()}
+
+        timeout_sec = (timeout / 1000) if timeout else None
+        timed_out = False
+
+        try:
+            proc = subprocess.Popen(
+                [self._provider.shell_path, *spawn_args],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=exec_cwd,
+                env=env,
+            )
+        except FileNotFoundError:
+            return (
+                ShellResult(exit_code=127, stderr=f"Shell not found: {self._provider.shell_path}"),
+                truncate_output(""),
+            )
+        except OSError as e:
+            return (
+                ShellResult(exit_code=126, stderr=f"Failed to execute: {e}"),
+                truncate_output(""),
+            )
+
+        try:
+            stdout_bytes, stderr_bytes = proc.communicate(timeout=timeout_sec)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            with contextlib.suppress(OSError):
+                _kill_proc_tree(proc)
+            try:
+                stdout_bytes, stderr_bytes = proc.communicate(timeout=5)
+            except subprocess.TimeoutExpired:
+                stdout_bytes, stderr_bytes = b"", b""
+
+        stdout = _robust_decode(stdout_bytes) if stdout_bytes else ""
+        stderr = _robust_decode(stderr_bytes) if stderr_bytes else ""
+
+        new_cwd = self._provider.read_cwd_file(cwd_file)
+        if new_cwd and not workdir:
+            if os.name == "nt" and new_cwd.startswith("/"):
+                match = re.match(r"^/([a-zA-Z])(/.*)?$", new_cwd)
+                if match:
+                    drive = match.group(1).upper()
+                    rest = match.group(2) or "\\"
+                    new_cwd = f"{drive}:{rest.replace('/', chr(92))}"
+            if os.path.isdir(new_cwd):
+                self._cwd = new_cwd
+
+        self._provider.cleanup_cwd_file(cwd_file)
+
+        result = ShellResult(
+            stdout=stdout,
+            stderr=stderr,
+            exit_code=proc.returncode if proc.returncode is not None else 1,
+            timed_out=timed_out,
+            interrupted=timed_out,
+        )
+
+        truncated = truncate_output(result.stdout)
+        if truncated.truncated:
+            result.output_file_path = truncated.persisted_path
+            result.output_file_size = truncated.total_bytes
+
+        return result, truncated
+
+
+def _robust_decode(data: bytes) -> str:
+    if not data:
+        return ""
+    system_encoding = locale.getpreferredencoding() or "utf-8"
+    if len(data) >= 4:
+        bom = data[:4]
+        if bom[:3] == b"\xef\xbb\xbf":
+            return data[3:].decode("utf-8", errors="replace")
+        if bom[:2] in (b"\xff\xfe", b"\xfe\xff"):
+            return data.decode("utf-16", errors="replace")
+    result = from_bytes(data)
+    best = result.best() if result else None
+    if best and best.coherence > 0.5:
+        return str(best)
+    for enc in ["utf-8", "gb18030", system_encoding, "latin-1"]:
+        try:
+            return data.decode(enc, errors="strict")
+        except (UnicodeDecodeError, LookupError):
+            continue
+    return data.decode(system_encoding, errors="replace")  # pragma: no cover
+
+
+def _kill_proc_tree(proc: subprocess.Popen) -> None:
+    pid = proc.pid
+    if pid is None:
+        return
+
+    try:
+        import psutil
+
+        parent = psutil.Process(pid)
+        children = parent.children(recursive=True)
+        for child in children:
+            with contextlib.suppress(psutil.NoSuchProcess):
+                child.kill()
+        parent.kill()
+    except ImportError:
+        if os.name == "nt":
+            proc.kill()
+        else:
+            with contextlib.suppress(OSError, ProcessLookupError):
+                os.killpg(pid, signal.SIGKILL)
+                return
+            proc.kill()