sqlsaber 0.1.0__py3-none-any.whl

sqlsaber/memory/manager.py

@@ -0,0 +1,77 @@
+"""Memory manager for handling database-specific context and memories."""
+
+from typing import List, Optional
+
+from sqlsaber.memory.storage import Memory, MemoryStorage
+
+
+class MemoryManager:
+    """Manages database-specific memories and context."""
+
+    def __init__(self):
+        self.storage = MemoryStorage()
+
+    def add_memory(self, database_name: str, content: str) -> Memory:
+        """Add a new memory for the specified database."""
+        return self.storage.add_memory(database_name, content)
+
+    def get_memories(self, database_name: str) -> List[Memory]:
+        """Get all memories for the specified database."""
+        return self.storage.get_memories(database_name)
+
+    def remove_memory(self, database_name: str, memory_id: str) -> bool:
+        """Remove a specific memory by ID."""
+        return self.storage.remove_memory(database_name, memory_id)
+
+    def clear_memories(self, database_name: str) -> int:
+        """Clear all memories for the specified database."""
+        return self.storage.clear_memories(database_name)
+
+    def get_memory_by_id(self, database_name: str, memory_id: str) -> Optional[Memory]:
+        """Get a specific memory by ID."""
+        return self.storage.get_memory_by_id(database_name, memory_id)
+
+    def has_memories(self, database_name: str) -> bool:
+        """Check if database has any memories."""
+        return self.storage.has_memories(database_name)
+
+    def format_memories_for_prompt(self, database_name: str) -> str:
+        """Format memories for inclusion in system prompt."""
+        memories = self.get_memories(database_name)
+
+        if not memories:
+            return ""
+
+        formatted_memories = []
+        for memory in memories:
+            formatted_memories.append(f"- {memory.content}")
+
+        return f"""
+Previous context from user:
+{chr(10).join(formatted_memories)}
+
+Use this context to better understand the user's needs and provide more relevant responses.
+"""
+
+    def get_memories_summary(self, database_name: str) -> dict:
+        """Get a summary of memories for a database."""
+        memories = self.get_memories(database_name)
+
+        return {
+            "database": database_name,
+            "total_memories": len(memories),
+            "memories": [
+                {
+                    "id": memory.id,
+                    "content": memory.content[:100] + "..."
+                    if len(memory.content) > 100
+                    else memory.content,
+                    "timestamp": memory.formatted_timestamp(),
+                }
+                for memory in memories
+            ],
+        }
+
+    def list_databases_with_memories(self) -> List[str]:
+        """List all databases that have memories."""
+        return self.storage.list_databases_with_memories()

sqlsaber/memory/storage.py

