sqlsaber 0.11.0__tar.gz → 0.13.0__tar.gz

sqlsaber-0.13.0/.github/workflows/claude-code-review.yml

@@ -0,0 +1,78 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+    
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@beta
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4)
+          # model: "claude-opus-4-20250514"
+          
+          # Direct prompt for automated review (no @claude mention needed)
+          direct_prompt: |
+            Please review this pull request and provide feedback on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Performance considerations
+            - Security concerns
+            - Test coverage
+            
+            Be constructive and helpful in your feedback.
+
+          # Optional: Use sticky comments to make Claude reuse the same comment on subsequent pushes to the same PR
+          # use_sticky_comment: true
+          
+          # Optional: Customize review based on file types
+          # direct_prompt: |
+          #   Review this PR focusing on:
+          #   - For TypeScript files: Type safety and proper interface usage
+          #   - For API endpoints: Security, input validation, and error handling
+          #   - For React components: Performance, accessibility, and best practices
+          #   - For tests: Coverage, edge cases, and test quality
+          
+          # Optional: Different prompts for different authors
+          # direct_prompt: |
+          #   ${{ github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' && 
+          #   'Welcome! Please review this PR from a first-time contributor. Be encouraging and provide detailed explanations for any suggestions.' ||
+          #   'Please provide a thorough code review focusing on our coding standards and best practices.' }}
+          
+          # Optional: Add specific tools for running tests or linting
+          # allowed_tools: "Bash(npm run test),Bash(npm run lint),Bash(npm run typecheck)"
+          
+          # Optional: Skip review for certain conditions
+          # if: |
+          #   !contains(github.event.pull_request.title, '[skip-review]') &&
+          #   !contains(github.event.pull_request.title, '[WIP]')
+

sqlsaber-0.13.0/.github/workflows/claude.yml

@@ -0,0 +1,64 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+          
+          # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4)
+          # model: "claude-opus-4-20250514"
+          
+          # Optional: Customize the trigger phrase (default: @claude)
+          # trigger_phrase: "/claude"
+          
+          # Optional: Trigger when specific user is assigned to an issue
+          # assignee_trigger: "claude-bot"
+          
+          # Optional: Allow Claude to run specific commands
+          # allowed_tools: "Bash(npm install),Bash(npm run build),Bash(npm run test:*),Bash(npm run lint:*)"
+          
+          # Optional: Add custom instructions for Claude to customize its behavior for your project
+          # custom_instructions: |
+          #   Follow our coding standards
+          #   Ensure all new code has tests
+          #   Use TypeScript for new files
+          
+          # Optional: Custom environment variables for Claude
+          # claude_env: |
+          #   NODE_ENV: test
+

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to SQLSaber will be documented in this file.
 
 ## [Unreleased]
 
+## [0.13.0] - 2025-07-26
+
+### Added
+
+- Database resolver abstraction for unified connection handling
+  - Extended `-d` flag to accept PostgreSQL and MySQL connection strings (e.g., `postgresql://user:pass@host:5432/db`)
+  - Support for direct connection strings alongside existing file path and configured database support
+  - Examples: `saber -d "postgresql://user:pass@host:5432/db" "show users"`
+
+## [0.12.0] - 2025-07-23
+
+### Added
+
+- Add support for ad-hoc SQLite files via `--database`/`-d` flag
+
 ## [0.11.0] - 2025-07-09
 
 ### Changed

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.11.0
+Version: 0.13.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -21,6 +21,15 @@ Description-Content-Type: text/markdown
 
 # SQLSaber
 
+```
+███████  ██████  ██      ███████  █████  ██████  ███████ ██████
+██      ██    ██ ██      ██      ██   ██ ██   ██ ██      ██   ██
+███████ ██    ██ ██      ███████ ███████ ██████  █████   ██████
+     ██ ██ ▄▄ ██ ██           ██ ██   ██ ██   ██ ██      ██   ██
+███████  ██████  ███████ ███████ ██   ██ ██████  ███████ ██   ██
+            ▀▀
+```
+
 > Use the agent Luke!
 
 SQLSaber is an agentic SQL assistant. Think Claude Code but for SQL.

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/README.md

