altimate-engine 0.1.0__py3-none-any.whl

altimate_engine/__init__.py

@@ -0,0 +1,3 @@
+"""Altimate Engine — Python sidecar for the Altimate Code CLI."""
+
+__version__ = "0.1.0"

altimate_engine/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for `python -m altimate_engine`."""
+
+from altimate_engine.server import main
+
+main()

altimate_engine/ci/cost_gate.py

@@ -0,0 +1,162 @@
+"""CI cost gate — scan changed SQL files for critical issues.
+
+Reads SQL files, runs lint analysis, and returns
+pass/fail based on whether CRITICAL severity issues are found.
+
+Skips:
+  - Jinja templates ({{ }}, {% %})
+  - Parse errors (likely Jinja or non-standard SQL)
+  - Non-SQL files
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Any
+
+from altimate_engine.sql.guard import guard_lint
+
+
+# Jinja pattern: {{ ... }} or {% ... %} or {# ... #}
+_JINJA_PATTERN = re.compile(r"\{\{.*?\}\}|\{%.*?%\}|\{#.*?#\}", re.DOTALL)
+
+
+def _has_jinja(sql: str) -> bool:
+    """Check if SQL contains Jinja template syntax."""
+    return bool(_JINJA_PATTERN.search(sql))
+
+
+def _split_statements(sql: str) -> list[str]:
+    """Split SQL on semicolons, filtering empty statements."""
+    statements = []
+    for stmt in sql.split(";"):
+        stmt = stmt.strip()
+        if stmt:
+            statements.append(stmt)
+    return statements
+
+
+def scan_files(
+    file_paths: list[str],
+    dialect: str = "snowflake",
+) -> dict[str, Any]:
+    """Scan SQL files for critical issues.
+
+    Args:
+        file_paths: List of SQL file paths to scan.
+        dialect: SQL dialect for analysis (default: snowflake).
+
+    Returns:
+        Dict with pass/fail status, per-file results, and summary.
+    """
+    file_results: list[dict[str, Any]] = []
+    total_issues = 0
+    critical_count = 0
+    files_scanned = 0
+    files_skipped = 0
+
+    for path in file_paths:
+        # Skip non-SQL files
+        if not path.endswith(".sql"):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "not a SQL file",
+                "issues": [],
+            })
+            continue
+
+        # Read file
+        if not os.path.isfile(path):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "file not found",
+                "issues": [],
+            })
+            continue
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+        except Exception as e:
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": f"read error: {e}",
+                "issues": [],
+            })
+            continue
+
+        # Skip Jinja templates
+        if _has_jinja(content):
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "contains Jinja templates",
+                "issues": [],
+            })
+            continue
+
+        # Split and analyze each statement
+        statements = _split_statements(content)
+        if not statements:
+            files_skipped += 1
+            file_results.append({
+                "file": path,
+                "status": "skipped",
+                "reason": "empty file",
+                "issues": [],
+            })
+            continue
+
+        files_scanned += 1
+        file_issues: list[dict[str, Any]] = []
+
+        for stmt in statements:
+            # Run lint analysis
+            lint_result = guard_lint(stmt)
+            if lint_result.get("error"):
+                # Parse error — skip this statement (likely incomplete SQL)
+                continue
+
+            for finding in lint_result.get("findings", lint_result.get("issues", [])):
+                severity = finding.get("severity", "warning")
+                file_issues.append({
+                    "type": finding.get("rule", finding.get("type", "UNKNOWN")),
+                    "severity": severity,
+                    "message": finding.get("message", ""),
+                    "source": "lint",
+                })
+                total_issues += 1
+                if severity in ("error", "critical"):
+                    critical_count += 1
+
+        status = "fail" if any(
+            i["severity"] in ("error", "critical") for i in file_issues
+        ) else "pass"
+
+        file_results.append({
+            "file": path,
+            "status": status,
+            "issues": file_issues,
+        })
+
+    passed = critical_count == 0
+
+    return {
+        "success": True,
+        "passed": passed,
+        "exit_code": 0 if passed else 1,
+        "files_scanned": files_scanned,
+        "files_skipped": files_skipped,
+        "total_issues": total_issues,
+        "critical_count": critical_count,
+        "file_results": file_results,
+        "error": None,
+    }

