quantalogic 0.2.0__py3-none-any.whl

quantalogic/tools/unified_diff_tool.py

@@ -0,0 +1,387 @@
+import argparse
+import os
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class LineType(Enum):
+    """Enum for different types of lines in a patch."""
+
+    CONTEXT = " "
+    ADDITION = "+"
+    DELETION = "-"
+
+    @classmethod
+    def from_line(cls, line: str) -> Optional["LineType"]:
+        """Get the line type from a patch line."""
+        if line.startswith(" "):
+            return cls.CONTEXT
+        elif line.startswith("+"):
+            return cls.ADDITION
+        elif line.startswith("-"):
+            return cls.DELETION
+        return None
+
+
+@dataclass
+class PatchLine:
+    """Represents a line in a patch with type and content."""
+
+    type: LineType
+    content: str
+    original_line_number: Optional[int] = None
+    new_line_number: Optional[int] = None
+
+
+@dataclass
+class HunkHeader:
+    """Represents a hunk header in a patch."""
+
+    orig_start: int
+    orig_count: int
+    new_start: int
+    new_count: int
+    section_header: Optional[str] = None
+
+
+@dataclass
+class Hunk:
+    """Represents a complete hunk in a patch with validation and application logic."""
+
+    header: HunkHeader
+    lines: List[PatchLine]
+
+    def validate(self, file_lines: List[str], start_line: int, lenient: bool = False, tolerance: int = 5) -> int:
+        """Validate hunk context against file contents with detailed error reporting.
+
+        Args:
+            file_lines (List[str]): The lines of the file to patch.
+            start_line (int): The expected starting line number for the hunk.
+            lenient (bool): Whether to allow lenient matching of context lines.
+            tolerance (int): The number of lines to search around the expected line for context matching.
+
+        Returns:
+            int: The offset to apply to subsequent lines in the hunk.
+        """
+        if not file_lines:
+            if self.header.orig_start > 0:
+                raise PatchError("Cannot delete from empty file", {"Hunk header": self._format_header()})
+            return 0
+
+        if start_line > len(file_lines):
+            raise PatchError(
+                "Patch refers to lines beyond file length",
+                {"File length": len(file_lines), "Start line": start_line, "Hunk header": self._format_header()},
+            )
+
+        context_lines = [line for line in self.lines if line.type in (LineType.CONTEXT, LineType.DELETION)]
+        if not context_lines:  # Only additions, no context to validate
+            return 0
+
+        file_pos = start_line - 1
+        offset = 0
+
+        for patch_line in context_lines:
+            expected_line = file_pos + offset
+            search_start = max(0, expected_line - tolerance)
+            search_end = min(len(file_lines), expected_line + tolerance + 1)
+
+            found = False
+            for i in range(search_start, search_end):
+                if file_lines[i].rstrip() == patch_line.content.rstrip():
+                    found = True
+                    if i != expected_line:
+                        offset = i - expected_line
+                    break
+
+            if not found:
+                raise PatchError(
+                    "Context mismatch",
+                    {
+                        "Expected": patch_line.content.rstrip(),
+                        "Found": file_lines[expected_line].rstrip()
+                        if expected_line < len(file_lines)
+                        else "End of file",
+                        "At line": expected_line + 1,
+                        "Hunk header": self._format_header(),
+                        "Offset": offset,
+                    },
+                )
+
+            file_pos += 1
+
+        return offset
+
+    def _format_header(self) -> str:
+        """Format hunk header for error messages."""
+        header = (
+            f"@@ -{self.header.orig_start},{self.header.orig_count} +{self.header.new_start},{self.header.new_count} @@"
+        )
+        if self.header.section_header:
+            header += f" {self.header.section_header}"
+        return header
+
+    def apply(self, lines: List[str], start_line: int, offset: int = 0) -> List[str]:
+        """Apply this hunk to the given lines."""
+        result = lines[: start_line - 1 + offset]
+        file_pos = start_line - 1 + offset
+
+        for patch_line in self.lines:
+            if patch_line.type == LineType.CONTEXT:
+                if file_pos < len(lines):
+                    result.append(lines[file_pos])
+                file_pos += 1
+            elif patch_line.type == LineType.ADDITION:
+                result.append(patch_line.content.rstrip() + "\n")
+            elif patch_line.type == LineType.DELETION:
+                if file_pos < len(lines):
+                    file_pos += 1
+
+        result.extend(lines[file_pos:])
+        return result
+
+
+class PatchError(Exception):
+    """Custom exception for patch-related errors with context."""
+
+    def __init__(self, message: str, context: Optional[Dict] = None):
+        self.context = context or {}
+        super().__init__(message)
+
+    def __str__(self):
+        msg = [super().__str__()]
+        if self.context:
+            for key, value in self.context.items():
+                msg.append(f"\n{key}:")
+                msg.append(f"  {str(value)}")
+        return "\n".join(msg)
+
+
+class Patch:
+    """Represents a complete patch with enhanced parsing and validation."""
+
+    def __init__(self, content: str):
+        self.content = content
+        self.hunks: List[Hunk] = []
+        self.original_filename: Optional[str] = None
+        self.new_filename: Optional[str] = None
+        self.metadata: Dict[str, str] = {}
+        self._parse()
+
+    def _parse(self) -> None:
+        """Parse the patch content with metadata and headers."""
+        if not self.content:
+            raise PatchError("Empty patch content")
+
+        lines = self.content.splitlines()
+        if not lines:
+            raise PatchError("No lines in patch")
+
+        if self.content.startswith("<![CDATA[") and self.content.endswith("]]>"):
+            self.content = self.content[9:-3]
+            lines = self.content.splitlines()
+
+        self._parse_headers(lines)
+        self._parse_hunks(lines)
+
+        if not self.hunks:
+            raise PatchError("No valid hunks found in patch")
+
+    def _parse_headers(self, lines: List[str]) -> None:
+        """Parse patch headers and metadata."""
+        for line in lines:
+            if line.startswith("--- "):
+                self.original_filename = line[4:].split("\t")[0].strip()
+            elif line.startswith("+++ "):
+                self.new_filename = line[4:].split("\t")[0].strip()
+            elif ":" in line:  # Possible metadata
+                key, value = line.split(":", 1)
+                self.metadata[key.strip()] = value.strip()
+
+    def _parse_hunks(self, lines: List[str]) -> None:
+        """Parse patch hunks with line number tracking."""
+        current_hunk_lines: List[str] = []
+        in_hunk = False
+
+        for line in lines:
+            if line.startswith("@@ "):
+                if current_hunk_lines:
+                    self._parse_hunk(current_hunk_lines)
+                    current_hunk_lines = []
+                in_hunk = True
+
+            if in_hunk:
+                current_hunk_lines.append(line)
+            elif not (line.startswith("--- ") or line.startswith("+++ ") or line.strip() == ""):
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    self.metadata[key.strip()] = value.strip()
+
+        if current_hunk_lines:
+            self._parse_hunk(current_hunk_lines)
+
+    def _parse_hunk(self, lines: List[str]) -> None:
+        """Parse a single hunk from its lines."""
+        if not lines or not lines[0].startswith("@@ "):
+            raise PatchError("Invalid hunk format", {"First line": lines[0] if lines else "No lines"})
+
+        header = self._parse_hunk_header(lines[0])
+        patch_lines: List[PatchLine] = []
+        orig_line = header.orig_start
+        new_line = header.new_start
+
+        for line in lines[1:]:
+            line_type = LineType.from_line(line)
+            if line_type:
+                content = line[1:]
+                patch_line = PatchLine(line_type, content)
+                if line_type in (LineType.CONTEXT, LineType.DELETION):
+                    patch_line.original_line_number = orig_line
+                    orig_line += 1
+                if line_type in (LineType.CONTEXT, LineType.ADDITION):
+                    patch_line.new_line_number = new_line
+                    new_line += 1
+                patch_lines.append(patch_line)
+
+        self.hunks.append(Hunk(header, patch_lines))
+
+    def _parse_hunk_header(self, header_line: str) -> HunkHeader:
+        """Parse a hunk header line."""
+        if not header_line.startswith("@@ "):
+            raise PatchError("Malformed hunk header", {"Header line": header_line})
+
+        parts = header_line.split("@@")
+        if len(parts) < 3:
+            raise PatchError("Malformed hunk header", {"Header line": header_line})
+
+        ranges = parts[1].strip().split(" ")
+        if len(ranges) != 2:
+            raise PatchError("Malformed hunk ranges", {"Header line": header_line, "Ranges": ranges})
+
+        orig_range = ranges[0][1:]
+        new_range = ranges[1][1:]
+
+        try:
+            orig_start, orig_count = self._parse_range(orig_range)
+            new_start, new_count = self._parse_range(new_range)
+        except ValueError as e:
+            raise PatchError(
+                "Invalid range format",
+                {"Header line": header_line, "Original range": orig_range, "New range": new_range, "Error": str(e)},
+            )
+
+        section_header = " ".join(parts[2:]).strip() if len(parts) > 2 else None
+        return HunkHeader(orig_start, orig_count, new_start, new_count, section_header)
+
+    def _parse_range(self, range_str: str) -> Tuple[int, int]:
+        """Parse a range string (e.g., 'start,length') into start and count."""
+        try:
+            if "," in range_str:
+                start, count = range_str.split(",")
+                return int(start), int(count)
+            return int(range_str), 1
+        except ValueError:
+            raise ValueError(f"Invalid range format: {range_str}")
+
+    def apply_to_text(self, text: str, lenient: bool = False, tolerance: int = 5) -> str:
+        """Apply the patch to the given text with enhanced error handling."""
+        lines = text.splitlines(keepends=True) if text else []
+
+        for hunk in self.hunks:
+            offset = hunk.validate(lines, hunk.header.orig_start, lenient, tolerance)
+            lines = hunk.apply(lines, hunk.header.orig_start, offset)
+
+        return "".join(lines)
+
+
+class UnifiedDiffTool(Tool):
+    """Tool for applying unified diff patches with comprehensive error handling."""
+
+    name: str = "unified_diff"
+    description: str = "Applies a unified diff patch to update a file."
+    need_validation: bool = True
+    lenient: bool = True
+    tolerance: int = 5
+    arguments: list[ToolArgument] = [
+        ToolArgument(
+            name="file_path",
+            arg_type="string",
+            description="The path to the file to patch. Using an absolute path is recommended.",
+            required=True,
+            example="/path/to/file.txt",
+        ),
+        ToolArgument(
+            name="patch",
+            arg_type="string",
+            description="The unified diff patch content in CDATA format.",
+            required=True,
+            example="<![CDATA[--- a/file.txt\n+++ b/file.txt\n@@ -1,3 +1,4 @@\n Hello, world!\n+New line!]]>",
+        ),
+    ]
+
+    def execute(self, file_path: str, patch: str):
+        """Apply the patch to the specified file."""
+        error_context = {
+            "File": file_path,
+            "File exists": os.path.exists(file_path),
+        }
+
+        try:
+            if os.path.exists(file_path):
+                with open(file_path, encoding="utf-8") as f:
+                    original_content = f.read()
+                    error_context["File preview"] = (
+                        original_content[:200] + "..." if len(original_content) > 200 else original_content
+                    )
+            else:
+                original_content = ""
+
+            patch_obj = Patch(patch)
+            new_content = patch_obj.apply_to_text(original_content, lenient=self.lenient, tolerance=self.tolerance)
+
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(new_content)
+
+            return "Patch applied successfully"
+
+        except Exception as e:
+            raise PatchError(f"Unexpected error: {str(e)}", error_context)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Apply a unified diff patch to a file")
+    parser.add_argument("file_path", help="Path to the file to patch")
+    parser.add_argument("--patch-file", help="Path to the patch file")
+    parser.add_argument("--patch", help="Patch content as string")
+    parser.add_argument("--lenient", action="store_true", help="Enable lenient mode for patch application")
+    parser.add_argument(
+        "--tolerance", type=int, default=5, help="Number of lines to search around for context matching"
+    )
+
+    args = parser.parse_args()
+
+    if args.patch_file and args.patch:
+        parser.error("Cannot specify both --patch-file and --patch")
+
+    if args.patch_file:
+        with open(args.patch_file, encoding="utf-8") as f:
+            patch_content = f.read()
+    elif args.patch:
+        patch_content = args.patch
+    else:
+        parser.error("Must specify either --patch-file or --patch")
+
+    tool = UnifiedDiffTool()
+    tool.lenient = args.lenient
+    tool.tolerance = args.tolerance
+    try:
+        result = tool.execute(args.file_path, patch_content)
+        print(result)
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)