@@ -1,5 +1,14 @@
 # SQLSaber
 
+```
+███████  ██████  ██      ███████  █████  ██████  ███████ ██████
+██      ██    ██ ██      ██      ██   ██ ██   ██ ██      ██   ██
+███████ ██    ██ ██      ███████ ███████ ██████  █████   ██████
+     ██ ██ ▄▄ ██ ██           ██ ██   ██ ██   ██ ██      ██   ██
+███████  ██████  ███████ ███████ ██   ██ ██████  ███████ ██   ██
+            ▀▀
+```
+
 > Use the agent Luke!
 
 SQLSaber is an agentic SQL assistant. Think Claude Code but for SQL.

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlsaber"
-version = "0.11.0"
+version = "0.13.0"
 description = "SQLSaber - Agentic SQL assistant like Claude Code"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/src/sqlsaber/cli/commands.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import sys
-from pathlib import Path
 from typing import Annotated
 
 import cyclopts
@@ -17,6 +16,7 @@ from sqlsaber.cli.models import create_models_app
 from sqlsaber.cli.streaming import StreamingQueryHandler
 from sqlsaber.config.database import DatabaseConfigManager
 from sqlsaber.database.connection import DatabaseConnection
+from sqlsaber.database.resolver import DatabaseResolutionError, resolve_database
 
 
 class CLIError(Exception):