@@ -0,0 +1,176 @@
+"""Memory storage implementation for database-specific memories."""
+
+import json
+import os
+import platform
+import stat
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import platformdirs
+
+
+@dataclass
+class Memory:
+    """Represents a single memory entry."""
+
+    id: str
+    content: str
+    timestamp: float
+
+    def to_dict(self) -> Dict:
+        """Convert memory to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "content": self.content,
+            "timestamp": self.timestamp,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "Memory":
+        """Create Memory from dictionary."""
+        return cls(
+            id=data["id"],
+            content=data["content"],
+            timestamp=data["timestamp"],
+        )
+
+    def formatted_timestamp(self) -> str:
+        """Get human-readable timestamp."""
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.timestamp))
+
+
+class MemoryStorage:
+    """Handles storage and retrieval of database-specific memories."""
+
+    def __init__(self):
+        self.memory_dir = Path(platformdirs.user_config_dir("sqlsaber")) / "memories"
+        self._ensure_memory_dir()
+
+    def _ensure_memory_dir(self) -> None:
+        """Ensure memory directory exists with proper permissions."""
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+        self._set_secure_permissions(self.memory_dir, is_directory=True)
+
+    def _set_secure_permissions(self, path: Path, is_directory: bool = False) -> None:
+        """Set secure permissions cross-platform."""
+        try:
+            if platform.system() == "Windows":
+                # On Windows, rely on NTFS permissions and avoid chmod
+                return
+            else:
+                # Unix-like systems (Linux, macOS)
+                if is_directory:
+                    os.chmod(
+                        path, stat.S_IRWXU
+                    )  # 0o700 - owner read/write/execute only
+                else:
+                    os.chmod(
+                        path, stat.S_IRUSR | stat.S_IWUSR
+                    )  # 0o600 - owner read/write only
+        except (OSError, PermissionError):
+            # If we can't set permissions, continue anyway
+            pass
+
+    def _get_memory_file(self, database_name: str) -> Path:
+        """Get the memory file path for a specific database."""
+        return self.memory_dir / f"{database_name}.json"
+
+    def _load_memories(self, database_name: str) -> List[Memory]:
+        """Load memories for a specific database."""
+        memory_file = self._get_memory_file(database_name)
+
+        if not memory_file.exists():
+            return []
+
+        try:
+            with open(memory_file, "r") as f:
+                data = json.load(f)
+                return [
+                    Memory.from_dict(memory_data)
+                    for memory_data in data.get("memories", [])
+                ]
+        except (json.JSONDecodeError, IOError, KeyError):
+            return []
+
+    def _save_memories(self, database_name: str, memories: List[Memory]) -> None:
+        """Save memories for a specific database."""
+        memory_file = self._get_memory_file(database_name)
+
+        data = {
+            "database": database_name,
+            "memories": [memory.to_dict() for memory in memories],
+        }
+
+        with open(memory_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+        # Set secure permissions
+        self._set_secure_permissions(memory_file, is_directory=False)
+
+    def add_memory(self, database_name: str, content: str) -> Memory:
+        """Add a new memory for the specified database."""
+        memory = Memory(
+            id=str(uuid.uuid4()),
+            content=content.strip(),
+            timestamp=time.time(),
+        )
+
+        memories = self._load_memories(database_name)
+        memories.append(memory)
+        self._save_memories(database_name, memories)
+
+        return memory
+
+    def get_memories(self, database_name: str) -> List[Memory]:
+        """Get all memories for the specified database."""
+        return self._load_memories(database_name)
+
+    def remove_memory(self, database_name: str, memory_id: str) -> bool:
+        """Remove a specific memory by ID."""
+        memories = self._load_memories(database_name)
+        original_count = len(memories)
+
+        memories = [m for m in memories if m.id != memory_id]
+
+        if len(memories) < original_count:
+            self._save_memories(database_name, memories)
+            return True
+
+        return False
+
+    def clear_memories(self, database_name: str) -> int:
+        """Clear all memories for the specified database."""
+        memories = self._load_memories(database_name)
+        count = len(memories)
+
+        if count > 0:
+            self._save_memories(database_name, [])
+
+        return count
+
+    def get_memory_by_id(self, database_name: str, memory_id: str) -> Optional[Memory]:
+        """Get a specific memory by ID."""
+        memories = self._load_memories(database_name)
+        return next((m for m in memories if m.id == memory_id), None)
+
+    def has_memories(self, database_name: str) -> bool:
+        """Check if database has any memories."""
+        return len(self._load_memories(database_name)) > 0
+
+    def list_databases_with_memories(self) -> List[str]:
+        """List all databases that have memories."""
+        databases = []
+
+        if not self.memory_dir.exists():
+            return databases
+
+        for memory_file in self.memory_dir.glob("*.json"):
+            database_name = memory_file.stem
+            if self.has_memories(database_name):
+                databases.append(database_name)
+
+        return databases

sqlsaber/models/__init__.py

@@ -0,0 +1,13 @@
+"""Models module for SQLSaber."""
+
+from .events import StreamEvent, SQLResponse
+from .types import ColumnInfo, ForeignKeyInfo, SchemaInfo, ToolDefinition
+
+__all__ = [
+    "StreamEvent",
+    "SQLResponse",
+    "ColumnInfo",
+    "ForeignKeyInfo",
+    "SchemaInfo",
+    "ToolDefinition",
+]

sqlsaber/models/events.py

@@ -0,0 +1,28 @@
+"""Event models for streaming and responses."""
+
+from typing import Any, Dict, List, Optional
+
+
+class StreamEvent:
+    """Event emitted during streaming processing."""
+
+    def __init__(self, event_type: str, data: Any = None):
+        # 'tool_use', 'text', 'query_result', 'error', 'processing'
+        self.type = event_type
+        self.data = data
+
+
+class SQLResponse:
+    """Response from the SQL agent."""
+
+    def __init__(
+        self,
+        query: Optional[str] = None,
+        explanation: str = "",
+        results: Optional[List[Dict[str, Any]]] = None,
+        error: Optional[str] = None,
+    ):
+        self.query = query
+        self.explanation = explanation
+        self.results = results
+        self.error = error

sqlsaber/models/types.py

@@ -0,0 +1,40 @@
+"""Type definitions for SQLSaber."""
+
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ColumnInfo(TypedDict):
+    """Type definition for column information."""
+
+    data_type: str
+    nullable: bool
+    default: Optional[str]
+    max_length: Optional[int]
+    precision: Optional[int]
+    scale: Optional[int]
+
+
+class ForeignKeyInfo(TypedDict):
+    """Type definition for foreign key information."""
+
+    column: str
+    references: Dict[str, str]  # {"table": "schema.table", "column": "column_name"}
+
+
+class SchemaInfo(TypedDict):
+    """Type definition for schema information."""
+
+    schema: str
+    name: str
+    type: str
+    columns: Dict[str, ColumnInfo]
+    primary_keys: List[str]
+    foreign_keys: List[ForeignKeyInfo]
+
+
+class ToolDefinition(TypedDict):
+    """Type definition for tool definition."""
+
+    name: str
+    description: str
+    input_schema: Dict[str, Any]

sqlsaber-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: sqlsaber
+Version: 0.1.0
+Summary: SQLSaber - Agentic SQL assistant like Claude Code
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: aiomysql>=0.2.0
+Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: anthropic>=0.54.0
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.16.0
+Description-Content-Type: text/markdown
+
+# SQLSaber
+
+> Use the agent Luke!
+
+SQLSaber is an agentic SQL assistant. Think Claude Code but for SQL.
+
+Ask your questions in natural language and it will gather the right context and answer your query by writing SQL and analyzing the results.
+
+## Features
+
+- Natural language to SQL conversion
+- 🔍 Automatic database schema introspection
+- 🛡️ Safe query execution (read-only by default)
+- 🧠 Memory management
+- 💬 Interactive REPL mode
+- 🎨 Beautiful formatted output with syntax highlighting
+- 🗄️ Support for PostgreSQL, SQLite, and MySQL
+
+## Installation
+
+```bash
+uv tool install sqlsaber
+```
+
+or
+
+```bash
+pipx install sqlsaber
+```
+
+## Configuration
+
+### Database Connection
+
+Set your database connection URL:
+
+```bash
+saber db add DB_NAME
+```
+
+This will ask you some questions about your database connection
+
+### AI Model Configuration
+
+SQLSaber uses Sonnet-4 by default. You can change it using:
+
+```bash
+saber models set
+
+# for more model settings run:
+saber models --help
+```
+
+### Memory Management
+
+You can add specific context about your database to the model using the memory feature. This is similar to how you add memory/context in Claude Code.
+
+```bash
+saber memory add 'always convert dates to string for easier formating'
+```
+
+View all memories
+
+```bash
+saber memory list
+```
+
+> You can also add memories in an interactive query session by starting with the `#` sign
+
+## Usage
+
+### Interactive Mode
+
+Start an interactive session:
+
+```bash
+saber query
+```
+
+> You can also add memories in an interactive session by starting your message with the `#` sign
+
+### Single Query
+
+Execute a single natural language query:
+
+```bash
+saber query "show me all users created this month"
+```
+
+### Database Selection
+
+Use a specific database connection:
+
+```bash
+# Use named database from config
+saber query -d mydb "count all orders"
+```
+
+## Examples
+
+```bash
+# Show database schema
+saber query "what tables are in my database?"
+
+# Count records
+saber query "how many active users do we have?"
+
+# Complex queries with joins
+saber query "show me orders with customer details for this week"
+
+# Aggregations
+saber query "what's the total revenue by product category?"
+
+# Date filtering
+saber query "list users who haven't logged in for 30 days"
+
+# Data exploration
+saber query "show me the distribution of customer ages"
+
+# Business analytics
+saber query "which products had the highest sales growth last quarter?"
+```
+
+## How It Works
+
+SQLSaber uses an intelligent three-step process optimized for minimal token usage:
+
+### 🔍 Discovery Phase
+
+1. **List Tables Tool**: Quickly discovers available tables with row counts
+2. **Pattern Matching**: Identifies relevant tables based on your query using SQL LIKE patterns
+
+### 📋 Schema Analysis
+
+3. **Smart Introspection**: Analyzes only the specific table structures needed for your query
+4. **Selective Loading**: Fetches schema information only for relevant tables
+
+### ⚡ Execution Phase
+
+5. **SQL Generation**: Creates optimized SQL queries based on natural language input
+6. **Safe Execution**: Runs queries with built-in protections against destructive operations
+7. **Result Formatting**: Presents results with syntax highlighting and explanations
+
+## Contributing
+
+Contributions are welcome! Please feel free to open an issue to discuss your ideas or report bugs.
+
+## License
+
+This project is licensed under Apache-2.0 License - see the LICENSE file for details.

sqlsaber-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+sqlsaber/__init__.py,sha256=QCFi8xTVMohelfi7zOV1-6oLCcGoiXoOcKQY-HNBCk8,66
+sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
+sqlsaber/agents/__init__.py,sha256=LWeSeEUE4BhkyAYFF3TE-fx8TtLud3oyEtyB8ojFJgo,167
+sqlsaber/agents/anthropic.py,sha256=CPNshN68QxxdIvWS5YjEuiXd_8V8mmMTL9aC2Mqkvts,17863
+sqlsaber/agents/base.py,sha256=UUSGhoJImATXrYS7yrLR2qjg1iFW4udOUdRaV3Ryk5s,2086
+sqlsaber/agents/streaming.py,sha256=0bNzd_JhLlgQB40pf9FZFMvmU9Q7W6D9BmglA1rIGqw,850
+sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
+sqlsaber/cli/commands.py,sha256=Adrt_0LRgykb2FZ4F0TQpuBM8Z0qgfbggn0FexcVALI,4094
+sqlsaber/cli/database.py,sha256=W-tJqmihKjZhoe5AGpQKe0txzLIgRVGikZHM_ELAbnQ,9138
+sqlsaber/cli/display.py,sha256=5J4AgJADmMwKi9Aq5u6_MKRO1TA6unS4F4RUfml_sfU,7651
+sqlsaber/cli/interactive.py,sha256=y92rdoM49SOSwEctm9ZcrEN220fhJ_DMHPSd_7KsORg,3701
+sqlsaber/cli/memory.py,sha256=LW4ZF2V6Gw6hviUFGZ4ym9ostFCwucgBTIMZ3EANO-I,7671
+sqlsaber/cli/models.py,sha256=3IcXeeU15IQvemSv-V-RQzVytJ3wuQ4YmWk89nTDcSE,7813
+sqlsaber/cli/streaming.py,sha256=5QGAYTAvg9mzQLxDEVtdDH-TIbGfYYzMOLoOYPrHPu0,3788
+sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
+sqlsaber/config/api_keys.py,sha256=kLdoExF_My9ojmdhO5Ca7-ZeowsO0v1GVa_QT5jjUPo,3658
+sqlsaber/config/database.py,sha256=FX4zwmOkW-lvIH--c8xRyoyyjYLjn3OQTkSruEw-aQY,8790
+sqlsaber/config/settings.py,sha256=zjQ7nS3ybcCb88Ea0tmwJox5-q0ettChZw89ZqRVpX8,3975
+sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
+sqlsaber/database/connection.py,sha256=Z1iIRBIoPQcCfBliROLeebEQeI7ggu-hh_G1l-tzhIM,6672
+sqlsaber/database/schema.py,sha256=gURfCFVE--UWIqD_0StqS2NMB9VIPpqczBEoS2GnKR4,27025
+sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
+sqlsaber/memory/manager.py,sha256=ML2NEO5Z4Aw36sEI9eOvWVnjl-qT2VOTojViJAj7Seo,2777
+sqlsaber/memory/storage.py,sha256=DvZBsSPaAfk_DqrNEn86uMD-TQsWUI6rQLfNw6PSCB8,5788
+sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
+sqlsaber/models/events.py,sha256=55m41tDwMsFxnKKA5_VLJz8iV-V4Sq3LDfta4VoutJI,737
+sqlsaber/models/types.py,sha256=3U_30n91EB3IglBTHipwiW4MqmmaA2qfshfraMZyPps,896
+sqlsaber-0.1.0.dist-info/METADATA,sha256=37Xik234wv415wWsvIWr4XFjzHiQV39EnDAYyZsMgXA,3953
+sqlsaber-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.1.0.dist-info/entry_points.txt,sha256=POwcsEskUp7xQQWabrAi6Eawz4qc5eBlB3KzAiBq-Y0,124
+sqlsaber-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.1.0.dist-info/RECORD,,

sqlsaber-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlsaber-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+saber = sqlsaber.cli.commands:main
+sql = sqlsaber.cli.commands:main
+sqlsaber = sqlsaber.cli.commands:main