altimate_engine/connections.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from altimate_engine.connectors.base import Connector
+from altimate_engine.credential_store import resolve_config
+from altimate_engine.ssh_tunnel import start, stop
+
+SSH_FIELDS = {
+    "ssh_host",
+    "ssh_port",
+    "ssh_user",
+    "ssh_auth_type",
+    "ssh_key_path",
+    "ssh_password",
+}
+
+
+class ConnectionRegistry:
+    _connections: dict[str, dict[str, Any]] = {}
+    _loaded: bool = False
+
+    @classmethod
+    def load(cls) -> None:
+        if cls._loaded:
+            return
+
+        global_config = Path.home() / ".altimate-code" / "connections.json"
+        if global_config.exists():
+            with open(global_config) as f:
+                cls._connections.update(json.load(f))
+
+        project_config = Path.cwd() / ".altimate-code" / "connections.json"
+        if project_config.exists():
+            with open(project_config) as f:
+                cls._connections.update(json.load(f))
+
+        for key, value in os.environ.items():
+            if key.startswith("ALTIMATE_CODE_CONN_"):
+                name = key[len("ALTIMATE_CODE_CONN_") :].lower()
+                try:
+                    cls._connections[name] = json.loads(value)
+                except json.JSONDecodeError:
+                    pass
+
+        cls._loaded = True
+
+    @classmethod
+    def get(cls, name: str) -> Connector:
+        cls.load()
+
+        if name not in cls._connections:
+            raise ValueError(f"Connection '{name}' not found in registry")
+
+        config = dict(cls._connections[name])
+        config = resolve_config(name, config)
+
+        ssh_host = config.get("ssh_host")
+        if ssh_host:
+            if config.get("connection_string"):
+                raise ValueError(
+                    "SSH tunneling requires explicit host/port — "
+                    "cannot be used with connection_string"
+                )
+            ssh_config = {
+                k: config.pop(k) for k in list(config.keys()) if k in SSH_FIELDS
+            }
+            local_port = start(
+                name=name,
+                ssh_host=ssh_config.get("ssh_host", ""),
+                remote_host=config.get("host", "localhost"),
+                remote_port=config.get("port", 5432),
+                ssh_port=ssh_config.get("ssh_port", 22),
+                ssh_user=ssh_config.get("ssh_user"),
+                ssh_auth_type=ssh_config.get("ssh_auth_type", "key"),
+                ssh_key_path=ssh_config.get("ssh_key_path"),
+                ssh_password=ssh_config.get("ssh_password"),
+            )
+            config["host"] = "127.0.0.1"
+            config["port"] = local_port
+
+        dialect = config.get("type", "duckdb")
+
+        if dialect == "duckdb":
+            from altimate_engine.connectors.duckdb import DuckDBConnector
+
+            return DuckDBConnector(
+                path=config.get("path", ":memory:"),
+                **{k: v for k, v in config.items() if k not in ("type", "path")},
+            )
+        elif dialect == "postgres":
+            from altimate_engine.connectors.postgres import PostgresConnector
+
+            return PostgresConnector(
+                connection_string=config.get("connection_string", ""),
+                **{
+                    k: v
+                    for k, v in config.items()
+                    if k not in ("type", "connection_string")
+                },
+            )
+        elif dialect == "snowflake":
+            from altimate_engine.connectors.snowflake import SnowflakeConnector
+
+            _snowflake_keys = {
+                "type",
+                "account",
+                "user",
+                "password",
+                "private_key_path",
+                "private_key_passphrase",
+                "warehouse",
+                "database",
+                "schema",
+                "role",
+            }
+            return SnowflakeConnector(
+                account=config.get("account", ""),
+                user=config.get("user", ""),
+                password=config.get("password"),
+                private_key_path=config.get("private_key_path"),
+                private_key_passphrase=config.get("private_key_passphrase"),
+                warehouse=config.get("warehouse"),
+                database=config.get("database"),
+                schema=config.get("schema"),
+                role=config.get("role"),
+                **{k: v for k, v in config.items() if k not in _snowflake_keys},
+            )
+        elif dialect == "bigquery":
+            from altimate_engine.connectors.bigquery import BigQueryConnector
+
+            _bigquery_keys = {"type", "project", "credentials_path", "location"}
+            return BigQueryConnector(
+                project=config.get("project", ""),
+                credentials_path=config.get("credentials_path"),
+                location=config.get("location", "US"),
+                **{k: v for k, v in config.items() if k not in _bigquery_keys},
+            )
+        elif dialect == "databricks":
+            from altimate_engine.connectors.databricks import DatabricksConnector
+
+            _databricks_keys = {
+                "type",
+                "server_hostname",
+                "http_path",
+                "access_token",
+                "catalog",
+                "schema",
+            }
+            return DatabricksConnector(
+                server_hostname=config.get("server_hostname", ""),
+                http_path=config.get("http_path", ""),
+                access_token=config.get("access_token"),
+                catalog=config.get("catalog"),
+                schema=config.get("schema"),
+                **{k: v for k, v in config.items() if k not in _databricks_keys},
+            )
+        elif dialect == "redshift":
+            from altimate_engine.connectors.redshift import RedshiftConnector
+
+            _redshift_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "connection_string",
+                "iam_role",
+                "region",
+                "cluster_identifier",
+            }
+            return RedshiftConnector(
+                host=config.get("host", ""),
+                port=config.get("port", 5439),
+                database=config.get("database", "dev"),
+                user=config.get("user"),
+                password=config.get("password"),
+                connection_string=config.get("connection_string"),
+                iam_role=config.get("iam_role"),
+                region=config.get("region"),
+                cluster_identifier=config.get("cluster_identifier"),
+                **{k: v for k, v in config.items() if k not in _redshift_keys},
+            )
+        elif dialect == "mysql":
+            from altimate_engine.connectors.mysql import MySQLConnector
+
+            _mysql_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "ssl_ca",
+                "ssl_cert",
+                "ssl_key",
+            }
+            return MySQLConnector(
+                host=config.get("host", "localhost"),
+                port=config.get("port", 3306),
+                database=config.get("database"),
+                user=config.get("user"),
+                password=config.get("password"),
+                ssl_ca=config.get("ssl_ca"),
+                ssl_cert=config.get("ssl_cert"),
+                ssl_key=config.get("ssl_key"),
+                **{k: v for k, v in config.items() if k not in _mysql_keys},
+            )
+        elif dialect == "sqlserver":
+            from altimate_engine.connectors.sqlserver import SQLServerConnector
+
+            _sqlserver_keys = {
+                "type",
+                "host",
+                "port",
+                "database",
+                "user",
+                "password",
+                "driver",
+                "azure_auth",
+                "trust_server_certificate",
+            }
+            return SQLServerConnector(
+                host=config.get("host", "localhost"),
+                port=config.get("port", 1433),
+                database=config.get("database"),
+                user=config.get("user"),
+                password=config.get("password"),
+                driver=config.get("driver", "ODBC Driver 18 for SQL Server"),
+                azure_auth=config.get("azure_auth", False),
+                trust_server_certificate=config.get("trust_server_certificate", False),
+                **{k: v for k, v in config.items() if k not in _sqlserver_keys},
+            )
+        else:
+            raise ValueError(f"Unsupported connector type: {dialect}")
+
+    @classmethod
+    def list(cls) -> list[dict[str, Any]]:
+        cls.load()
+        return [
+            {"name": name, "type": config.get("type", "unknown")}
+            for name, config in cls._connections.items()
+        ]
+
+    @classmethod
+    def test(cls, name: str) -> dict[str, Any]:
+        try:
+            connector = cls.get(name)
+            connector.connect()
+            connector.execute("SELECT 1")
+            connector.close()
+            return {"connected": True, "error": None}
+        except Exception as e:
+            return {"connected": False, "error": str(e)}
+        finally:
+            stop(name)
+
+    @classmethod
+    def add(cls, name: str, config: dict[str, Any]) -> dict[str, Any]:
+        from altimate_engine.credential_store import save_connection
+
+        result = save_connection(name, config)
+        cls._loaded = False
+        return result
+
+    @classmethod
+    def remove(cls, name: str) -> bool:
+        from altimate_engine.credential_store import remove_connection
+
+        result = remove_connection(name)
+        cls._loaded = False
+        return result
+
+    @classmethod
+    def reload(cls) -> None:
+        cls._loaded = False
+        cls._connections.clear()