quantalogic/tools/write_file_tool.py

@@ -0,0 +1,97 @@
+"""Tool for writing a file and returning its content."""
+
+import os
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class WriteFileTool(Tool):
+    """Tool for writing a text file."""
+
+    name: str = "write_file_tool"
+    description: str = "Writes a file with the given content. The tool will fail if the file already exists when not used in append mode."
+    need_validation: bool = True
+    arguments: list = [
+        ToolArgument(
+            name="file_path",
+            arg_type="string",
+            description="The path to the file to write. Using an absolute path is recommended.",
+            required=True,
+            example="/path/to/file.txt",
+        ),
+        ToolArgument(
+            name="content",
+            arg_type="string",
+            description="""
+            The content to write to the file. Use CDATA to escape special characters.
+            Don't add newlines at the beginning or end of the content.
+            """,
+            required=True,
+            example="Hello, world!",
+        ),
+        ToolArgument(
+            name="append_mode",
+            arg_type="string",
+            description="""Append mode. If true, the content will be appended to the end of the file.
+            """,
+            required=False,
+            example="False",
+        ),
+        ToolArgument(
+            name="overwrite",
+            arg_type="string",
+            description="Overwrite mode. If true, existing files can be overwritten. Defaults to False.",
+            required=False,
+            example="False",
+        ),
+    ]
+
+    def execute(self, file_path: str, content: str, append_mode: str = "False", overwrite: str = "False") -> str:
+        """Writes a file with the given content.
+
+        Args:
+            file_path (str): The path to the file to write.
+            content (str): The content to write to the file.
+            append_mode (str, optional): If true, append content to existing file. Defaults to "False".
+            overwrite (str, optional): If true, overwrite existing file. Defaults to "False".
+
+        Returns:
+            str: The content of the file.
+
+        Raises:
+            FileExistsError: If the file already exists and append_mode is False and overwrite is False.
+        """
+        # Convert mode strings to booleans
+        append_mode_bool = append_mode.lower() in ["true", "1", "yes"]
+        overwrite_bool = overwrite.lower() in ["true", "1", "yes"]
+
+        ## Handle tilde expansion
+        if file_path.startswith("~"):
+            # Expand the tilde to the user's home directory
+            file_path = os.path.expanduser(file_path)
+
+        # Convert relative paths to absolute paths using current working directory
+        if not os.path.isabs(file_path):
+            file_path = os.path.abspath(os.path.join(os.getcwd(), file_path))
+
+        # Ensure parent directory exists
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        # Determine file write mode based on append_mode
+        mode = "a" if append_mode_bool else "w"
+
+        # Check if file already exists and not in append mode and not in overwrite mode
+        if os.path.exists(file_path) and not append_mode_bool and not overwrite_bool:
+            raise FileExistsError(
+                f"File {file_path} already exists. Set append_mode=True to append or overwrite=True to overwrite."
+            )
+
+        with open(file_path, mode, encoding="utf-8") as f:
+            f.write(content)
+        file_size = os.path.getsize(file_path)
+        return f"File {file_path} {'appended to' if append_mode_bool else 'written'} successfully. Size: {file_size} bytes."
+
+
+if __name__ == "__main__":
+    tool = WriteFileTool()
+    print(tool.to_markdown())

