hanzo-mcp 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

hanzo_mcp/tools/database/sql_search.py

@@ -0,0 +1,296 @@
+"""SQL search tool for text search in database."""
+
+import sqlite3
+from typing import Annotated, Optional, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.database.database_manager import DatabaseManager
+
+
+SearchPattern = Annotated[
+    str,
+    Field(
+        description="Search pattern (SQL LIKE syntax, % for wildcard)",
+        min_length=1,
+    ),
+]
+
+Table = Annotated[
+    str,
+    Field(
+        description="Table to search in (files, symbols, metadata)",
+        default="files",
+    ),
+]
+
+Column = Annotated[
+    Optional[str],
+    Field(
+        description="Specific column to search (searches all text columns if not specified)",
+        default=None,
+    ),
+]
+
+ProjectPath = Annotated[
+    Optional[str],
+    Field(
+        description="Project path (defaults to current directory)",
+        default=None,
+    ),
+]
+
+MaxResults = Annotated[
+    int,
+    Field(
+        description="Maximum number of results",
+        default=50,
+    ),
+]
+
+
+class SqlSearchParams(TypedDict, total=False):
+    """Parameters for SQL search tool."""
+
+    pattern: str
+    table: str
+    column: Optional[str]
+    project_path: Optional[str]
+    max_results: int
+
+
+@final
+class SqlSearchTool(BaseTool):
+    """Tool for searching text in SQLite database."""
+
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
+        """Initialize the SQL search tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+            db_manager: Database manager instance
+        """
+        self.permission_manager = permission_manager
+        self.db_manager = db_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "sql_search"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Search for text patterns in the project's SQLite database.
+
+Supports SQL LIKE pattern matching:
+- % matches any sequence of characters
+- _ matches any single character
+- Use %pattern% to search for pattern anywhere
+
+Tables available:
+- files: Search in file paths and content
+- symbols: Search in symbol names, types, and signatures
+- metadata: Search in key-value metadata
+
+Examples:
+- sql_search --pattern "%TODO%" --table files
+- sql_search --pattern "test_%" --table symbols --column name
+- sql_search --pattern "%config%" --table metadata
+- sql_search --pattern "%.py" --table files --column path
+
+Use sql_query for complex queries with joins, conditions, etc."""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[SqlSearchParams],
+    ) -> str:
+        """Execute SQL search.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Search results
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        pattern = params.get("pattern")
+        if not pattern:
+            return "Error: pattern is required"
+
+        table = params.get("table", "files")
+        column = params.get("column")
+        project_path = params.get("project_path")
+        max_results = params.get("max_results", 50)
+
+        # Validate table
+        valid_tables = ["files", "symbols", "metadata"]
+        if table not in valid_tables:
+            return f"Error: Invalid table '{table}'. Must be one of: {', '.join(valid_tables)}"
+
+        # Get project database
+        try:
+            if project_path:
+                project_db = self.db_manager.get_project_db(project_path)
+            else:
+                import os
+                project_db = self.db_manager.get_project_for_path(os.getcwd())
+                
+            if not project_db:
+                return "Error: Could not find project database"
+
+        except PermissionError as e:
+            return str(e)
+        except Exception as e:
+            return f"Error accessing project database: {str(e)}"
+
+        await tool_ctx.info(f"Searching in {table} table for pattern: {pattern}")
+
+        # Build search query
+        conn = None
+        try:
+            conn = project_db.get_sqlite_connection()
+            cursor = conn.cursor()
+            
+            # Get searchable columns for the table
+            if column:
+                # Validate column exists
+                cursor.execute(f"PRAGMA table_info({table})")
+                columns_info = cursor.fetchall()
+                column_names = [col[1] for col in columns_info]
+                
+                if column not in column_names:
+                    return f"Error: Column '{column}' not found in table '{table}'. Available columns: {', '.join(column_names)}"
+                
+                search_columns = [column]
+            else:
+                # Get all text columns
+                search_columns = self._get_text_columns(cursor, table)
+                if not search_columns:
+                    return f"Error: No searchable text columns in table '{table}'"
+
+            # Build WHERE clause
+            where_conditions = [f"{col} LIKE ?" for col in search_columns]
+            where_clause = " OR ".join(where_conditions)
+            
+            # Build query
+            if table == "files":
+                query = f"""
+                    SELECT path, SUBSTR(content, 1, 200) as snippet, size, modified_at
+                    FROM {table}
+                    WHERE {where_clause}
+                    LIMIT ?
+                """
+                params_list = [pattern] * len(search_columns) + [max_results]
+                
+            elif table == "symbols":
+                query = f"""
+                    SELECT name, type, file_path, line_start, signature
+                    FROM {table}
+                    WHERE {where_clause}
+                    ORDER BY type, name
+                    LIMIT ?
+                """
+                params_list = [pattern] * len(search_columns) + [max_results]
+                
+            else:  # metadata
+                query = f"""
+                    SELECT key, value, updated_at
+                    FROM {table}
+                    WHERE {where_clause}
+                    LIMIT ?
+                """
+                params_list = [pattern] * len(search_columns) + [max_results]
+            
+            # Execute search
+            cursor.execute(query, params_list)
+            results = cursor.fetchall()
+            
+            if not results:
+                return f"No results found for pattern '{pattern}' in {table}"
+            
+            # Format results
+            output = self._format_results(table, results, pattern, search_columns)
+            
+            return f"Found {len(results)} result(s) in {table}:\n\n{output}"
+
+        except sqlite3.Error as e:
+            await tool_ctx.error(f"SQL error: {str(e)}")
+            return f"SQL error: {str(e)}"
+        except Exception as e:
+            await tool_ctx.error(f"Unexpected error: {str(e)}")
+            return f"Error executing search: {str(e)}"
+        finally:
+            if conn:
+                conn.close()
+
+    def _get_text_columns(self, cursor: sqlite3.Cursor, table: str) -> list[str]:
+        """Get text columns for a table."""
+        cursor.execute(f"PRAGMA table_info({table})")
+        columns_info = cursor.fetchall()
+        
+        # Get TEXT columns
+        text_columns = []
+        for col in columns_info:
+            col_name = col[1]
+            col_type = col[2].upper()
+            if 'TEXT' in col_type or 'CHAR' in col_type or col_type == '':
+                text_columns.append(col_name)
+        
+        return text_columns
+
+    def _format_results(self, table: str, results: list, pattern: str, search_columns: list[str]) -> str:
+        """Format search results based on table type."""
+        output = []
+        
+        if table == "files":
+            output.append(f"Searched columns: {', '.join(search_columns)}\n")
+            for row in results:
+                path, snippet, size, modified = row
+                output.append(f"File: {path}")
+                output.append(f"Size: {size} bytes")
+                output.append(f"Modified: {modified}")
+                if snippet:
+                    # Highlight pattern in snippet
+                    snippet = snippet.replace('\n', ' ')
+                    if len(snippet) > 150:
+                        snippet = snippet[:150] + "..."
+                    output.append(f"Content: {snippet}")
+                output.append("-" * 60)
+                
+        elif table == "symbols":
+            output.append(f"Searched columns: {', '.join(search_columns)}\n")
+            for row in results:
+                name, type_, file_path, line_start, signature = row
+                output.append(f"{type_}: {name}")
+                output.append(f"File: {file_path}:{line_start}")
+                if signature:
+                    output.append(f"Signature: {signature}")
+                output.append("-" * 60)
+                
+        else:  # metadata
+            output.append(f"Searched columns: {', '.join(search_columns)}\n")
+            for row in results:
+                key, value, updated = row
+                output.append(f"Key: {key}")
+                output.append(f"Value: {value}")
+                output.append(f"Updated: {updated}")
+                output.append("-" * 60)
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/database/sql_stats.py

