quantalogic 0.2.29__tar.gz → 0.2.30__tar.gz

{quantalogic-0.2.29 → quantalogic-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.29
+Version: 0.2.30
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com

{quantalogic-0.2.29 → quantalogic-0.2.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.2.29"
+version = "0.2.30"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"

{quantalogic-0.2.29 → quantalogic-0.2.30}/quantalogic/main.py

@@ -23,9 +23,52 @@ from quantalogic.agent_config import (  # noqa: E402
 )
 from quantalogic.task_runner import task_runner  # noqa: E402
 
+# Platform-specific imports
+try:
+    if sys.platform == 'win32':
+        import msvcrt  # Built-in Windows module
+    else:
+        import termios
+        import tty
+except ImportError as e:
+    logger.warning(f"Could not import platform-specific module: {e}")
+    # Fall back to basic terminal handling if imports fail
+    msvcrt = None
+    termios = None
+    tty = None
+
 AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full"]
 
 
+def setup_terminal():
+    """Configure terminal settings based on platform."""
+    if sys.platform == 'win32':
+        if msvcrt:
+            return None  # Windows terminal is already configured
+        logger.warning("msvcrt module not available on Windows")
+        return None
+    else:
+        if termios and tty:
+            try:
+                fd = sys.stdin.fileno()
+                old_settings = termios.tcgetattr(fd)
+                tty.setraw(fd)
+                return old_settings
+            except (termios.error, AttributeError) as e:
+                logger.warning(f"Failed to configure terminal: {e}")
+                return None
+        return None
+
+
+def restore_terminal(old_settings):
+    """Restore terminal settings based on platform."""
+    if sys.platform != 'win32' and termios and old_settings:
+        try:
+            termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, old_settings)
+        except (termios.error, AttributeError) as e:
+            logger.warning(f"Failed to restore terminal settings: {e}")
+
+
 @click.group(invoke_without_command=True)
 @click.option(
     "--compact-every-n-iteration",
@@ -181,8 +224,12 @@ def task(
 
 
 def main():
-    """Main Entry point"""
-    cli()
+    """Main entry point."""
+    old_settings = setup_terminal()
+    try:
+        cli()  # type: ignore
+    finally:
+        restore_terminal(old_settings)
 
 
 if __name__ == "__main__":

{quantalogic-0.2.29 → quantalogic-0.2.30}/quantalogic/tools/execute_bash_command_tool.py

@@ -1,13 +1,22 @@
 """Tool for executing bash commands with interactive input support."""
 
 import os
-import pty
 import select
 import signal
 import subprocess
 import sys
 from typing import Dict, Optional, Union
 
+from loguru import logger
+
+# Platform-specific imports
+try:
+    if sys.platform != 'win32':
+        import pty
+except ImportError as e:
+    logger.warning(f"Could not import platform-specific module: {e}")
+    pty = None
+
 from quantalogic.tools.tool import Tool, ToolArgument
 
 
@@ -41,20 +50,58 @@ class ExecuteBashCommandTool(Tool):
         ),
     ]
 
-    def execute(
+    def _execute_windows(
         self,
         command: str,
-        working_dir: Optional[str] = None,
-        timeout: Union[int, str, None] = 60,
-        env: Optional[Dict[str, str]] = None,
+        cwd: str,
+        timeout_seconds: int,
+        env_vars: Dict[str, str],
     ) -> str:
-        """Executes a bash command with interactive input handling."""
-        timeout_seconds = int(timeout) if timeout else 60
-        cwd = working_dir or os.getcwd()
-        env_vars = os.environ.copy()
-        if env:
-            env_vars.update(env)
+        """Execute command on Windows platform."""
+        try:
+            # On Windows, use subprocess with pipes
+            process = subprocess.Popen(
+                command,
+                shell=True,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=cwd,
+                env=env_vars,
+                text=True,
+                encoding='utf-8'
+            )
+
+            try:
+                stdout, stderr = process.communicate(timeout=timeout_seconds)
+                return_code = process.returncode
+                
+                if return_code != 0 and stderr:
+                    logger.warning(f"Command failed with error: {stderr}")
+                
+                formatted_result = (
+                    "<command_output>"
+                    f" <stdout>{stdout.strip()}</stdout>"
+                    f" <returncode>{return_code}</returncode>"
+                    f"</command_output>"
+                )
+                return formatted_result
+            
+            except subprocess.TimeoutExpired:
+                process.kill()
+                return f"Command timed out after {timeout_seconds} seconds."
+                
+        except Exception as e:
+            return f"Unexpected error executing command: {str(e)}"
 
+    def _execute_unix(
+        self,
+        command: str,
+        cwd: str,
+        timeout_seconds: int,
+        env_vars: Dict[str, str],
+    ) -> str:
+        """Execute command on Unix platform."""
         try:
             master, slave = pty.openpty()
             proc = subprocess.Popen(
@@ -94,9 +141,7 @@ class ExecuteBashCommandTool(Tool):
                             user_input = os.read(sys.stdin.fileno(), 1024)
                             os.write(master, user_input)
                     
-                    # Check if process completed or EOF received
                     if break_loop or proc.poll() is not None:
-                        # Read any remaining output
                         while True:
                             data = os.read(master, 1024).decode()
                             if not data:
@@ -127,6 +172,28 @@ class ExecuteBashCommandTool(Tool):
         except Exception as e:
             return f"Unexpected error executing command: {str(e)}"
 
+    def execute(
+        self,
+        command: str,
+        working_dir: Optional[str] = None,
+        timeout: Union[int, str, None] = 60,
+        env: Optional[Dict[str, str]] = None,
+    ) -> str:
+        """Executes a bash command with interactive input handling."""
+        timeout_seconds = int(timeout) if timeout else 60
+        cwd = working_dir or os.getcwd()
+        env_vars = os.environ.copy()
+        if env:
+            env_vars.update(env)
+
+        if sys.platform == 'win32':
+            return self._execute_windows(command, cwd, timeout_seconds, env_vars)
+        else:
+            if not pty:
+                logger.warning("PTY module not available, falling back to Windows-style execution")
+                return self._execute_windows(command, cwd, timeout_seconds, env_vars)
+            return self._execute_unix(command, cwd, timeout_seconds, env_vars)
+
 
 if __name__ == "__main__":
     tool = ExecuteBashCommandTool()