altimate_engine/connectors/__init__.py

@@ -0,0 +1,21 @@
+from altimate_engine.connectors.base import Connector
+from altimate_engine.connectors.duckdb import DuckDBConnector
+from altimate_engine.connectors.postgres import PostgresConnector
+from altimate_engine.connectors.snowflake import SnowflakeConnector
+from altimate_engine.connectors.bigquery import BigQueryConnector
+from altimate_engine.connectors.databricks import DatabricksConnector
+from altimate_engine.connectors.redshift import RedshiftConnector
+from altimate_engine.connectors.mysql import MySQLConnector
+from altimate_engine.connectors.sqlserver import SQLServerConnector
+
+__all__ = [
+    "Connector",
+    "DuckDBConnector",
+    "PostgresConnector",
+    "SnowflakeConnector",
+    "BigQueryConnector",
+    "DatabricksConnector",
+    "RedshiftConnector",
+    "MySQLConnector",
+    "SQLServerConnector",
+]

altimate_engine/connectors/base.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Connector(ABC):
+    @abstractmethod
+    def connect(self) -> Any:
+        pass
+
+    @abstractmethod
+    def execute(self, sql: str, params: tuple | list | None = None, limit: int = 1000) -> list[dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    def list_schemas(self) -> list[str]:
+        pass
+
+    @abstractmethod
+    def list_tables(self, schema: str) -> list[dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    def describe_table(self, schema: str, table: str) -> list[dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        pass
+
+    def set_statement_timeout(self, timeout_ms: int) -> None:
+        """Set a per-session statement timeout. Override in subclasses that support it.
+
+        Args:
+            timeout_ms: Maximum query execution time in milliseconds.
+        """
+        pass
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False