@@ -0,0 +1,254 @@
+"""SQL statistics tool for database insights."""
+
+import sqlite3
+from typing import Annotated, Optional, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.database.database_manager import DatabaseManager
+
+
+ProjectPath = Annotated[
+    Optional[str],
+    Field(
+        description="Project path (defaults to current directory)",
+        default=None,
+    ),
+]
+
+Detailed = Annotated[
+    bool,
+    Field(
+        description="Show detailed statistics",
+        default=False,
+    ),
+]
+
+
+class SqlStatsParams(TypedDict, total=False):
+    """Parameters for SQL stats tool."""
+
+    project_path: Optional[str]
+    detailed: bool
+
+
+@final
+class SqlStatsTool(BaseTool):
+    """Tool for getting SQLite database statistics."""
+
+    def __init__(self, permission_manager: PermissionManager, db_manager: DatabaseManager):
+        """Initialize the SQL stats tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+            db_manager: Database manager instance
+        """
+        self.permission_manager = permission_manager
+        self.db_manager = db_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "sql_stats"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Get statistics about the project's SQLite database.
+
+Shows:
+- Database size and location
+- Table information (row counts, sizes)
+- Index information
+- Column statistics
+- Most common values (with --detailed)
+
+Examples:
+- sql_stats                    # Basic stats for current project
+- sql_stats --detailed         # Detailed statistics
+- sql_stats --project-path /path/to/project
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[SqlStatsParams],
+    ) -> str:
+        """Get database statistics.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Database statistics
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        project_path = params.get("project_path")
+        detailed = params.get("detailed", False)
+
+        # Get project database
+        try:
+            if project_path:
+                project_db = self.db_manager.get_project_db(project_path)
+            else:
+                import os
+                project_db = self.db_manager.get_project_for_path(os.getcwd())
+                
+            if not project_db:
+                return "Error: Could not find project database"
+
+        except PermissionError as e:
+            return str(e)
+        except Exception as e:
+            return f"Error accessing project database: {str(e)}"
+
+        await tool_ctx.info(f"Getting statistics for project: {project_db.project_path}")
+
+        # Collect statistics
+        conn = None
+        try:
+            conn = project_db.get_sqlite_connection()
+            cursor = conn.cursor()
+            
+            output = []
+            output.append(f"=== SQLite Database Statistics ===")
+            output.append(f"Project: {project_db.project_path}")
+            output.append(f"Database: {project_db.sqlite_path}")
+            
+            # Get database size
+            db_size = project_db.sqlite_path.stat().st_size
+            output.append(f"Database Size: {self._format_size(db_size)}")
+            output.append("")
+            
+            # Get table statistics
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+            tables = cursor.fetchall()
+            
+            output.append("=== Tables ===")
+            total_rows = 0
+            
+            for (table_name,) in tables:
+                if table_name.startswith('sqlite_'):
+                    continue
+                    
+                # Get row count
+                cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+                row_count = cursor.fetchone()[0]
+                total_rows += row_count
+                
+                # Get table info
+                cursor.execute(f"PRAGMA table_info({table_name})")
+                columns = cursor.fetchall()
+                col_count = len(columns)
+                
+                output.append(f"\n{table_name}:")
+                output.append(f"  Rows: {row_count:,}")
+                output.append(f"  Columns: {col_count}")
+                
+                if detailed and row_count > 0:
+                    # Show column details
+                    output.append("  Columns:")
+                    for col in columns:
+                        col_name = col[1]
+                        col_type = col[2]
+                        is_pk = col[5]
+                        not_null = col[3]
+                        
+                        flags = []
+                        if is_pk:
+                            flags.append("PRIMARY KEY")
+                        if not_null:
+                            flags.append("NOT NULL")
+                        
+                        flag_str = f" ({', '.join(flags)})" if flags else ""
+                        output.append(f"    - {col_name}: {col_type}{flag_str}")
+                    
+                    # Show sample data for specific tables
+                    if table_name == "files" and row_count > 0:
+                        cursor.execute(f"SELECT COUNT(DISTINCT SUBSTR(path, -3)) as ext_count FROM {table_name}")
+                        ext_count = cursor.fetchone()[0]
+                        output.append(f"  File types: ~{ext_count}")
+                        
+                    elif table_name == "symbols" and row_count > 0:
+                        cursor.execute(f"SELECT type, COUNT(*) as count FROM {table_name} GROUP BY type ORDER BY count DESC LIMIT 5")
+                        symbol_types = cursor.fetchall()
+                        output.append("  Symbol types:")
+                        for sym_type, count in symbol_types:
+                            output.append(f"    - {sym_type}: {count}")
+                
+                # Get indexes
+                cursor.execute(f"PRAGMA index_list({table_name})")
+                indexes = cursor.fetchall()
+                if indexes:
+                    output.append(f"  Indexes: {len(indexes)}")
+            
+            output.append(f"\nTotal Rows: {total_rows:,}")
+            
+            # Get index statistics
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='index' AND sql IS NOT NULL ORDER BY name")
+            indexes = cursor.fetchall()
+            if indexes:
+                output.append(f"\n=== Indexes ===")
+                output.append(f"Total Indexes: {len(indexes)}")
+                
+                if detailed:
+                    for (idx_name,) in indexes:
+                        cursor.execute(f"PRAGMA index_info({idx_name})")
+                        idx_info = cursor.fetchall()
+                        if idx_info:
+                            cols = [info[2] for info in idx_info]
+                            output.append(f"  {idx_name}: ({', '.join(cols)})")
+            
+            # Database properties
+            if detailed:
+                output.append("\n=== Database Properties ===")
+                
+                # Page size
+                cursor.execute("PRAGMA page_size")
+                page_size = cursor.fetchone()[0]
+                output.append(f"Page Size: {page_size:,} bytes")
+                
+                # Page count
+                cursor.execute("PRAGMA page_count")
+                page_count = cursor.fetchone()[0]
+                output.append(f"Page Count: {page_count:,}")
+                
+                # Cache size
+                cursor.execute("PRAGMA cache_size")
+                cache_size = cursor.fetchone()[0]
+                output.append(f"Cache Size: {abs(cache_size):,} pages")
+            
+            return "\n".join(output)
+
+        except sqlite3.Error as e:
+            await tool_ctx.error(f"SQL error: {str(e)}")
+            return f"SQL error: {str(e)}"
+        except Exception as e:
+            await tool_ctx.error(f"Unexpected error: {str(e)}")
+            return f"Error getting statistics: {str(e)}"
+        finally:
+            if conn:
+                conn.close()
+
+    def _format_size(self, size: int) -> str:
+        """Format file size in human-readable format."""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size < 1024.0:
+                return f"{size:.1f} {unit}"
+            size /= 1024.0
+        return f"{size:.1f} TB"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/editor/__init__.py

@@ -0,0 +1,11 @@
+"""Editor integration tools for Hanzo MCP."""
+
+from hanzo_mcp.tools.editor.neovim_edit import NeovimEditTool
+from hanzo_mcp.tools.editor.neovim_command import NeovimCommandTool
+from hanzo_mcp.tools.editor.neovim_session import NeovimSessionTool
+
+__all__ = [
+    "NeovimEditTool",
+    "NeovimCommandTool",
+    "NeovimSessionTool",
+]