@@ -43,7 +43,7 @@ def meta_handler(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -54,6 +54,10 @@ def meta_handler(
         saber                                  # Start interactive mode
         saber "show me all users"              # Run a single query with default database
         saber -d mydb "show me users"          # Run a query with specific database
+        saber -d data.csv "show me users"      # Run a query with ad-hoc CSV file
+        saber -d data.db "show me users"       # Run a query with ad-hoc SQLite file
+        saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
+        saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
         echo "show me all users" | saber       # Read query from stdin
         cat query.txt | saber                  # Read query from file via stdin
     """
@@ -73,7 +77,7 @@ def query(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -88,6 +92,10 @@ def query(
     Examples:
         saber                             # Start interactive mode
         saber "show me all users"         # Run a single query
+        saber -d data.csv "show users"    # Run a query with ad-hoc CSV file
+        saber -d data.db "show users"     # Run a query with ad-hoc SQLite file
+        saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
+        saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
         echo "show me all users" | saber  # Read query from stdin
     """
 
@@ -101,32 +109,13 @@ def query(
                 # If stdin was empty, fall back to interactive mode
                 actual_query = None
 
-        # Get database configuration or handle direct CSV file
-        if database:
-            # Check if this is a direct CSV file path
-            if database.endswith(".csv"):
-                csv_path = Path(database).expanduser().resolve()
-                if not csv_path.exists():
-                    raise CLIError(f"CSV file '{database}' not found.")
-                connection_string = f"csv:///{csv_path}"
-                db_name = csv_path.stem
-            else:
-                # Look up configured database connection
-                db_config = config_manager.get_database(database)
-                if not db_config:
-                    raise CLIError(
-                        f"Database connection '{database}' not found. Use 'sqlsaber db list' to see available connections."
-                    )
-                connection_string = db_config.to_connection_string()
-                db_name = db_config.name
-        else:
-            db_config = config_manager.get_default_database()
-            if not db_config:
-                raise CLIError(
-                    "No database connections configured. Use 'sqlsaber db add <name>' to add a database connection."
-                )
-            connection_string = db_config.to_connection_string()
-            db_name = db_config.name
+        # Resolve database from CLI input
+        try:
+            resolved = resolve_database(database, config_manager)
+            connection_string = resolved.connection_string
+            db_name = resolved.name
+        except DatabaseResolutionError as e:
+            raise CLIError(str(e))
 
         # Create database connection
         try:

sqlsaber-0.13.0/src/sqlsaber/database/resolver.py

@@ -0,0 +1,96 @@
+"""Database connection resolution from CLI input."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+from sqlsaber.config.database import DatabaseConfig, DatabaseConfigManager
+
+
+class DatabaseResolutionError(Exception):
+    """Exception raised when database resolution fails."""
+
+    pass
+
+
+@dataclass
+class ResolvedDatabase:
+    """Result of database resolution containing canonical connection info."""
+
+    name: str  # Human-readable name for display/logging
+    connection_string: str  # Canonical connection string for DatabaseConnection factory
+
+
+SUPPORTED_SCHEMES = {"postgresql", "mysql", "sqlite", "csv"}
+
+
+def _is_connection_string(s: str) -> bool:
+    """Check if string looks like a connection string with supported scheme."""
+    try:
+        scheme = urlparse(s).scheme
+        return scheme in SUPPORTED_SCHEMES
+    except Exception:
+        return False
+
+
+def resolve_database(
+    spec: str | None, config_mgr: DatabaseConfigManager
+) -> ResolvedDatabase:
+    """Turn user CLI input into resolved database connection info.
+
+    Args:
+        spec: User input - None (default), configured name, connection string, or file path
+        config_mgr: Database configuration manager for looking up configured connections
+
+    Returns:
+        ResolvedDatabase with name and canonical connection string
+
+    Raises:
+        DatabaseResolutionError: If the spec cannot be resolved to a valid database connection
+    """
+    if spec is None:
+        db_cfg = config_mgr.get_default_database()
+        if not db_cfg:
+            raise DatabaseResolutionError(
+                "No database connections configured. "
+                "Use 'sqlsaber db add <name>' to add one."
+            )
+        return ResolvedDatabase(
+            name=db_cfg.name,
+            connection_string=db_cfg.to_connection_string(),
+        )
+
+    # 1. Connection string?
+    if _is_connection_string(spec):
+        scheme = urlparse(spec).scheme
+        if scheme in {"postgresql", "mysql"}:
+            db_name = urlparse(spec).path.lstrip("/") or "database"
+        elif scheme in {"sqlite", "csv"}:
+            db_name = Path(urlparse(spec).path).stem
+        else:  # should not happen because of SUPPORTED_SCHEMES
+            db_name = "database"
+        return ResolvedDatabase(name=db_name, connection_string=spec)
+
+    # 2. Raw file path?
+    path = Path(spec).expanduser().resolve()
+    if path.suffix.lower() == ".csv":
+        if not path.exists():
+            raise DatabaseResolutionError(f"CSV file '{spec}' not found.")
+        return ResolvedDatabase(name=path.stem, connection_string=f"csv:///{path}")
+    if path.suffix.lower() in {".db", ".sqlite", ".sqlite3"}:
+        if not path.exists():
+            raise DatabaseResolutionError(f"SQLite file '{spec}' not found.")
+        return ResolvedDatabase(name=path.stem, connection_string=f"sqlite:///{path}")
+
+    # 3. Must be a configured name
+    db_cfg: DatabaseConfig | None = config_mgr.get_database(spec)
+    if not db_cfg:
+        raise DatabaseResolutionError(
+            f"Database connection '{spec}' not found. "
+            "Use 'sqlsaber db list' to see available connections."
+        )
+    return ResolvedDatabase(
+        name=db_cfg.name, connection_string=db_cfg.to_connection_string()
+    )

sqlsaber-0.13.0/tests/test_database_resolver.py

@@ -0,0 +1,126 @@
+"""Tests for database resolver functionality."""
+
+import pytest
+from unittest.mock import Mock, patch
+from sqlsaber.database.resolver import resolve_database, DatabaseResolutionError
+from sqlsaber.config.database import DatabaseConfig
+
+
+class TestDatabaseResolver:
+    """Test cases for database resolution logic."""
+
+    def test_resolve_connection_strings(self):
+        """Test that connection strings are handled correctly."""
+        config_mgr = Mock()
+
+        # PostgreSQL connection string
+        result = resolve_database("postgresql://user:pass@host:5432/testdb", config_mgr)
+        assert result.name == "testdb"
+        assert result.connection_string == "postgresql://user:pass@host:5432/testdb"
+
+        # MySQL connection string
+        result = resolve_database("mysql://user:pass@host:3306/mydb", config_mgr)
+        assert result.name == "mydb"
+        assert result.connection_string == "mysql://user:pass@host:3306/mydb"
+
+        # SQLite connection string
+        result = resolve_database("sqlite:///test.db", config_mgr)
+        assert result.name == "test"
+        assert result.connection_string == "sqlite:///test.db"
+
+        # CSV connection string
+        result = resolve_database("csv:///data.csv", config_mgr)
+        assert result.name == "data"
+        assert result.connection_string == "csv:///data.csv"
+
+    @patch("pathlib.Path.exists")
+    def test_resolve_file_paths(self, mock_exists):
+        """Test that file paths are resolved correctly."""
+        mock_exists.return_value = True
+        config_mgr = Mock()
+
+        # CSV file
+        result = resolve_database("data.csv", config_mgr)
+        assert result.name == "data"
+        assert result.connection_string.startswith("csv:///")
+        assert result.connection_string.endswith("data.csv")
+
+        # SQLite file
+        result = resolve_database("test.db", config_mgr)
+        assert result.name == "test"
+        assert result.connection_string.startswith("sqlite:///")
+        assert result.connection_string.endswith("test.db")
+
+    @patch("pathlib.Path.exists")
+    def test_file_not_found_error(self, mock_exists):
+        """Test that missing files raise appropriate errors."""
+        mock_exists.return_value = False
+        config_mgr = Mock()
+
+        with pytest.raises(
+            DatabaseResolutionError, match="CSV file 'missing.csv' not found"
+        ):
+            resolve_database("missing.csv", config_mgr)
+
+        with pytest.raises(
+            DatabaseResolutionError, match="SQLite file 'missing.db' not found"
+        ):
+            resolve_database("missing.db", config_mgr)
+
+    def test_resolve_configured_database(self):
+        """Test that configured database names are resolved."""
+        config_mgr = Mock()
+        db_config = Mock(spec=DatabaseConfig)
+        db_config.name = "mydb"
+        db_config.to_connection_string.return_value = "postgresql://localhost:5432/mydb"
+        config_mgr.get_database.return_value = db_config
+
+        result = resolve_database("mydb", config_mgr)
+        assert result.name == "mydb"
+        assert result.connection_string == "postgresql://localhost:5432/mydb"
+
+    def test_configured_database_not_found(self):
+        """Test error when configured database doesn't exist."""
+        config_mgr = Mock()
+        config_mgr.get_database.return_value = None
+
+        with pytest.raises(
+            DatabaseResolutionError, match="Database connection 'unknown' not found"
+        ):
+            resolve_database("unknown", config_mgr)
+
+    def test_resolve_default_database(self):
+        """Test that None resolves to default database."""
+        config_mgr = Mock()
+        db_config = Mock(spec=DatabaseConfig)
+        db_config.name = "default"
+        db_config.to_connection_string.return_value = (
+            "postgresql://localhost:5432/default"
+        )
+        config_mgr.get_default_database.return_value = db_config
+
+        result = resolve_database(None, config_mgr)
+        assert result.name == "default"
+        assert result.connection_string == "postgresql://localhost:5432/default"
+
+    def test_no_default_database_error(self):
+        """Test error when no default database is configured."""
+        config_mgr = Mock()
+        config_mgr.get_default_database.return_value = None
+
+        with pytest.raises(
+            DatabaseResolutionError, match="No database connections configured"
+        ):
+            resolve_database(None, config_mgr)
+
+    def test_connection_string_edge_cases(self):
+        """Test edge cases in connection string parsing."""
+        config_mgr = Mock()
+
+        # PostgreSQL without database name
+        result = resolve_database("postgresql://user:pass@host:5432/", config_mgr)
+        assert result.name == "database"  # fallback name
+
+        # PostgreSQL with no path at all
+        result = resolve_database("postgresql://user:pass@host:5432", config_mgr)
+        assert result.name == "database"  # fallback name

{sqlsaber-0.11.0 → sqlsaber-0.13.0}/uv.lock

@@ -918,7 +918,7 @@ wheels = [
 
 [[package]]
 name = "sqlsaber"
-version = "0.11.0"
+version = "0.13.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiomysql" },