quantalogic/utils/__init__.py

@@ -0,0 +1,17 @@
+from .download_http_file import download_http_file  # noqa: I001
+from .read_file import read_file
+from .read_http_text_content import read_http_text_content
+from .git_ls import git_ls
+from .get_environment import get_environment
+from .get_coding_environment import get_coding_environment
+from .get_quantalogic_rules_content import get_quantalogic_rules_file_content
+
+__all__ = [
+    "download_http_file",
+    "read_http_text_content",
+    "read_file",
+    "git_ls",
+    "get_environment",
+    "get_coding_environment",
+    "get_quantalogic_rules_file_content",
+]

quantalogic/utils/ask_user_validation.py

@@ -0,0 +1,12 @@
+def console_ask_for_user_validation(question: str = "Do you want to continue?") -> bool:
+    """Prompt the user for validation using Rich.
+
+    Args:
+        question (str): The validation question.
+
+    Returns:
+        bool: User's confirmation.
+    """
+    from rich.prompt import Confirm
+
+    return Confirm.ask(question, default=True)

quantalogic/utils/download_http_file.py

@@ -0,0 +1,77 @@
+"""Utility function to download a file from a given URL and save it to a local path."""
+
+import logging
+from time import sleep
+from typing import Optional
+
+import requests
+from requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout, TooManyRedirects
+
+# Configure logging
+logging.basicConfig(level=logging.ERROR, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def download_http_file(
+    url: str, local_path: str, chunk_size: int = 8192, max_retries: int = 3, timeout: int = 10, delay: int = 2
+) -> Optional[str]:
+    """Downloads a file from a given URL and saves it to the specified local path.
+
+    Args:
+        url (str): The URL of the file to download.
+        local_path (str): The local file path where the downloaded file will be saved.
+        chunk_size (int): The size of each chunk to download. Default is 8192 bytes.
+        max_retries (int): The maximum number of retries for transient errors. Default is 3.
+        timeout (int): Timeout in seconds for the HTTP request. Default is 10.
+        delay (int): Delay in seconds between retries. Default is 2.
+
+    Returns:
+        Optional[str]: The local path where the file was saved if successful, None otherwise.
+    """
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "*/*",
+    }
+
+    for attempt in range(max_retries):
+        try:
+            logger.info(f"Attempt {attempt + 1} of {max_retries} to download {url}")
+            response = requests.get(url, headers=headers, stream=True, timeout=timeout)
+            response.raise_for_status()
+
+            content_type = response.headers.get("Content-Type", "unknown")
+            logger.info(f"Downloading content with Content-Type: {content_type}")
+
+            with open(local_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    file.write(chunk)
+
+            logger.info(f"File successfully downloaded and saved to {local_path}")
+            return local_path
+
+        except HTTPError as http_err:
+            status_code = http_err.response.status_code if http_err.response else "unknown"
+            error_msg = f"HTTP error occurred (status code: {status_code}, URL: {url}): {http_err}"
+            logger.error(error_msg)
+            if status_code in [404, 403, 401]:  # Don't retry for these status codes
+                break
+        except ConnectionError as conn_err:
+            error_msg = f"Connection error occurred (URL: {url}): {conn_err}"
+            logger.error(error_msg)
+        except Timeout as timeout_err:
+            error_msg = f"Request timed out after {timeout} seconds (URL: {url}): {timeout_err}"
+            logger.error(error_msg)
+        except TooManyRedirects as redirect_err:
+            error_msg = f"Too many redirects (URL: {url}): {redirect_err}"
+            logger.error(error_msg)
+        except RequestException as req_err:
+            error_msg = f"An unexpected error occurred (URL: {url}): {req_err}"
+            logger.error(error_msg)
+
+        if attempt < max_retries - 1:
+            sleep_duration = delay * (2**attempt)  # Exponential backoff
+            logger.info(f"Retrying in {sleep_duration} seconds...")
+            sleep(sleep_duration)
+
+    logger.error("Max retries reached. Download failed.")
+    return None

quantalogic/utils/get_coding_environment.py

@@ -0,0 +1,15 @@
+import os
+
+from quantalogic.utils.get_environment import get_environment
+from quantalogic.utils.git_ls import git_ls
+
+
+def get_coding_environment() -> str:
+    """Retrieve coding environment details."""
+    return (
+        f"{get_environment()}"
+        "\n\n"
+        "<codebase_first_level>\n"
+        f"{git_ls(directory_path=os.getcwd())}"
+        "\n</codebase_first_level>\n"
+    )

quantalogic/utils/get_environment.py

@@ -0,0 +1,26 @@
+import os
+from datetime import datetime
+
+from loguru import logger
+
+
+def get_environment() -> str:
+    """Retrieve the current environment details."""
+    try:
+        logger.debug("Retrieving environment details.")
+        shell = os.getenv("SHELL", "bash")
+        current_dir = os.getcwd()
+        operating_system = os.name
+        date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        environment_details = (
+            f"Current shell: {shell}\n"
+            f"Current directory: {current_dir}\n"
+            f"Operating system: {operating_system}\n"
+            f"Date and time: {date_time}"
+        )
+        logger.debug(f"Environment details:\n{environment_details}")
+        return environment_details
+    except Exception as e:
+        logger.error(f"Error retrieving environment details: {str(e)}")
+        return "Environment details unavailable."

quantalogic/utils/get_quantalogic_rules_content.py

@@ -0,0 +1,19 @@
+from typing import Union
+
+
+def get_quantalogic_rules_file_content() -> Union[str, None]:
+    """
+    Reads the content of the .quantalogicrules file in the current directory.
+
+    Returns:
+        Union[str, None]: The content of the .quantalogicrules file if it exists.
+                          Returns None if the file does not exist.
+                          Raises RuntimeError if an error occurs while reading the file.
+    """
+    try:
+        with open(".quantalogicrules") as file:
+            return file.read()
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        raise RuntimeError(f"Error reading .quantalogicrules file: {e}")