nl2sql-engine 0.1.0__tar.gz → 0.1.1__tar.gz

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nl2sql-engine
-Version: 0.1.0
+Version: 0.1.1
 Summary: Natural-language-to-SQL engine, CLI and database adapters
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nl2sql-engine"
-version = "0.1.0" # x-release-please-version
+version = "0.1.1" # x-release-please-version
 description = "Natural-language-to-SQL engine, CLI and database adapters"
 readme = "README.md"
 requires-python = ">=3.9"

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/api/datasource_api.py

@@ -10,7 +10,7 @@ import pathlib
 from typing import Union, Dict, Any, List
 
 from nl2sql.context import NL2SQLContext
-from nl2sql.datasources.registry import DatasourceRegistry
+from nl2sql.datasources.registry import DatasourceRegistry, mask_connection_args
 from nl2sql.datasources.models import DatasourceConfig
 
 
@@ -123,7 +123,7 @@ class DatasourceAPI:
         details = {
             "datasource_id": adapter.datasource_id,
             "datasource_engine_type": adapter.datasource_engine_type,
-            "connection_args": adapter.connection_args,
+            "connection_args": mask_connection_args(adapter.connection_args),
             "statement_timeout_ms": adapter.statement_timeout_ms,
             "row_limit": adapter.row_limit,
             "max_bytes": adapter.max_bytes,

nl2sql_engine-0.1.1/src/nl2sql/cli/checks.py

@@ -0,0 +1,80 @@
+import importlib.util
+
+from rich.table import Table
+from rich.text import Text
+
+from nl2sql.cli.console import console
+from nl2sql.configs import ConfigManager
+from nl2sql.datasources import DatasourceRegistry
+from nl2sql.secrets import SecretManager
+
+
+def check_package(name: str) -> bool:
+    """Checks if a python package is installed."""
+    import_name = name.replace("-", "_")
+    return importlib.util.find_spec(import_name) is not None
+
+
+def verify_connectivity(print_table: bool = True) -> bool:
+    """Checks connectivity for every configured datasource.
+
+    This backs ``nl2sql doctor``, which is what a user runs when something is
+    already wrong, so no failure mode may escape as an exception: a broken
+    config, an uninstalled driver, an unresolvable secret and a driver that
+    raises on connect all have to come back as a reported row or a message.
+
+    Returns:
+        bool: True only if every datasource connected. ``setup`` branches on
+        this to decide whether to warn before continuing.
+    """
+    try:
+        config_manager = ConfigManager()
+        secret_manager = SecretManager()
+        secret_configs = config_manager.load_secrets()
+        if secret_configs:
+            secret_manager.configure(secret_configs)
+        ds_configs = config_manager.load_datasources()
+        registry = DatasourceRegistry(secret_manager)
+    except Exception as e:
+        # Externally-sourced text (paths, parser errors): print it as Text so
+        # a bracket sequence in the message cannot be parsed as rich markup.
+        console.print(Text(f"Connectivity check failed: {e}", style="red"))
+        return False
+
+    if not ds_configs:
+        console.print("[yellow]No datasources configured.[/yellow]")
+        return True
+
+    results = []
+
+    with console.status("[bold green]Verifying connectivity...[/bold green]"):
+        for config in ds_configs:
+            ds_id = getattr(config, "id", None) or "<unknown>"
+            try:
+                adapter = registry.register_datasource(config)
+            except Exception as e:
+                results.append((ds_id, False, str(e)))
+                continue
+
+            try:
+                ok = bool(adapter.test_connection())
+                details = "" if ok else "Connection test failed."
+            except Exception as e:
+                ok, details = False, str(e)
+            results.append((ds_id, ok, details))
+
+    all_ok = all(ok for _, ok, _ in results)
+
+    if print_table:
+        conn_table = Table(show_header=True, header_style="bold cyan")
+        conn_table.add_column("Datasource ID")
+        conn_table.add_column("Status")
+        conn_table.add_column("Details")
+
+        for ds_id, ok, details in results:
+            status = "[green]OK[/green]" if ok else "[red]Failed[/red]"
+            conn_table.add_row(Text(str(ds_id)), status, Text(str(details)))
+
+        console.print(conn_table)
+
+    return all_ok

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/cli/commands/setup.py

@@ -7,6 +7,7 @@ from InquirerPy import inquirer
 from InquirerPy.validator import NumberValidator
 
 from nl2sql.cli.common.decorators import handle_cli_errors
+from nl2sql.cli.common.prompts import confirm
 from nl2sql.cli.console import console, print_success, print_step
 from nl2sql.cli.config import ADAPTER_DRIVERS, KNOWN_ADAPTERS
 from nl2sql.cli.commands.install import install_package
@@ -357,8 +358,22 @@ def setup_command(demo: bool = False, lite: bool = True, docker: bool = False, a
             demo_manager.setup_lite(api_key=api_key)
         elif docker:
             docker_dir = demo_manager.setup_docker(api_key=api_key)
-            if inquirer.confirm(message="Start Docker containers now?", default=True).execute():
+            # A terminal that cannot host a prompt (Git Bash/MSYS) must not be
+            # read as consent to pull images and bind ports, so the fallback is
+            # "no": the artifacts are already on disk and the panel below tells
+            # the user how to start the stack themselves.
+            if confirm(
+                "Start Docker containers now?",
+                default=True,
+                when_unavailable=False,
+            ):
                 demo_manager.start_docker_containers(docker_dir)
+            else:
+                console.print(
+                    f"[dim]Containers not started. To start them yourself: "
+                    f"cd {escape(str(docker_dir))} && "
+                    f"docker compose -f docker-compose.demo.yml up -d[/dim]"
+                )
                 
             console.print(Panel(f"""[bold yellow]Next Steps:[/bold yellow]
                     1. [bold]Verify & Index[/bold]:

nl2sql_engine-0.1.1/src/nl2sql/cli/common/prompts.py

@@ -0,0 +1,53 @@
+"""Interactive prompts that survive a terminal which cannot host them.
+
+Git Bash / MSYS on Windows present a TTY that is not a Windows console, so
+``prompt_toolkit`` -- which InquirerPy builds every prompt on -- refuses to
+attach and raises ``NoConsoleScreenBufferError``. That killed
+``nl2sql setup --demo --docker`` with a traceback *after* it had already
+written the demo artifacts, which is the exact flow the docs tell users to run.
+
+The convention here: a prompt that cannot be shown is answered the way a
+non-interactive run would answer it, and the caller states that answer
+explicitly rather than inheriting the interactive default. The two are not the
+same -- a prompt guarding an action with side effects defaults to "yes" when a
+human is watching and to "no" when nobody can say otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from InquirerPy import inquirer
+from rich.markup import escape
+
+from nl2sql.cli.console import console
+
+if sys.platform == "win32":  # pragma: no cover - exercised only on Windows
+    from prompt_toolkit.output.win32 import NoConsoleScreenBufferError
+else:
+    class NoConsoleScreenBufferError(Exception):
+        """Stand-in for the Windows-only prompt_toolkit error.
+
+        ``prompt_toolkit.output.win32`` asserts ``sys.platform == "win32"`` at
+        import time, so the real class cannot be imported elsewhere. This one is
+        never raised in production; it only keeps the ``except`` clause below
+        importable (and testable) on every platform.
+        """
+
+
+def confirm(message: str, default: bool, when_unavailable: bool) -> bool:
+    """Ask a yes/no question, falling back when no prompt can be displayed.
+
+    ``default`` is the pre-selected answer for a human; ``when_unavailable`` is
+    the answer used when the terminal cannot host a prompt at all.
+    """
+    try:
+        return inquirer.confirm(message=message, default=default).execute()
+    except (NoConsoleScreenBufferError, EOFError):
+        answer = "yes" if when_unavailable else "no"
+        console.print(
+            f"[yellow]No usable interactive console (Git Bash/MSYS or a "
+            f"redirected terminal). Assuming '{answer}' for:[/yellow] "
+            f"{escape(message)}"
+        )
+        return when_unavailable

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/cli/demo/defaults.py

@@ -69,13 +69,17 @@ DEMO_LITE_DATASOURCES = [
     {"id": "manufacturing_history", "connection": {"type": "sqlite", "database": "data/demo_lite/manufacturing_history.db"}, "description": "Historical Data (Sales)"},
 ]
 
+# Host and port are resolved from the environment so one config serves both
+# callers: `.env.demo` defaults to localhost + the published ports for the
+# host-side CLI, and the compose `app` service overrides them with the
+# compose service names + internal ports.
 DEMO_DOCKER_DATASOURCES = [
     {
         "id": "manufacturing_ref", 
         "connection": {
             "type": "postgres", 
-            "host": "localhost",
-            "port": 5433,
+            "host": "${env:DEMO_REF_HOST}",
+            "port": "${env:DEMO_REF_PORT}",
             "user": "${env:DEMO_REF_USER}",
             "password": "${env:DEMO_REF_PASSWORD}",
             "database": "manufacturing_ref"
@@ -86,8 +90,8 @@ DEMO_DOCKER_DATASOURCES = [
         "id": "manufacturing_ops", 
         "connection": {
             "type": "postgres", 
-            "host": "localhost",
-            "port": 5434,
+            "host": "${env:DEMO_OPS_HOST}",
+            "port": "${env:DEMO_OPS_PORT}",
             "user": "${env:DEMO_OPS_USER}",
             "password": "${env:DEMO_OPS_PASSWORD}",
             "database": "manufacturing_ops"
@@ -98,8 +102,8 @@ DEMO_DOCKER_DATASOURCES = [
         "id": "manufacturing_supply", 
         "connection": {
             "type": "mysql", 
-            "host": "localhost",
-            "port": 3307,
+            "host": "${env:DEMO_SUPPLY_HOST}",
+            "port": "${env:DEMO_SUPPLY_PORT}",
             "user": "${env:DEMO_SUPPLY_USER}",
             "password": "${env:DEMO_SUPPLY_PASSWORD}",
             "database": "manufacturing_supply"
@@ -110,8 +114,8 @@ DEMO_DOCKER_DATASOURCES = [
         "id": "manufacturing_history", 
         "connection": {
             "type": "mssql", 
-            "host": "localhost",
-            "port": 1434,
+            "host": "${env:DEMO_HISTORY_HOST}",
+            "port": "${env:DEMO_HISTORY_PORT}",
             "user": "${env:DEMO_HISTORY_USER}",
             "password": "${env:DEMO_HISTORY_PASSWORD}",
             "database": "manufacturing_history",

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/cli/demo/schemas.py

@@ -323,6 +323,18 @@ services:
       - "8000:8000"
     env_file:
       - ../.env.demo
+    environment:
+      # .env.demo points at localhost + the published ports, which is correct
+      # from the developer's machine but not from in here -- inside the compose
+      # network the databases answer on their service names and internal ports.
+      DEMO_REF_HOST: manufacturing_ref
+      DEMO_REF_PORT: 5432
+      DEMO_OPS_HOST: manufacturing_ops
+      DEMO_OPS_PORT: 5432
+      DEMO_SUPPLY_HOST: manufacturing_supply
+      DEMO_SUPPLY_PORT: 3306
+      DEMO_HISTORY_HOST: manufacturing_history
+      DEMO_HISTORY_PORT: 1433
     volumes:
       - ../configs:/app/configs
       - ../data:/app/data

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/cli/demo/writers/docker.py

@@ -157,11 +157,19 @@ GO
         content = f"""# NL2SQL Demo Environment Secrets
 # Generated automatically. DO NOT COMMIT TO VERSION CONTROL.
 
+# Host-side defaults: the published ports on localhost, for
+# `nl2sql --env demo index` / `run` from the developer's machine. The compose
+# `app` service overrides these with the service names and internal ports.
+
 # 1. Manufacturing Ref (Postgres)
+DEMO_REF_HOST=localhost
+DEMO_REF_PORT=5433
 DEMO_REF_USER=ref_admin
 DEMO_REF_PASSWORD={secrets["DEMO_REF_PASSWORD"]}
 
 # 2. Manufacturing Ops (Postgres)
+DEMO_OPS_HOST=localhost
+DEMO_OPS_PORT=5434
 DEMO_OPS_USER=ops_admin
 DEMO_OPS_PASSWORD={secrets["DEMO_OPS_PASSWORD"]}
 
@@ -170,11 +178,15 @@ DEMO_POSTGRES_USER=postgres
 DEMO_POSTGRES_PASSWORD={secrets["DEMO_POSTGRES_PASSWORD"]}
 
 # 3. Manufacturing Supply (MySQL)
+DEMO_SUPPLY_HOST=localhost
+DEMO_SUPPLY_PORT=3307
 DEMO_SUPPLY_USER=supply_admin
 DEMO_SUPPLY_PASSWORD={secrets["DEMO_SUPPLY_PASSWORD"]}
 DEMO_MYSQL_ROOT_PASSWORD={secrets["DEMO_MYSQL_ROOT_PASSWORD"]}
 
 # 4. Manufacturing History (MSSQL)
+DEMO_HISTORY_HOST=localhost
+DEMO_HISTORY_PORT=1434
 DEMO_HISTORY_USER=history_admin
 DEMO_HISTORY_PASSWORD={secrets["DEMO_HISTORY_PASSWORD"]}
 DEMO_MSSQL_SA_PASSWORD={secrets["DEMO_MSSQL_SA_PASSWORD"]}

nl2sql_engine-0.1.1/src/nl2sql/common/exceptions.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from nl2sql.common.errors import PipelineError
+
+
+class NL2SQLError(Exception):
+    """Base exception for all NL2SQL errors."""
+    pass
+
+
+class PipelineExecutionError(NL2SQLError):
+    """Raised when a pipeline step fails where a PipelineError cannot be returned.
+
+    Most of the pipeline reports failures by putting a ``PipelineError`` into
+    graph state as a value. LangGraph conditional-edge routers cannot do that --
+    they may only return routing decisions -- so they raise this instead. The
+    structured payload is kept on ``error`` because ``error_code``, ``severity``
+    and ``is_retryable`` drive downstream handling; ``str()`` is the underlying
+    message so the CLI error decorator prints something readable.
+    """
+
+    def __init__(self, error: PipelineError):
+        super().__init__(error.message)
+        self.error = error

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/configs/manager.py

@@ -125,7 +125,10 @@ class ConfigManager:
             
         try:
             content = target_path.read_text(encoding="utf-8")
-            raw = yaml.safe_load(content) or []
+            # An empty file parses as None. Fall back to a mapping, not a
+            # list: the envelope is a mapping, and `or []` made an empty file
+            # fail with a misleading "should be a valid dictionary".
+            raw = yaml.safe_load(content) or {}
             
             file_config = SecretsFileConfig.model_validate(raw)
             return file_config.providers

nl2sql_engine-0.1.1/src/nl2sql/configs/secrets.py

@@ -0,0 +1,23 @@
+
+from typing import List
+
+from pydantic import BaseModel, Field, field_validator
+from nl2sql.secrets.models import SecretProviderConfig
+
+class SecretsFileConfig(BaseModel):
+    """File-level schema for secrets.yaml."""
+    version: int = Field(1, description="Schema version")
+    providers: List[SecretProviderConfig] = Field(default_factory=list)
+
+    @field_validator("providers", mode="before")
+    @classmethod
+    def _empty_providers_means_none_configured(cls, value):
+        """Treat ``providers:`` with nothing under it as no providers.
+
+        Secret providers are optional, so the default alone is not enough:
+        pydantic applies it only when the key is absent, and a user who
+        comments out every example leaves the key present with a null value.
+        YAML parses that as ``None``, which the annotation rejects. Coerce it
+        here so the missing key and the empty key behave the same.
+        """
+        return [] if value is None else value

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/datasources/registry.py

@@ -7,6 +7,32 @@ from nl2sql.datasources.protocols import DatasourceAdapterProtocol
 from nl2sql.secrets import SecretManager
 from .models import DatasourceConfig, ConnectionConfig
 
+# Resolved connection args hold plaintext secrets (see ``resolved_connection``),
+# so anything that renders them -- an API payload, a `doctor` row, a pydantic
+# ValidationError repr -- has to mask them by name first.
+SECRET_ARG_HINTS = ("password", "secret", "token", "api_key")
+
+
+def _is_secret_arg(key: str) -> bool:
+    return any(hint in key.lower() for hint in SECRET_ARG_HINTS)
+
+
+def mask_connection_args(connection_args: Dict[str, Any]) -> Dict[str, Any]:
+    """Returns a copy of the connection args with secret values masked."""
+    return {
+        key: ("***" if _is_secret_arg(key) and value else value)
+        for key, value in (connection_args or {}).items()
+    }
+
+
+def redact_connection_secrets(text: str, connection_args: Dict[str, Any]) -> str:
+    """Replaces every secret value from the connection args found in ``text``."""
+    for key, value in (connection_args or {}).items():
+        if _is_secret_arg(key) and isinstance(value, str) and value:
+            text = text.replace(value, "***")
+    return text
+
+
 class DatasourceRegistry:
     """Manages a collection of active DatasourceAdapters.
     
@@ -38,19 +64,24 @@ class DatasourceRegistry:
     def resolved_connection(self, unresolved_connection: ConnectionConfig) -> ConnectionConfig:
         """Resolves all secrets in a connection dictionary.
 
+        Values are returned as plain strings. ``ConnectionConfig`` declares only
+        ``type`` and allows extras, so there is no type information here to tell
+        a password apart from a host, a user or a port -- wrapping every
+        placeholder in ``SecretStr`` broke every non-password field. Each
+        adapter's own config model declares which fields are secret and pydantic
+        coerces the plain string into ``SecretStr`` for those, so masking is
+        preserved exactly where it is declared.
+
         Args:
             unresolved_connection (ConnectionConfig): The connection dictionary with potential secrets.
 
         Returns:
             ConnectionConfig: The connection dictionary with resolved secrets.
         """
-        from pydantic import SecretStr
-        
         resolved_connection = unresolved_connection.model_dump()
-        for key, value in unresolved_connection.model_dump().items():
+        for key, value in list(resolved_connection.items()):
             if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
-                secret_val = self.find_and_resolve_secret(value)
-                resolved_connection[key] = SecretStr(secret_val)
+                resolved_connection[key] = self.find_and_resolve_secret(value)
         return ConnectionConfig(**resolved_connection)
 
     def register_datasources(self, configs: List[DatasourceConfig]):
@@ -95,14 +126,22 @@ class DatasourceRegistry:
         if conn_type in self._available_adapters:
             adapter_cls = self._available_adapters[conn_type]
 
-            adapter = adapter_cls(
-                datasource_id=ds_id,
-                datasource_engine_type=conn_type,
-                connection_args=connection_args,
-                statement_timeout_ms=config.options.get("statement_timeout_ms"),
-                row_limit=config.options.get("row_limit"),
-                max_bytes=config.options.get("max_bytes"),
-            )
+            try:
+                adapter = adapter_cls(
+                    datasource_id=ds_id,
+                    datasource_engine_type=conn_type,
+                    connection_args=connection_args,
+                    statement_timeout_ms=config.options.get("statement_timeout_ms"),
+                    row_limit=config.options.get("row_limit"),
+                    max_bytes=config.options.get("max_bytes"),
+                )
+            except Exception as e:
+                # A pydantic ValidationError renders the whole input dict, which
+                # now holds the plaintext password. Re-raise without the cause so
+                # neither the message nor the traceback carries it.
+                raise ValueError(
+                    redact_connection_secrets(str(e), connection_args)
+                ) from None
             with self._lock:
                 self._adapters[ds_id] = adapter
                 if hasattr(adapter, "capabilities"):

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/pipeline/routes.py

@@ -4,6 +4,7 @@ from langgraph.graph import END
 from langgraph.types import Send
 
 from nl2sql.common.errors import PipelineError, ErrorSeverity, ErrorCode
+from nl2sql.common.exceptions import PipelineExecutionError
 from nl2sql.context import NL2SQLContext
 from nl2sql.pipeline.graph_utils import (
     StateAccessor,
@@ -58,11 +59,13 @@ def build_scan_layer_router(ctx: NL2SQLContext):
 
             target = resolve_subgraph(datasource_id, ctx)
             if not target:
-                raise PipelineError(
-                    node="layer_router",
-                    message=f"No compatible subgraph found for datasource '{datasource_id}'.",
-                    severity=ErrorSeverity.ERROR,
-                    error_code=ErrorCode.INVALID_STATE,
+                raise PipelineExecutionError(
+                    PipelineError(
+                        node="layer_router",
+                        message=f"No compatible subgraph found for datasource '{datasource_id}'.",
+                        severity=ErrorSeverity.ERROR,
+                        error_code=ErrorCode.INVALID_STATE,
+                    )
                 )
             payload = build_scan_payload(state, target, node_id)
             branches.append(Send(target, payload))

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql/pipeline/runtime.py

@@ -10,6 +10,7 @@ from typing import Callable, Dict, List, Optional
 from nl2sql.auth import UserContext
 from nl2sql.common.cancellation import CancellationToken
 from nl2sql.common.errors import PipelineError, ErrorSeverity, ErrorCode
+from nl2sql.common.exceptions import PipelineExecutionError
 from nl2sql.common.settings import settings
 from nl2sql.context import NL2SQLContext
 from nl2sql.pipeline.graph import build_graph
@@ -135,6 +136,11 @@ def run_with_graph(
             ],
             "final_answer": "I apologize, but the request timed out. Please try again with a simpler query.",
         }
+    except PipelineExecutionError as e:
+        # Raised where a PipelineError cannot be returned as a value (conditional-edge
+        # routers). The payload is already structured, so surface it unchanged: the
+        # blanket catch below would relabel it UNKNOWN_ERROR and flip is_retryable.
+        return {"errors": [e.error]}
     except Exception as e:
         # Fallback for other runtime crashes
         return {

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nl2sql-engine
-Version: 0.1.0
+Version: 0.1.1
 Summary: Natural-language-to-SQL engine, CLI and database adapters
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{nl2sql_engine-0.1.0 → nl2sql_engine-0.1.1}/src/nl2sql_engine.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ src/nl2sql/cli/commands/run.py
 src/nl2sql/cli/commands/setup.py
 src/nl2sql/cli/commands/visualize.py
 src/nl2sql/cli/common/decorators.py
+src/nl2sql/cli/common/prompts.py
 src/nl2sql/cli/demo/__init__.py
 src/nl2sql/cli/demo/data.py
 src/nl2sql/cli/demo/defaults.py

nl2sql_engine-0.1.0/src/nl2sql/cli/checks.py

@@ -1,53 +0,0 @@
-import importlib.util
-from typing import Dict, Tuple
-import pathlib
-from rich.markup import escape
-from rich.table import Table
-from rich.text import Text
-from nl2sql.cli.console import console, print_success, print_error
-
-def check_package(name: str) -> bool:
-    """Checks if a python package is installed."""
-    import_name = name.replace("-", "_")
-    return importlib.util.find_spec(import_name) is not None
-
-def verify_connectivity(print_table: bool = True) -> bool:
-    """
-    Checks connectivity for all profiles in the default config.
-    Returns True if all checks passed, False otherwise.
-    """
-    from nl2sql.common.settings import settings
-    from nl2sql.datasources import load_profiles
-    from nl2sql.diagnostics import check_connectivity as core_check
-    
-    try:
-        profiles = load_profiles(pathlib.Path(settings.datasource_config_path))
-        
-        with console.status("[bold green]Verifying connectivity...[/bold green]"):
-            results = core_check(list(profiles.values()))
-        
-        all_ok = True
-        
-        if print_table:
-            conn_table = Table(show_header=True, header_style="bold cyan")
-            conn_table.add_column("Datasource ID")
-            conn_table.add_column("Status")
-            conn_table.add_column("Details")
-        
-        for ds_id, (success, msg) in results.items():
-            if not success:
-                all_ok = False
-            
-            if print_table:
-                status = "[green]OK[/green]" if success else "[red]Failed[/red]"
-                details = msg if not success else ""
-                conn_table.add_row(Text(str(ds_id)), status, Text(str(details)))
-        
-        if print_table:
-            console.print(conn_table)
-            
-        return all_ok
-
-    except Exception as e:
-         console.print(f"[red]Connectivity check failed: {escape(str(e))}[/red]")
-         return False

nl2sql_engine-0.1.0/src/nl2sql/common/exceptions.py

@@ -1,3 +0,0 @@
-class NL2SQLError(Exception):
-    """Base exception for all NL2SQL errors."""
-    pass

nl2sql_engine-0.1.0/src/nl2sql/configs/secrets.py

@@ -1,11 +0,0 @@
-
-from typing import List
-
-from pydantic import BaseModel, Field
-from nl2sql.secrets.models import SecretProviderConfig
-
-class SecretsFileConfig(BaseModel):
-    """File-level schema for secrets.yaml."""
-    version: int = Field(1, description="Schema version")
-    providers: List[SecretProviderConfig]
-