quantalogic 0.2.27__py3-none-any.whl → 0.2.30__py3-none-any.whl

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/tools/execute_bash_command_tool.py

@@ -1,14 +1,27 @@
-"""Tool for executing bash commands and capturing their output."""
+"""Tool for executing bash commands with interactive input support."""
 
 import os
+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
 
 
 class ExecuteBashCommandTool(Tool):
-    """Tool for executing bash commands and capturing their output."""
+    """Tool for executing bash commands with real-time I/O handling."""
 
     name: str = "execute_bash_tool"
     description: str = "Executes a bash command and returns its output."
@@ -35,82 +48,153 @@ class ExecuteBashCommandTool(Tool):
             required=False,
             example="60",
         ),
-        # Removed the `env` argument from ToolArgument since it doesn't support `dict` type
     ]
 
-    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 and returns its output.
-
-        Args:
-            command (str): The bash command to execute.
-            working_dir (str, optional): Working directory for command execution. Defaults to the current directory.
-            timeout (int or str, optional): Maximum execution time in seconds. Defaults to 60 seconds.
-            env (dict, optional): Environment variables to set for the command execution. Defaults to the current environment.
-
-        Returns:
-            str: The command output or error message.
-
-        Raises:
-            subprocess.TimeoutExpired: If the command execution exceeds the timeout.
-            subprocess.CalledProcessError: If the command returns a non-zero exit status.
-            ValueError: If the timeout cannot be converted to an integer.
-        """
-        # Convert timeout to integer, defaulting to 60 if None or invalid
+        """Execute command on Windows platform."""
         try:
-            timeout_seconds = int(timeout) if timeout else 60
-        except (ValueError, TypeError):
-            timeout_seconds = 60
-
-        # Use the current working directory if no working directory is specified
-        cwd = working_dir if working_dir else os.getcwd()
+            # 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'
+            )
 
-        # Use the current environment if no custom environment is specified
-        env_vars = os.environ.copy()
-        if env:
-            env_vars.update(env)
+            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:
-            # Execute the command with specified timeout, working directory, and environment
-            result = subprocess.run(
+            master, slave = pty.openpty()
+            proc = subprocess.Popen(
                 command,
                 shell=True,
+                stdin=slave,
+                stdout=slave,
+                stderr=subprocess.STDOUT,
                 cwd=cwd,
-                capture_output=True,
-                text=True,
-                timeout=timeout_seconds,
                 env=env_vars,
+                preexec_fn=os.setsid,
+                close_fds=True,
             )
-
-            formated_result = (
+            os.close(slave)
+
+            stdout_buffer = []
+            break_loop = False
+
+            try:
+                while True:
+                    rlist, _, _ = select.select([master, sys.stdin], [], [], timeout_seconds)
+                    if not rlist:
+                        if proc.poll() is not None:
+                            break  # Process completed but select timed out
+                        raise subprocess.TimeoutExpired(command, timeout_seconds)
+                    
+                    for fd in rlist:
+                        if fd == master:
+                            data = os.read(master, 1024).decode()
+                            if not data:
+                                break_loop = True
+                                break
+                            stdout_buffer.append(data)
+                            sys.stdout.write(data)
+                            sys.stdout.flush()
+                        elif fd == sys.stdin:
+                            user_input = os.read(sys.stdin.fileno(), 1024)
+                            os.write(master, user_input)
+                    
+                    if break_loop or proc.poll() is not None:
+                        while True:
+                            data = os.read(master, 1024).decode()
+                            if not data:
+                                break
+                            stdout_buffer.append(data)
+                            sys.stdout.write(data)
+                            sys.stdout.flush()
+                        break
+
+            except subprocess.TimeoutExpired:
+                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                return f"Command timed out after {timeout_seconds} seconds."
+            except EOFError:
+                pass  # Process exited normally
+            finally:
+                os.close(master)
+                proc.wait()
+
+            stdout_content = ''.join(stdout_buffer)
+            return_code = proc.returncode
+            formatted_result = (
                 "<command_output>"
-                f" <stdout>"
-                f"{result.stdout.strip()}"
-                f" </stdout>"
-                f" <stderr>"
-                f"{result.stderr.strip()}"
-                f" </stderr>"
-                f" <returncode>"
-                f" {result.returncode}"
-                f" </returncode>"
+                f" <stdout>{stdout_content.strip()}</stdout>"
+                f" <returncode>{return_code}</returncode>"
                 f"</command_output>"
             )
-
-            return formated_result
-
-        except subprocess.TimeoutExpired:
-            return f"Command timed out after {timeout_seconds} seconds."
-        except subprocess.CalledProcessError as e:
-            return f"Command failed with error: {e.stderr.strip()}"
+            return formatted_result
         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()
-    print(tool.to_markdown())
+    print(tool.to_markdown())

quantalogic/tools/replace_in_file_tool.py

@@ -65,7 +65,6 @@ class ReplaceInFileTool(Tool):
     )
     need_validation: bool = True
 
-    # Adjust this threshold to allow more or less approximate matching
     SIMILARITY_THRESHOLD: float = 0.85
 
     arguments: list[ToolArgument] = [
@@ -124,6 +123,15 @@ class ReplaceInFileTool(Tool):
         ),
     ]
 
+    def normalize_whitespace(self, text: str) -> str:
+        """Normalize leading whitespace by converting tabs to spaces."""
+        return '\n'.join([self._normalize_line(line) for line in text.split('\n')])
+
+    def _normalize_line(self, line: str) -> str:
+        """Normalize leading whitespace in a single line."""
+        leading_ws = len(line) - len(line.lstrip())
+        return line.replace('\t', '    ', leading_ws)  # Convert tabs to 4 spaces only in leading whitespace
+
     def parse_diff(self, diff: str) -> list[SearchReplaceBlock]:
         """Parses the diff string into a list of SearchReplaceBlock instances."""
         if not diff or not diff.strip():
@@ -250,6 +258,7 @@ class ReplaceInFileTool(Tool):
             except Exception as e:
                 return f"Error: Failed to write changes to '{path}': {str(e) or 'Unknown error'}"
 
+            # Maintain original success message format
             message = [f"Successfully modified '{path}'"]
             for idx, block in enumerate(blocks, 1):
                 status = "Exact match" if block.similarity is None else f"Similar match ({block.similarity:.1%})"
@@ -267,26 +276,27 @@ class ReplaceInFileTool(Tool):
             return f"Error: Unexpected error occurred - {error_msg or 'Unknown error'}"
 
     def find_similar_match(self, search: str, content: str) -> Tuple[float, str]:
-        """Finds the most similar substring in content compared to search."""
-        if not search or not content:
-            return 0.0, ""
-
-        search_lines = search.splitlines()
-        content_lines = content.splitlines()
+        """Finds the most similar substring in content compared to search with whitespace normalization."""
+        norm_search = self.normalize_whitespace(search)
+        content_lines = content.split('\n')
+        norm_content = self.normalize_whitespace(content)
+        norm_content_lines = norm_content.split('\n')
 
-        if len(search_lines) > len(content_lines):
+        if len(norm_content_lines) < len(norm_search.split('\n')):
             return 0.0, ""
 
         max_similarity = 0.0
         best_match = ""
+        search_line_count = len(norm_search.split('\n'))
 
-        for i in range(len(content_lines) - len(search_lines) + 1):
-            candidate = "\n".join(content_lines[i : i + len(search_lines)])
-            similarity = difflib.SequenceMatcher(None, search, candidate).ratio()
+        for i in range(len(norm_content_lines) - search_line_count + 1):
+            candidate_norm = '\n'.join(norm_content_lines[i:i+search_line_count])
+            similarity = difflib.SequenceMatcher(None, norm_search, candidate_norm).ratio()
 
             if similarity > max_similarity:
                 max_similarity = similarity
-                best_match = candidate
+                # Get original lines (non-normalized) for accurate replacement
+                best_match = '\n'.join(content_lines[i:i+search_line_count])
 
         return max_similarity, best_match
 
@@ -297,4 +307,4 @@ class ReplaceInFileTool(Tool):
 
 if __name__ == "__main__":
     tool = ReplaceInFileTool()
-    print(tool.to_markdown())
+    print(tool.to_markdown())

{quantalogic-0.2.27.dist-info → quantalogic-0.2.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.27
+Version: 0.2.30
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -63,8 +63,10 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://quantalogic.github.io/quantalogic/)
 
 
+
 QuantaLogic is a  ReAct (Reasoning & Action) framework for building advanced AI agents. 
 
+
 It seamlessly integrates large language models (LLMs) with a robust tool system, enabling agents to understand, reason about, and execute complex tasks through natural language interaction.
 
 The `cli` version include coding capabilities comparable to Aider.

{quantalogic-0.2.27.dist-info → quantalogic-0.2.30.dist-info}/RECORD

@@ -10,7 +10,7 @@ quantalogic/event_emitter.py,sha256=jqot2g4JRXc88K6PW837Oqxbf7shZfO-xdPaUWmzupk,
 quantalogic/generative_model.py,sha256=az_kqWdEBQRROvvYZu6d68JQ4nzDbQG23gADeHLMypc,16761
 quantalogic/get_model_info.py,sha256=YCBZ8qynlq_iLUc--xBrQxacFZL9RHZPv5cdVwjukcw,602
 quantalogic/interactive_text_editor.py,sha256=_pNPnUG3Y3_YX0R9-kx0vcaUWU0AAC350jpJ5UjrTuE,6986
-quantalogic/main.py,sha256=YYP0DSnzlLpbyQPlQxbq-ZKIoA5ezv0kjy5LsQlT6bI,5227
+quantalogic/main.py,sha256=A0ruAGy1ptYH46VHrhIFZeVUQajrIK18Zvri0Itcmi0,6765
 quantalogic/memory.py,sha256=zbtRuM05jaS2lJll-92dt5JfYVLERnF_m_9xqp2x-k0,6304
 quantalogic/model_names.py,sha256=UZlz25zG9B2dpfwdw_e1Gw5qFsKQ7iME9FJh9Ts4u6s,938
 quantalogic/prompts.py,sha256=CW4CRgW1hTpXeWdeJNbPaRPUeUm-xKuGHJrT8mOtvkw,3602
@@ -33,7 +33,7 @@ quantalogic/tools/download_http_file_tool.py,sha256=wTfanbXjIRi5-qrbluuLvNmDNhvm
 quantalogic/tools/duckduckgo_search_tool.py,sha256=xVaEb_SUK5NL3lwMQXj1rGQYYvNT-td-qaB9QCes27Q,7014
 quantalogic/tools/edit_whole_content_tool.py,sha256=nXmpAvojvqvAcqNMy1kUKZ1ocboky_ZcnCR4SNCSPgw,2360
 quantalogic/tools/elixir_tool.py,sha256=fzPPtAW-Koy9KB0r5k2zV1f1U0WphL-LXPPOBkeNkug,7652
-quantalogic/tools/execute_bash_command_tool.py,sha256=fnx-zSPpxR2EofaleygAorrR21gRs43jBWh7IBAoNKw,4131
+quantalogic/tools/execute_bash_command_tool.py,sha256=kl3RSOZCOc-U52dwd0h6BxXvjMlAX7D0Bo2-HkCOcxo,6908
 quantalogic/tools/generate_database_report_tool.py,sha256=QbZjtmegGEOEZAIa-CSeBo5O9dYBZTk_PWrumyFUg1Q,1890
 quantalogic/tools/grep_app_tool.py,sha256=BDxygwx7WCbqbiP2jmSRnIsoIUVYG5A4SKzId524ys4,19957
 quantalogic/tools/input_question_tool.py,sha256=UoTlNhdmdr-eyiVtVCG2qJe_R4bU_ag-DzstSdmYkvM,1848
@@ -57,7 +57,7 @@ quantalogic/tools/python_tool.py,sha256=70HLbfU2clOBgj4axDOtIKzXwEBMNGEAX1nGSf-K
 quantalogic/tools/read_file_block_tool.py,sha256=FTcDAUOOPQOvWRjnRI6nMI1Upus90klR4PC0pbPP_S8,5266
 quantalogic/tools/read_file_tool.py,sha256=l6k-SOIV9krpXAmUTkxzua51S-KHgzGqkcDlD5AD8K0,2710
 quantalogic/tools/read_html_tool.py,sha256=Vq2rHY8a36z1-4rN6c_kYjPUTQ4I2UT154PMpaoWSkA,11139
-quantalogic/tools/replace_in_file_tool.py,sha256=n63s09Y8RXOKGjxfWw0D6F6JpQ6ERSJxVJOzmceVXLk,12953
+quantalogic/tools/replace_in_file_tool.py,sha256=AM2XSF5WMI48gOyAGsnUOeW-jlyorWV182Yw_BA26_o,13719
 quantalogic/tools/ripgrep_tool.py,sha256=sRzHaWac9fa0cCGhECJN04jw_Ko0O3u45KDWzMIYcvY,14291
 quantalogic/tools/search_definition_names.py,sha256=Qj9ex226vHs8Jf-kydmTh7B_R8O5buIsJpQu3CvYw7k,18601
 quantalogic/tools/serpapi_search_tool.py,sha256=sX-Noch77kGP2XiwislPNFyy3_4TH6TwMK6C81L3q9Y,5316
@@ -85,8 +85,8 @@ quantalogic/version_check.py,sha256=cttR1lR3OienGLl7NrK1Te1fhDkqSjCci7HC1vFUTSY,
 quantalogic/welcome_message.py,sha256=IXMhem8h7srzNUwvw8G_lmEkHU8PFfote021E_BXmVk,3039
 quantalogic/xml_parser.py,sha256=uMLQNHTRCg116FwcjRoquZmSwVtE4LEH-6V2E3RD-dA,11466
 quantalogic/xml_tool_parser.py,sha256=Vz4LEgDbelJynD1siLOVkJ3gLlfHsUk65_gCwbYJyGc,3784
-quantalogic-0.2.27.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.2.27.dist-info/METADATA,sha256=a2770Es_XksLjabRKUzbpKVp9BVrHaob7MdUVnGH7YE,20532
-quantalogic-0.2.27.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.2.27.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.2.27.dist-info/RECORD,,
+quantalogic-0.2.30.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.2.30.dist-info/METADATA,sha256=hjKqynOMQvyUjApchHNiYJDF5i0owdznI2gmo3TmKrs,20534
+quantalogic-0.2.30.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.2.30.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
+quantalogic-0.2.30.dist-info/RECORD,,