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

quantalogic/agent.py

@@ -164,7 +164,11 @@ class Agent(BaseModel):
         self.task_to_solve_summary = self._generate_task_summary(task)
 
         # Add system prompt to memory
-        self.memory.add(Message(role="system", content=self.config.system_prompt))
+        # Check if system prompt is already in memory
+        # if not add it
+        # The system message is always the first message in memory
+        if not self.memory.memory or self.memory.memory[0].role != "system":
+            self.memory.add(Message(role="system", content=self.config.system_prompt))
 
         self._emit_event(
             "session_start",

quantalogic/coding_agent.py

@@ -4,6 +4,7 @@ from quantalogic.tools import (
     DuckDuckGoSearchTool,
     EditWholeContentTool,
     ExecuteBashCommandTool,
+    GrepAppTool,
     InputQuestionTool,
     JinjaTool,
     ListDirectoryTool,
@@ -75,7 +76,8 @@ def create_coding_agent(
         InputQuestionTool(),
         DuckDuckGoSearchTool(),
         JinjaTool(),
-        ReadHTMLTool()
+        ReadHTMLTool(),
+        GrepAppTool()
     ]
 
     if vision_model_name:

quantalogic/tools/__init__.py

@@ -7,6 +7,8 @@ from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .edit_whole_content_tool import EditWholeContentTool
 from .elixir_tool import ElixirTool
 from .execute_bash_command_tool import ExecuteBashCommandTool
+from .generate_database_report_tool import GenerateDatabaseReportTool
+from .grep_app_tool import GrepAppTool
 from .input_question_tool import InputQuestionTool
 from .jinja_tool import JinjaTool
 from .list_directory_tool import ListDirectoryTool
@@ -22,6 +24,7 @@ from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
 from .search_definition_names import SearchDefinitionNames
 from .serpapi_search_tool import SerpApiSearchTool
+from .sql_query_tool import SQLQueryTool
 from .task_complete_tool import TaskCompleteTool
 from .tool import Tool, ToolArgument
 from .unified_diff_tool import UnifiedDiffTool
@@ -56,5 +59,8 @@ __all__ = [
     "EditWholeContentTool",
     "JinjaTool",
     "LLMImageGenerationTool",
-    "ReadHTMLTool"
+    "ReadHTMLTool",
+    "GrepAppTool",
+    "GenerateDatabaseReportTool",
+    'SQLQueryTool'
 ]

quantalogic/tools/generate_database_report_tool.py

@@ -0,0 +1,52 @@
+"""Tool for generating comprehensive database documentation reports."""
+
+from pydantic import Field, ValidationError
+
+from quantalogic.tools.tool import Tool
+from quantalogic.tools.utils.generate_database_report import generate_database_report
+
+
+class GenerateDatabaseReportTool(Tool):
+    """Tool for generating database documentation reports from a connection string."""
+
+    name: str = "generate_database_report_tool"
+    description: str = (
+        "Generates a comprehensive Markdown database documentation report with ER diagram. "
+    )
+    arguments: list = []  # No execution arguments - connection string is configured during tool setup
+    connection_string: str = Field(
+        ...,
+        description="SQLAlchemy-compatible database connection string (e.g., 'sqlite:///database.db')",
+        example="postgresql://user:password@localhost/mydatabase"
+    )
+
+    def execute(self) -> str:
+        """Generates a database documentation report using the configured connection string.
+
+        Returns:
+            str: Markdown-formatted database report
+
+        Raises:
+            ValueError: For invalid connection strings or database connection errors
+            RuntimeError: For errors during report generation
+        """
+        try:
+            return generate_database_report(self.connection_string)
+        except ValidationError as e:
+            raise ValueError(f"Invalid connection configuration: {e}") from e
+        except Exception as e:
+            raise RuntimeError(f"Database report generation failed: {e}") from e
+
+
+if __name__ == "__main__":
+
+    from quantalogic.tools.utils.create_sample_database import create_sample_database
+
+    # Create and document sample database
+    create_sample_database("sample.db")
+
+    # Example usage
+    tool = GenerateDatabaseReportTool(
+        connection_string="sqlite:///sample.db"
+    )
+    print(tool.execute())

quantalogic/tools/grep_app_tool.py

@@ -0,0 +1,499 @@
+# quantalogic/tools/grep_app_tool.py
+
+import random
+import sys
+import time
+from typing import Any, ClassVar, Dict, Optional, Union
+
+import requests
+from loguru import logger
+from pydantic import BaseModel, Field, ValidationError, model_validator
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Configurable User Agents
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/91.0.4472.124 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/91.0.4472.124 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) "
+    "Version/14.1.1 Safari/605.1.15"
+]
+
+class SearchError(Exception):
+    """Custom exception for search-related errors"""
+    pass
+
+class GrepAppArguments(BaseModel):
+    """Pydantic model for grep.app search arguments"""
+    search_query: str = Field(
+        ...,
+        description="GitHub Code search using simple keyword or regular expression",
+        example="code2prompt"
+    )
+    repository: Optional[str] = Field(
+        None,
+        description="Filter by repository (e.g. user/repo)",
+        example="quantalogic/quantalogic",
+    )
+    page: int = Field(
+        1,
+        description="Results page number",
+        ge=1
+    )
+    per_page: int = Field(
+        10,
+        description="Number of results per page",
+        ge=1,
+        le=100
+    )
+    regexp: bool = Field(
+        False,
+        description="Enable regular expression search"
+    )
+    case: bool = Field(
+        False,
+        description="Enable case-sensitive search"
+    )
+    words: bool = Field(
+        False,
+        description="Match whole words only"
+    )
+
+    @model_validator(mode='before')
+    @classmethod
+    def convert_types(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert input types before validation"""
+        # Convert string numbers to integers
+        for field in ['page', 'per_page']:
+            if field in data and isinstance(data[field], str):
+                try:
+                    data[field] = int(data[field])
+                except ValueError:
+                    raise ValueError(f"{field} must be a valid integer")
+
+        # Convert various string representations to booleans
+        for field in ['regexp', 'case', 'words']:
+            if field in data:
+                if isinstance(data[field], str):
+                    data[field] = data[field].lower() in ['true', '1', 'yes', 'on']
+
+        return data
+
+    @model_validator(mode='after')
+    def validate_search_query(self) -> 'GrepAppArguments':
+        """Validate search query is not empty and has reasonable length"""
+        if not self.search_query or not self.search_query.strip():
+            raise ValueError("Search query cannot be empty")
+        if len(self.search_query) > 500:  # Reasonable limit for search query
+            raise ValueError("Search query is too long (max 500 characters)")
+        return self
+
+class GrepAppTool(Tool):
+    """Tool for searching GitHub code via grep.app API"""
+    
+    BASE_URL: ClassVar[str] = "https://grep.app/api/search"
+    TIMEOUT: ClassVar[int] = 10
+
+    def __init__(self):
+        super().__init__(
+            name="grep_app_tool", 
+            description="Searches GitHub code using grep.app API. Returns code matches with metadata."
+        )
+        self.arguments = [
+            ToolArgument(
+                name="search_query",
+                arg_type="string",
+                description="Search query using grep.app syntax",
+                required=True
+            ),
+            ToolArgument(
+                name="repository",
+                arg_type="string",
+                description="Filter by repository",
+                required=False
+            ),
+            ToolArgument(
+                name="page",
+                arg_type="int",
+                description="Pagination page number",
+                default="1",
+                required=False
+            ),
+            ToolArgument(
+                name="per_page",
+                arg_type="int",
+                description="Results per page",
+                default="10",
+                required=False
+            ),
+            ToolArgument(
+                name="regexp",
+                arg_type="boolean",
+                description="Enable regular expression search",
+                default="False",
+                required=False
+            ),
+            ToolArgument(
+                name="case",
+                arg_type="boolean",
+                description="Enable case-sensitive search",
+                default="False",
+                required=False
+            ),
+            ToolArgument(
+                name="words",
+                arg_type="boolean",
+                description="Match whole words only",
+                default="False",
+                required=False
+            )
+        ]
+
+    def _build_headers(self) -> Dict[str, str]:
+        """Build request headers with random User-Agent"""
+        headers = {
+            "User-Agent": random.choice(USER_AGENTS),
+            "Accept": "application/json",
+            "Accept-Language": "en-US,en;q=0.5",
+            "DNT": "1"
+        }
+        logger.debug(f"Built headers: {headers}")
+        return headers
+
+    def _build_params(self, args: GrepAppArguments) -> Dict[str, Any]:
+        """Build request parameters from arguments"""
+        params = {
+            "q": args.search_query,
+            "page": args.page,
+            "per_page": args.per_page
+        }
+        if args.repository:
+            params["filter[repo][0]"] = args.repository
+        if args.regexp:
+            params["regexp"] = "true"
+        if args.case:
+            params["case"] = "true"
+        if args.words:
+            params["words"] = "true"
+        logger.debug(f"Built params: {params}")
+        return params
+
+    def _make_request(self, params: Dict[str, Any], headers: Dict[str, str]) -> Dict[str, Any]:
+        """Make the API request"""
+        logger.info("Making API request to grep.app")
+        response = requests.get(
+            self.BASE_URL,
+            params=params,
+            headers=headers,
+            timeout=self.TIMEOUT
+        )
+        logger.debug(f"API Response Status Code: {response.status_code}")
+        response.raise_for_status()
+        data = response.json()
+        if not isinstance(data, dict):
+            raise SearchError("Invalid response format from API")
+        logger.debug(f"API Response Data: {data}")
+        return data
+
+    def execute(self, 
+                search_query: str, 
+                repository: Optional[str] = None,
+                page: Union[int, str] = 1,
+                per_page: Union[int, str] = 10,
+                regexp: bool = False,
+                case: bool = False,
+                words: bool = False,
+                skip_delay: bool = False) -> str:
+        """Execute grep.app API search with pagination and return formatted results as a string"""
+        try:
+            # Validate and convert arguments
+            args = GrepAppArguments(
+                search_query=search_query,
+                repository=repository,
+                page=int(page),
+                per_page=int(per_page),
+                regexp=regexp,
+                case=case,
+                words=words
+            )
+
+            logger.info(f"Executing search: '{args.search_query}'")
+            logger.debug(f"Search parameters: {args.model_dump()}")
+
+            # Add random delay to mimic human behavior (unless skipped for testing)
+            if not skip_delay:
+                delay = random.uniform(0.5, 1.5)
+                logger.debug(f"Sleeping for {delay:.2f} seconds to mimic human behavior")
+                time.sleep(delay)
+
+            # Make API request
+            headers = self._build_headers()
+            params = self._build_params(args)
+            results = self._make_request(params, headers)
+
+            # Format and return results
+            return self._format_results(results)
+
+        except ValidationError as e:
+            logger.error(f"Validation error: {e}")
+            return self._format_error("Validation Error", str(e))
+        except requests.RequestException as e:
+            logger.error(f"API request failed: {e}")
+            return self._format_error(
+                "API Error",
+                str(e),
+                {"Request URL": getattr(e.response, 'url', 'N/A') if hasattr(e, 'response') else 'N/A'}
+            )
+        except SearchError as e:
+            logger.error(f"Search error: {e}")
+            return self._format_error("Search Error", str(e))
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            return self._format_error("Unexpected Error", str(e))
+
+    def _format_results(self, data: Dict[str, Any]) -> str:
+        """Format API results into a structured Markdown string"""
+        query = data.get('query', '')
+        total_results = data.get('hits', {}).get('total', 0)
+        hits = data.get("hits", {}).get("hits", [])
+
+        output = [
+            "# 🔍 Search Results",
+            "",
+            f"**Query:** `{query if query else '<empty>'}`  •  **Found:** {total_results} matches",
+            ""
+        ]
+
+        if not hits:
+            output.append("> No matches found for your search query.")
+        else:
+            for idx, result in enumerate(hits, 1):
+                repo = result.get('repo', {}).get('raw', 'N/A')
+                file_path = result.get('path', {}).get('raw', 'N/A')
+                language = result.get('language', 'N/A').lower()
+                content = result.get("content", {})
+                
+                # Extract the actual code and line info
+                snippet = content.get("snippet", "")
+                line_num = content.get("line", "")
+                
+                # Clean up the snippet
+                import re
+                clean_snippet = re.sub(r'<[^>]+>', '', snippet)
+                clean_snippet = re.sub(r'&quot;', '"', clean_snippet)
+                clean_snippet = re.sub(r'&lt;', '<', clean_snippet)
+                clean_snippet = re.sub(r'&gt;', '>', clean_snippet)
+                clean_snippet = clean_snippet.strip()
+                
+                # Split into lines and clean each line
+                raw_lines = clean_snippet.split('\n')
+                lines = []
+                current_line_num = int(line_num) if line_num else 1
+                
+                # First pass: collect all lines and their content
+                for line in raw_lines:
+                    # Remove excess whitespace but preserve indentation
+                    stripped = line.rstrip()
+                    if not stripped:
+                        lines.append(('', current_line_num))
+                        current_line_num += 1
+                        continue
+                    
+                    # Remove duplicate indentation
+                    if stripped.startswith('    '):
+                        stripped = stripped[4:]
+                    
+                    # Handle URLs that might be split across lines
+                    if stripped.startswith(('prompt', '-working')):
+                        if lines and lines[-1][0].endswith('/'):
+                            # Combine with previous line
+                            prev_content, prev_num = lines.pop()
+                            lines.append((prev_content + stripped, prev_num))
+                            continue
+                    
+                    # Handle concatenated lines by looking for line numbers
+                    line_parts = re.split(r'(\d+)(?=\s*[^\d])', stripped)
+                    if len(line_parts) > 1:
+                        # Process each part that might be a new line
+                        for i in range(0, len(line_parts)-1, 2):
+                            prefix = line_parts[i].rstrip()
+                            if prefix:
+                                if not any(l[0] == prefix for l in lines):  # Avoid duplicates
+                                    lines.append((prefix, current_line_num))
+                            
+                            # Update line number if found
+                            try:
+                                current_line_num = int(line_parts[i+1])
+                            except ValueError:
+                                current_line_num += 1
+                            
+                            # Add the content after the line number
+                            if i+2 < len(line_parts):
+                                content = line_parts[i+2].lstrip()
+                                if content and not any(l[0] == content for l in lines):  # Avoid duplicates
+                                    lines.append((content, current_line_num))
+                    else:
+                        if not any(l[0] == stripped for l in lines):  # Avoid duplicates
+                            lines.append((stripped, current_line_num))
+                        current_line_num += 1
+
+                # Format line numbers and code
+                formatted_lines = []
+                max_line_width = len(str(max(line[1] for line in lines))) if lines else 3
+                
+                # Second pass: format each line
+                for line_content, line_no in lines:
+                    if not line_content:  # Empty line
+                        formatted_lines.append('')
+                        continue
+                    
+                    # Special handling for markdown badges and links
+                    if '[![' in line_content or '[!' in line_content:
+                        badges = re.findall(r'(\[!\[.*?\]\(.*?\)\]\(.*?\))', line_content)
+                        if badges:
+                            for badge in badges:
+                                if not any(badge in l for l in formatted_lines):  # Avoid duplicates
+                                    formatted_lines.append(f"{str(line_no).rjust(max_line_width)} │ {badge}")
+                            continue
+                    
+                    # Add syntax highlighting for comments
+                    if line_content.lstrip().startswith(('// ', '# ', '/* ', '* ', '*/')):
+                        line_str = f"{str(line_no).rjust(max_line_width)} │ <dim>{line_content}</dim>"
+                        if not any(line_str in l for l in formatted_lines):  # Avoid duplicates
+                            formatted_lines.append(line_str)
+                    else:
+                        # Split line into indentation and content for better formatting
+                        indent = len(line_content) - len(line_content.lstrip())
+                        indentation = line_content[:indent]
+                        content = line_content[indent:]
+                        
+                        # Highlight strings and special syntax
+                        content = re.sub(r'(["\'])(.*?)\1', r'<str>\1\2\1</str>', content)
+                        content = re.sub(r'\b(function|const|let|var|import|export|class|interface|type|enum)\b', 
+                                       r'<keyword>\1</keyword>', content)
+                        
+                        line_str = f"{str(line_no).rjust(max_line_width)} │ {indentation}{content}"
+                        if not any(line_str in l for l in formatted_lines):  # Avoid duplicates
+                            formatted_lines.append(line_str)
+
+                # Truncate if too long and add line count
+                if len(formatted_lines) > 5:
+                    remaining = len(formatted_lines) - 5
+                    formatted_lines = formatted_lines[:5]
+                    if remaining > 0:
+                        formatted_lines.append(f"   ┆ {remaining} more line{'s' if remaining > 1 else ''}")
+                
+                clean_snippet = '\n'.join(formatted_lines)
+                
+                # Format the repository link to be clickable
+                if '/' in repo:
+                    repo_link = f"[`{repo}`](https://github.com/{repo})"
+                else:
+                    repo_link = f"`{repo}`"
+
+                # Determine the best language display and icon
+                lang_display = language if language != 'n/a' else ''
+                lang_icon = {
+                    'python': '🐍',
+                    'typescript': '📘',
+                    'javascript': '📒',
+                    'markdown': '📝',
+                    'toml': '⚙️',
+                    'yaml': '📋',
+                    'json': '📦',
+                    'shell': '🐚',
+                    'rust': '🦀',
+                    'go': '🔵',
+                    'java': '☕',
+                    'ruby': '💎',
+                }.get(lang_display, '📄')
+                
+                # Format file path with language icon and line info
+                file_info = [f"{lang_icon} `{file_path}`"]
+                if line_num:
+                    file_info.append(f"Line {line_num}")
+                
+                output.extend([
+                    f"### {repo_link}",
+                    " • ".join(file_info),
+                    "```",
+                    clean_snippet,
+                    "```",
+                    ""
+                ])
+
+        return "\n".join(filter(None, output))
+
+    def _format_error(self, error_type: str, message: str, additional_info: Dict[str, str] = None) -> str:
+        """Format error messages consistently using Markdown"""
+        output = [
+            f"## {error_type}",
+            f"**Message:** {message}"
+        ]
+        
+        if additional_info:
+            output.append("**Additional Information:**")
+            for key, value in additional_info.items():
+                output.append(f"- **{key}:** {value}")
+        
+        output.append(f"## End {error_type}")
+        return "\n\n".join(output)
+
+if __name__ == "__main__":
+    # Configure logger
+    logger.remove()  # Remove default handlers
+    logger.add(sys.stderr, level="INFO", format="<green>{time}</green> <level>{message}</level>")
+
+    logger.info("Starting GrepAppTool test cases")
+    tool = GrepAppTool()
+
+    test_cases = [
+        {
+            "name": "Python __init__ Methods Search",
+            "args": {
+                "search_query": "lang:python def __init__",
+                "per_page": 5,
+                "skip_delay": True  # Skip delay for testing
+            }
+        },
+        {
+            "name": "Logging Patterns Search",
+            "args": {
+                "search_query": "logger",
+                "per_page": 3,
+                "skip_delay": True
+            }
+        },
+        {
+            "name": "Repository-Specific Search",
+            "args": {
+                "search_query": "def",
+                "repository": "quantalogic/quantalogic",
+                "per_page": 5,
+                "words": True,
+                "skip_delay": True
+            }
+        },
+        {
+            "name": "Raphaël MANSUY",
+            "args": {
+                "search_query": "raphaelmansuy",
+                "per_page": 3,
+                "skip_delay": True
+            }
+        }
+    ]
+
+    for test in test_cases:
+        try:
+            logger.info(f"Running test: {test['name']}")
+            logger.info(f"Executing with arguments: {test['args']}")
+            result = tool.execute(**test['args'])
+            print(f"\n### Test: {test['name']}\n{result}\n")
+            time.sleep(1)  # Add a small delay between tests to avoid rate limiting
+        except Exception as e:
+            logger.error(f"{test['name']} Failed: {e}", exc_info=True)

quantalogic/tools/llm_tool.py

@@ -122,7 +122,6 @@ class LLMTool(Tool):
         # Prepare the messages history
         messages_history = [
             Message(role="system", content=used_system_prompt),
-            Message(role="user", content=prompt),
         ]
 
         is_streaming = self.on_token is not None

quantalogic/tools/sql_query_tool.py

@@ -0,0 +1,167 @@
+"""Tool for executing SQL queries and returning paginated results in markdown format."""
+
+from typing import Any, Dict, List
+
+from pydantic import Field, ValidationError
+from sqlalchemy import create_engine, text
+from sqlalchemy.exc import SQLAlchemyError
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class SQLQueryTool(Tool):
+    """Tool for executing SQL queries and returning paginated results in markdown format."""
+
+    name: str = "sql_query_tool"
+    description: str = (
+        "Executes a SQL query and returns results in markdown table format "
+        "with pagination support. Results are truncated based on start/end row numbers."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="query",
+            arg_type="string",
+            description="The SQL query to execute",
+            required=True,
+            example="SELECT * FROM customers WHERE country = 'France'"
+        ),
+        ToolArgument(
+            name="start_row",
+            arg_type="int",
+            description="1-based starting row number for results",
+            required=True,
+            example="1"
+        ),
+        ToolArgument(
+            name="end_row",
+            arg_type="int",
+            description="1-based ending row number for results",
+            required=True,
+            example="100"
+        ),
+    ]
+    connection_string: str = Field(
+        ...,
+        description="SQLAlchemy-compatible database connection string",
+        example="postgresql://user:password@localhost/mydb"
+    )
+
+    def execute(self, query: str, start_row: Any, end_row: Any) -> str:
+        """
+        Executes a SQL query and returns formatted results.
+        
+        Args:
+            query: SQL query to execute
+            start_row: 1-based starting row number (supports various numeric types)
+            end_row: 1-based ending row number (supports various numeric types)
+            
+        Returns:
+            str: Markdown-formatted results with pagination metadata
+            
+        Raises:
+            ValueError: For invalid parameters or query errors
+            RuntimeError: For database connection issues
+        """
+        try:
+            # Convert and validate row numbers
+            start = self._convert_row_number(start_row, "start_row")
+            end = self._convert_row_number(end_row, "end_row")
+            
+            if start > end:
+                raise ValueError(f"start_row ({start}) must be <= end_row ({end})")
+
+            # Execute query
+            engine = create_engine(self.connection_string)
+            with engine.connect() as conn:
+                result = conn.execute(text(query))
+                columns: List[str] = result.keys()
+                all_rows: List[Dict] = [dict(row._mapping) for row in result]
+
+            # Apply pagination
+            total_rows = len(all_rows)
+            actual_start = max(1, start)
+            actual_end = min(end, total_rows)
+            
+            if actual_start > total_rows:
+                return f"No results found (total rows: {total_rows})"
+
+            # Slice results (convert to 0-based index)
+            displayed_rows = all_rows[actual_start-1:actual_end]
+
+            # Format results
+            markdown = [
+                f"**Query Results:** `{actual_start}-{actual_end}` of `{total_rows}` rows",
+                self._format_table(columns, displayed_rows)
+            ]
+
+            # Add pagination notice
+            if actual_end < total_rows:
+                remaining = total_rows - actual_end
+                markdown.append(f"\n*Showing first {actual_end} rows - {remaining} more row{'s' if remaining > 1 else ''} available*")
+
+            return "\n".join(markdown)
+
+        except SQLAlchemyError as e:
+            raise ValueError(f"SQL Error: {str(e)}") from e
+        except ValidationError as e:
+            raise ValueError(f"Validation Error: {str(e)}") from e
+        except Exception as e:
+            raise RuntimeError(f"Database Error: {str(e)}") from e
+
+    def _convert_row_number(self, value: Any, field_name: str) -> int:
+        """Convert and validate row number input."""
+        try:
+            # Handle numeric strings and floats
+            if isinstance(value, str):
+                if "." in value:
+                    num = float(value)
+                else:
+                    num = int(value)
+            else:
+                num = value
+
+            converted = int(num)
+            if converted != num:  # Check if float had decimal part
+                raise ValueError("Decimal values are not allowed for row numbers")
+                
+            if converted <= 0:
+                raise ValueError(f"{field_name} must be a positive integer")
+                
+            return converted
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Invalid value for {field_name}: {repr(value)}") from e
+
+    def _format_table(self, columns: List[str], rows: List[Dict]) -> str:
+        """Format results as markdown table with truncation."""
+        if not rows:
+            return "No results found"
+
+        # Create header
+        header = "| " + " | ".join(columns) + " |"
+        separator = "| " + " | ".join(["---"] * len(columns)) + " |"
+        
+        # Create rows with truncation
+        body = []
+        for row in rows:
+            values = []
+            for col in columns:
+                val = str(row.get(col, ""))
+                # Truncate long values
+                values.append(val[:50] + "..." if len(val) > 50 else val)
+            body.append("| " + " | ".join(values) + " |")
+
+        return "\n".join([header, separator] + body)
+
+
+
+if __name__ == "__main__":
+    from quantalogic.tools.utils.create_sample_database import create_sample_database
+
+    # Create and document sample database
+    create_sample_database("sample.db")
+    tool = SQLQueryTool(connection_string="sqlite:///sample.db")
+    print(tool.execute("select * from customers", 1, 10))
+    print(tool.execute("select * from customers", 11, 20))
+     
+    
+    

quantalogic/tools/utils/__init__.py

@@ -0,0 +1,13 @@
+"""
+Utility functions and classes for quantalogic tools.
+
+This module provides common utility functions used across the quantalogic package.
+"""
+
+from .create_sample_database import create_sample_database
+from .generate_database_report import generate_database_report
+
+__all__ = [
+    'create_sample_database',
+    'generate_database_report'
+]

quantalogic/tools/utils/create_sample_database.py

@@ -0,0 +1,124 @@
+import random
+from datetime import datetime, timedelta
+
+from faker import Faker
+from sqlalchemy import Column, Date, Float, ForeignKey, Integer, String, create_engine
+from sqlalchemy.orm import declarative_base, relationship, sessionmaker
+
+Base = declarative_base()
+fake = Faker()
+
+def create_sample_database(db_path: str) -> None:
+    """
+    Creates a sample SQLite database with 5 tables and 10 rows each.
+    
+    Args:
+        db_path: Path to the SQLite database file (e.g., 'sample.db')
+    """
+    # Define database schema
+    class Customer(Base):
+        __tablename__ = 'customers'
+        id = Column(Integer, primary_key=True)
+        name = Column(String)
+        email = Column(String)
+        addresses = relationship("Address", back_populates="customer")
+        orders = relationship("Order", back_populates="customer")
+
+    class Address(Base):
+        __tablename__ = 'addresses'
+        id = Column(Integer, primary_key=True)
+        street = Column(String)
+        city = Column(String)
+        customer_id = Column(Integer, ForeignKey('customers.id'))
+        customer = relationship("Customer", back_populates="addresses")
+
+    class Product(Base):
+        __tablename__ = 'products'
+        id = Column(Integer, primary_key=True)
+        name = Column(String)
+        price = Column(Float)
+
+    class Order(Base):
+        __tablename__ = 'orders'
+        id = Column(Integer, primary_key=True)
+        order_date = Column(Date)
+        customer_id = Column(Integer, ForeignKey('customers.id'))
+        customer = relationship("Customer", back_populates="orders")
+        items = relationship("OrderItem", back_populates="order")
+
+    class OrderItem(Base):
+        __tablename__ = 'order_items'
+        id = Column(Integer, primary_key=True)
+        quantity = Column(Integer)
+        order_id = Column(Integer, ForeignKey('orders.id'))
+        product_id = Column(Integer, ForeignKey('products.id'))
+        order = relationship("Order", back_populates="items")
+        product = relationship("Product")
+
+    # Create database and tables
+    engine = create_engine(f'sqlite:///{db_path}')
+    Base.metadata.create_all(engine)
+    Session = sessionmaker(bind=engine)  # noqa: N806
+    session = Session()
+
+    # Generate sample data
+    try:
+        # Create 10 customers
+        customers = []
+        for _ in range(10):
+            customer = Customer(
+                name=fake.name(),
+                email=fake.email()
+            )
+            customers.append(customer)
+            session.add(customer)
+        
+        session.commit()
+
+        # Create 10 addresses (1 per customer)
+        for customer in customers:
+            address = Address(
+                street=fake.street_address(),
+                city=fake.city(),
+                customer=customer
+            )
+            session.add(address)
+        
+        # Create 10 products
+        products = []
+        for _ in range(10):
+            product = Product(
+                name=fake.word().capitalize(),
+                price=round(random.uniform(10, 1000), 2)
+            )
+            products.append(product)
+            session.add(product)
+        
+        # Create 10 orders (1 per customer)
+        orders = []
+        start_date = datetime.now() - timedelta(days=365)
+        for customer in customers:
+            order = Order(
+                order_date=fake.date_between(start_date=start_date),
+                customer=customer
+            )
+            orders.append(order)
+            session.add(order)
+        
+        # Create 10 order items (1 per order)
+        for order in orders:
+            order_item = OrderItem(
+                quantity=random.randint(1, 5),
+                order=order,
+                product=random.choice(products)
+            )
+            session.add(order_item)
+
+        session.commit()
+    finally:
+        session.close()
+
+# Example usage
+if __name__ == "__main__":
+    create_sample_database("sample.db")
+    print("Sample database created successfully!")

quantalogic/tools/utils/generate_database_report.py

@@ -0,0 +1,289 @@
+from datetime import UTC, datetime
+from typing import Dict, List
+
+import networkx as nx
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.engine import Inspector
+
+
+def generate_database_report(connection_string: str) -> str:
+    """
+    Generates a comprehensive Markdown database documentation report with ER diagram.
+    
+    Args:
+        connection_string: SQLAlchemy-compatible database connection string
+        
+    Returns:
+        Markdown-formatted report as a string
+    """
+    # Setup database connection and inspection
+    engine = create_engine(connection_string)
+    inspector = inspect(engine)
+    
+    # Collect database metadata
+    db_metadata = {
+        'name': engine.url.database,
+        'dialect': engine.dialect.name,
+        'tables': inspector.get_table_names()
+    }
+    
+    # Initialize data structures
+    graph = nx.DiGraph()
+    table_metadata: Dict[str, dict] = {}
+    fk_relationships: List[dict] = []
+    sampled_ids: Dict[str, list] = {}
+    sample_data: Dict[str, list] = {}
+
+    # Collect schema metadata and relationships
+    for table in db_metadata['tables']:
+        columns = inspector.get_columns(table)
+        pk = inspector.get_pk_constraint(table).get('constrained_columns', [])
+        indexes = inspector.get_indexes(table)
+        fks = inspector.get_foreign_keys(table)
+        
+        # Process foreign keys
+        for fk in fks:
+            process_foreign_key(table, fk, inspector, graph, fk_relationships)
+        
+        table_metadata[table] = {
+            'columns': columns,
+            'primary_keys': pk,
+            'indexes': indexes,
+            'foreign_keys': fks
+        }
+
+    # Process tables in dependency order
+    sorted_tables = get_sorted_tables(graph, db_metadata['tables'])
+    
+    # Collect sample data with parent-child relationships
+    collect_sample_data(engine, sorted_tables, table_metadata, sample_data, sampled_ids)
+    
+    # Generate Markdown report
+    return generate_markdown_report(db_metadata, sorted_tables, table_metadata, 
+                                  fk_relationships, sample_data)
+
+
+def process_foreign_key(
+    table: str,
+    fk: dict,
+    inspector: Inspector,
+    graph: nx.DiGraph,
+    fk_relationships: List[dict]
+) -> None:
+    """Process and record foreign key relationships with cardinality information."""
+    src_col = fk['constrained_columns'][0]
+    tgt_table = fk['referred_table']
+    tgt_col = fk['referred_columns'][0]
+    
+    # Check uniqueness and nullability in source column
+    src_columns = inspector.get_columns(table)
+    src_col_meta = next(c for c in src_columns if c['name'] == src_col)
+    is_unique = src_col_meta.get('unique', False) or src_col in inspector.get_pk_constraint(table).get('constrained_columns', [])
+    is_nullable = src_col_meta['nullable']
+
+    fk_relationships.append({
+        'source_table': table,
+        'source_column': src_col,
+        'target_table': tgt_table,
+        'target_column': tgt_col,
+        'constraint_name': fk['name'],
+        'is_unique': is_unique,
+        'is_nullable': is_nullable
+    })
+    graph.add_edge(table, tgt_table)
+
+
+def get_sorted_tables(graph: nx.DiGraph, tables: List[str]) -> List[str]:
+    """Return tables sorted topologically with fallback to original order."""
+    try:
+        return list(nx.topological_sort(graph))
+    except nx.NetworkXUnfeasible:
+        return tables
+
+
+def collect_sample_data(
+    engine,
+    tables: List[str],
+    table_metadata: Dict[str, dict],
+    sample_data: Dict[str, list],
+    sampled_ids: Dict[str, list]
+) -> None:
+    """Collect sample data while maintaining referential integrity."""
+    for table in tables:
+        with engine.connect() as conn:
+            # Get parent samples
+            result = conn.execute(text(f"SELECT * FROM {table} LIMIT 5"))
+            samples = [dict(row._mapping) for row in result]
+            sample_data[table] = samples
+            
+            # Store IDs for child sampling
+            if samples and table_metadata[table]['primary_keys']:
+                pk_col = table_metadata[table]['primary_keys'][0]
+                sampled_ids[table] = [row[pk_col] for row in samples]
+
+
+def generate_markdown_report(
+    db_metadata: dict,
+    tables: List[str],
+    table_metadata: Dict[str, dict],
+    fk_relationships: List[dict],
+    sample_data: Dict[str, list]
+) -> str:
+    """Generate the complete Markdown report."""
+    md = []
+    
+    # Database Summary
+    md.append("# Database Documentation Report\n")
+    md.append(f"**Database Type**: {db_metadata['dialect'].capitalize()}\n")
+    md.append(f"**Database Name**: {db_metadata['name']}\n")
+    md.append(f"**Total Tables**: {len(db_metadata['tables'])}\n")
+    md.append(f"**Generated At**: {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")
+    
+    # ERD Section
+    md.append("## Entity Relationship Diagram\n")
+    md.append("```mermaid\nerDiagram\n")
+    generate_erd_section(md, tables, table_metadata, fk_relationships)
+    md.append("```\n\n")
+    
+    # Schema Details
+    md.append("## Schema Details\n")
+    for table in tables:
+        meta = table_metadata[table]
+        md.append(f"### {table}\n")
+        generate_columns_section(md, meta)
+        generate_indexes_section(md, meta)
+    
+    # Relationships
+    generate_relationships_section(md, fk_relationships)
+    
+    # Cardinality Report
+    generate_cardinality_section(md, fk_relationships)
+    
+    # Data Samples
+    md.append("## Data Samples\n")
+    for table in tables:
+        samples = sample_data[table]
+        md.append(f"### {table}\n")
+        generate_sample_table(md, samples)
+    
+    return '\n'.join(md)
+
+
+def generate_erd_section(md: List[str], tables: List[str], table_metadata: Dict[str, dict], fk_relationships: List[dict]) -> None:
+    """Generate Mermaid ER diagram section."""
+    # Define tables with their columns
+    for table in tables:
+        table_upper = table.upper()
+        md.append(f"    {table_upper} {{\n")
+        for col in table_metadata[table]['columns']:
+            col_type = str(col['type']).split('(')[0].upper()  # Simplify type names
+            annotations = []
+            if col['name'] in table_metadata[table]['primary_keys']:
+                annotations.append("PK")
+            # Check if column is a foreign key
+            for fk in fk_relationships:
+                if fk['source_table'] == table and fk['source_column'] == col['name']:
+                    annotations.append("FK")
+                    break
+            annotation_str = " ".join(annotations)
+            md.append(f"        {col_type} {col['name']} {annotation_str}\n")
+        md.append("    }\n")
+    
+    # Define relationships with cardinality
+    for fk in fk_relationships:
+        target_table = fk['target_table'].upper()
+        source_table = fk['source_table'].upper()
+        source_cardinality = get_source_cardinality(fk['is_unique'], fk['is_nullable'])
+        md.append(f"    {target_table} ||--{source_cardinality} {source_table} : \"{fk['constraint_name']}\"\n")
+
+
+def get_source_cardinality(is_unique: bool, is_nullable: bool) -> str:
+    """Determine Mermaid cardinality symbol for source side of relationship."""
+    if is_unique:
+        return "|o" if is_nullable else "||"
+    else:
+        return "o{" if is_nullable else "|{"
+
+
+def generate_relationships_section(md: List[str], fk_relationships: List[dict]) -> None:
+    """Generate foreign key relationships section."""
+    if fk_relationships:
+        md.append("## Relationships\n")
+        for fk in fk_relationships:
+            src = f"{fk['source_table']}.{fk['source_column']}"
+            tgt = f"{fk['target_table']}.{fk['target_column']}"
+            md.append(f"- `{src}` → `{tgt}` (Constraint: `{fk['constraint_name']}`)\n")
+        md.append("\n")
+
+
+def generate_cardinality_section(md: List[str], fk_relationships: List[dict]) -> None:
+    """Generate cardinality report section."""
+    cardinalities = {}
+    for fk in fk_relationships:
+        key = (fk['target_table'], fk['source_table'])
+        if key in cardinalities:
+            continue
+            
+        if fk['is_unique']:
+            cardinality = "(1) → (1)"
+        else:
+            cardinality = "(1) → (N)"
+            
+        cardinalities[key] = f"{fk['target_table']} {cardinality} {fk['source_table']}"
+    
+    if cardinalities:
+        md.append("## Cardinality Report\n")
+        for entry in cardinalities.values():
+            md.append(f"- {entry}\n")
+        md.append("\n")
+
+
+def generate_columns_section(md: List[str], meta: dict) -> None:
+    """Generate columns table section."""
+    md.append("#### Columns\n")
+    md.append("| Column Name | Data Type | Nullable? | Primary Key? |\n")
+    md.append("|-------------|-----------|-----------|--------------|\n")
+    for col in meta['columns']:
+        pk = "Yes" if col['name'] in meta['primary_keys'] else "No"
+        md.append(f"| `{col['name']}` | {col['type']} | {'Yes' if col['nullable'] else 'No'} | {pk} |\n")
+    md.append("\n")
+
+
+def generate_indexes_section(md: List[str], meta: dict) -> None:
+    """Generate indexes section."""
+    if meta['indexes']:
+        md.append("#### Indexes\n")
+        for idx in meta['indexes']:
+            columns = ", ".join(idx['column_names'])
+            md.append(f"- `{idx['name']}` ({idx['type'] or 'INDEX'}) → {columns}\n")
+        md.append("\n")
+
+
+def generate_sample_table(md: List[str], samples: list) -> None:
+    """Generate sample data table section."""
+    if not samples:
+        md.append("No records found.\n\n")
+        return
+        
+    headers = samples[0].keys()
+    md.append("| " + " | ".join(headers) + " |\n")
+    md.append("|" + "|".join(["---"] * len(headers)) + "|\n")
+    
+    for row in samples:
+        values = []
+        for val in row.values():
+            if isinstance(val, str) and len(val) > 50:
+                values.append(f"{val[:47]}...")
+            else:
+                values.append(str(val))
+        md.append("| " + " | ".join(values) + " |\n")
+    md.append("\n")
+
+
+if __name__ == "__main__":
+    from quantalogic.tools.utils.create_sample_database import create_sample_database
+    
+    # Create and document sample database
+    create_sample_database("sample.db")
+    report = generate_database_report("sqlite:///sample.db")
+    print(report)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.25
+Version: 0.2.27
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -12,6 +12,7 @@ Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: boto3 (>=1.35.86,<2.0.0)
 Requires-Dist: click (>=8.1.8,<9.0.0)
 Requires-Dist: duckduckgo-search (>=7.2.1,<8.0.0)
+Requires-Dist: faker (>=33.3.1,<34.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
 Requires-Dist: google-search-results (>=2.4.2,<3.0.0)
@@ -28,13 +29,16 @@ Requires-Dist: mkdocs-mermaid2-plugin (>=1.1.1,<2.0.0)
 Requires-Dist: mkdocs-minify-plugin (>=0.7.1,<0.8.0)
 Requires-Dist: mkdocstrings (>=0.24.0,<0.25.0)
 Requires-Dist: mkdocstrings-python (>=1.7.0,<2.0.0)
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
 Requires-Dist: pathspec (>=0.12.1,<0.13.0)
 Requires-Dist: prompt-toolkit (>=3.0.48,<4.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pymdown-extensions (>=10.3.1,<11.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: serpapi (>=0.1.5,<0.2.0)
+Requires-Dist: sqlalchemy (>=2.0.37,<3.0.0)
 Requires-Dist: tenacity (>=9.0.0,<10.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tree-sitter (>=0.23.2,<0.24.0)
@@ -82,7 +86,7 @@ We created [QuantaLogic](https://www.quantalogic.app) because we saw a significa
 ## 🌟 Highlights
 
 - **ReAct Framework**: Advanced implementation combining LLM reasoning with concrete actions
-- **Universal LLM Support**: Integration with OpenAI, Anthropic, LM Studio, Bedrock, Ollama, DeepSeek V3, via LiteLLM
+- **Universal LLM Support**: Integration with OpenAI, Anthropic, LM Studio, Bedrock, Ollama, DeepSeek V3, DeepSeek R1, via LiteLLM. Example usage: `quantalogic --model-name deepseek/deepseek-reasoner` or `quantalogic --model-name openrouter/deepseek/deepseek-r1`
 - **Secure Tool System**: Docker-based code execution and file manipulation tools
 - **Real-time Monitoring**: Web interface with SSE-based event visualization
 - **Memory Management**: Intelligent context handling and optimization

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

@@ -1,8 +1,8 @@
 quantalogic/__init__.py,sha256=kX0c_xmD9OslWnAE92YHMGuD7xZcTo8ZOF_5R64HKps,784
-quantalogic/agent.py,sha256=JJQkUcUtwkXHMk2Fk3_PG-R1ZI_axz0v6L0FcEztDJM,31615
+quantalogic/agent.py,sha256=r6MbnVaBv9tYNk8WR7YJAjXlEGgko8GSYitWzr7uNMY,31841
 quantalogic/agent_config.py,sha256=9sjDnCPlAqVM45oguB_D509WSCaXZmuaVUtLcOvDlPg,7572
 quantalogic/agent_factory.py,sha256=ODVGuGtugSzmSdP6jiWlT8WyC5onANc6BIs83FC90Bg,3782
-quantalogic/coding_agent.py,sha256=UJ0fdKKA8XSB2py0NW4-e-orozo78ZAprXWuortYBiA,4935
+quantalogic/coding_agent.py,sha256=Z7ik6LUvLKDnaW9Ax1iZGC7p1WMnlYEUIlE5lkBP414,4975
 quantalogic/console_print_events.py,sha256=KB-DGi52As8M96eUs1N_vgNqKIFtqv_H8NTOd3TLTgQ,2163
 quantalogic/console_print_token.py,sha256=qSU-3kmoZk4T5-1ybrEBi8tIXDPcz7eyWKhGh3E8uIg,395
 quantalogic/docs_cli.py,sha256=3giVbUpespB9ZdTSJ955A3BhcOaBl5Lwsn1AVy9XAeY,1663
@@ -26,7 +26,7 @@ quantalogic/server/templates/index.html,sha256=nDnXJoQEm1vXbhXtgaYk0G5VXj0wwzE6K
 quantalogic/task_file_reader.py,sha256=AMIJoeVY9Hhu0dBJ-C5EyaOFsXLkhn2oBhVs-WTnnLk,1460
 quantalogic/task_runner.py,sha256=FtxfZs2dxdsSZoiW92K3dpfegFe0dyKx9ZP5CCyEAzo,9965
 quantalogic/tool_manager.py,sha256=JAC5E5kLfYzYJx0QRIWbG14q1hlkOcwJFBG7HE8twpU,2425
-quantalogic/tools/__init__.py,sha256=GcYjE1r6aNQ_JZ8uwk0yaCCCMBz6zrD_PjkRtZiUhSk,1923
+quantalogic/tools/__init__.py,sha256=pTirT5UBynuTkAzFYebu7ttGAMP3_A0idFvDp6lGZJQ,2146
 quantalogic/tools/agent_tool.py,sha256=MXCXxWHRch7VK4UWhtRP1jeI8Np9Ne2CUGo8vm1oZiM,3064
 quantalogic/tools/dalle_e.py,sha256=nur2kl6DKjaWWaHcmF_y9vS5bvty2fW8hQfdgf5KWfs,10948
 quantalogic/tools/download_http_file_tool.py,sha256=wTfanbXjIRi5-qrbluuLvNmDNhvmYAnlMVb3dO8C2ss,2210
@@ -34,6 +34,8 @@ quantalogic/tools/duckduckgo_search_tool.py,sha256=xVaEb_SUK5NL3lwMQXj1rGQYYvNT-
 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/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
 quantalogic/tools/jinja_tool.py,sha256=1bqkFia2GtfntIyTVg4tCiPP8S1dX43U7QsrBE1Ngps,2893
 quantalogic/tools/language_handlers/__init__.py,sha256=5GD6TYsMqRni0nwePp2KOjNQ04GnT5wihT6YAuvx43c,699
@@ -47,7 +49,7 @@ quantalogic/tools/language_handlers/rust_handler.py,sha256=t_AqKVa3KVk6SVkq_UjUU
 quantalogic/tools/language_handlers/scala_handler.py,sha256=wr-cWOIFOc0UYwODmEtT6rV63Qf1NyNB_BLo23GLrvk,1281
 quantalogic/tools/language_handlers/typescript_handler.py,sha256=L4vuJMYxKO3_83dQhdwZ9fogauIV7rwoicRT0xLGfkQ,1738
 quantalogic/tools/list_directory_tool.py,sha256=8Hy38DelSh-mRqS_uDLpeBYoHLtEy5ji77xI-TJu3Ms,4176
-quantalogic/tools/llm_tool.py,sha256=6OSfEyV-VDlJjoQrRusXgeM-CPbTLZv1Yr1aRaXndVI,7064
+quantalogic/tools/llm_tool.py,sha256=CFTvr-RTFiuGWlOLtvw4zv93s_CLUHuHfNmvK6QpQiQ,7014
 quantalogic/tools/llm_vision_tool.py,sha256=eVDIrANxxZCHxYp9xaAN8hLdFhlYm7bUu2tX9-1xUbI,5496
 quantalogic/tools/markitdown_tool.py,sha256=lpbJBLx43_x2DjiZAV1HSidkHeqkkV0KvgeLG2fphK4,4339
 quantalogic/tools/nodejs_tool.py,sha256=zdnE0VFj_5786uR2L0o-SKR0Gk8L-U7rdj7xGHJYIq0,19905
@@ -59,9 +61,13 @@ quantalogic/tools/replace_in_file_tool.py,sha256=n63s09Y8RXOKGjxfWw0D6F6JpQ6ERSJ
 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
+quantalogic/tools/sql_query_tool.py,sha256=oScXJeLevIiKj_2-byPtD1fQ2FltlzywazVI68aNidc,6068
 quantalogic/tools/task_complete_tool.py,sha256=L8tuyVoN07Q2hOsxx17JTW0C5Jd_N-C0i_0PtCUQUKU,929
 quantalogic/tools/tool.py,sha256=fdD-wwAOgfua2RRk1FHv_mlNBQ1FTzPO8vMIKiRirZM,9800
 quantalogic/tools/unified_diff_tool.py,sha256=wTKXIoBEPcC_EcQmpJZVi95vq0Ncvsw1Kyc7XqPO6dU,14147
+quantalogic/tools/utils/__init__.py,sha256=qLQaS1JvZt_Bfg5sTj-TUa47u2IatLaIwDZe0EtXELI,344
+quantalogic/tools/utils/create_sample_database.py,sha256=Aus9xRLGfQfsYnxsAkJ5CW-Za6fwKQeqm2mOXqgkMis,4018
+quantalogic/tools/utils/generate_database_report.py,sha256=0D-5fWOfpAh1jEcld5OTQP5x6XkJE5jpNY6FyHv1L2s,10345
 quantalogic/tools/wikipedia_search_tool.py,sha256=bdZ_0dYTxpEfU04tBFsatnLM5P9Z3kAZgKQEjsopJLA,5405
 quantalogic/tools/write_file_tool.py,sha256=_mx9_Zjg2oMAAVzlcHEKjZVZUxQVgbRfcoMKgWnoZcg,3764
 quantalogic/utils/__init__.py,sha256=Ltq7tzLuHCl9BpCvfRVA9Sjrtp1RJesrn7G980lbl_c,563
@@ -79,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.25.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.2.25.dist-info/METADATA,sha256=MwnMh_F2PiVY2lYXAStsCFpf0Slcs67RAFtbu1jbFwk,20216
-quantalogic-0.2.25.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.2.25.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.2.25.dist-info/RECORD,,
+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,,