nao-core 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

nao_core/__init__.py

@@ -1,3 +1,2 @@
 # nao Core CLI package
-__version__ = "0.0.9"
-
+__version__ = "0.0.11"

nao_core/commands/__init__.py

@@ -1,5 +1,6 @@
 from nao_core.commands.chat import chat
+from nao_core.commands.debug import debug
 from nao_core.commands.init import init
+from nao_core.commands.sync import sync
 
-__all__ = ["chat", "init"]
-
+__all__ = ["chat", "debug", "init", "sync"]

nao_core/commands/chat.py

@@ -16,125 +16,117 @@ SERVER_PORT = 5005
 
 
 def get_server_binary_path() -> Path:
-	"""Get the path to the bundled nao-chat-server binary."""
-	# The binary is in the bin folder relative to this file
-	cli_dir = Path(__file__).parent.parent
-	bin_dir = cli_dir / "bin"
-	binary_path = bin_dir / "nao-chat-server"
+    """Get the path to the bundled nao-chat-server binary."""
+    # The binary is in the bin folder relative to this file
+    cli_dir = Path(__file__).parent.parent
+    bin_dir = cli_dir / "bin"
+    binary_path = bin_dir / "nao-chat-server"
 
-	if not binary_path.exists():
-		console.print(
-			f"[bold red]✗[/bold red] Server binary not found at {binary_path}"
-		)
-		console.print(
-			"[dim]Make sure you've built the server with ./scripts/build-server.sh[/dim]"
-		)
-		sys.exit(1)
+    if not binary_path.exists():
+        console.print(f"[bold red]✗[/bold red] Server binary not found at {binary_path}")
+        console.print("[dim]Make sure you've built the server with ./scripts/build-server.sh[/dim]")
+        sys.exit(1)
 
-	return binary_path
+    return binary_path
 
 
 def wait_for_server(port: int, timeout: int = 30) -> bool:
-	"""Wait for the server to be ready."""
-	import socket
-
-	for _ in range(timeout * 10):  # Check every 100ms
-		try:
-			with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-				sock.settimeout(0.1)
-				result = sock.connect_ex(("localhost", port))
-				if result == 0:
-					return True
-		except OSError:
-			pass
-		sleep(0.1)
-	return False
+    """Wait for the server to be ready."""
+    import socket
+
+    for _ in range(timeout * 10):  # Check every 100ms
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.settimeout(0.1)
+                result = sock.connect_ex(("localhost", port))
+                if result == 0:
+                    return True
+        except OSError:
+            pass
+        sleep(0.1)
+    return False
 
 
 def chat():
-	"""Start the nao chat UI.
-
-	Launches the nao chat server and opens the web interface in your browser.
-	"""
-	console.print("\n[bold cyan]💬 Starting nao chat...[/bold cyan]\n")
-
-	binary_path = get_server_binary_path()
-	bin_dir = binary_path.parent
-
-	console.print(f"[dim]Server binary: {binary_path}[/dim]")
-	console.print(f"[dim]Working directory: {bin_dir}[/dim]")
-
-	# Try to load nao config from current directory
-	config = NaoConfig.try_load()
-	if config:
-		console.print(f"[bold green]✓[/bold green] Loaded config from {Path.cwd() / 'nao_config.yaml'}")
-	else:
-		console.print("[dim]No nao_config.yaml found in current directory[/dim]")
-
-	# Start the server process
-	process = None
-	try:
-		# Set up environment - inherit from parent but ensure we're in the bin dir
-		# so the server can find the public folder
-		env = os.environ.copy()
-
-		# Set LLM API key from config if available
-		if config and config.llm:
-			env_var_name = f"{config.llm.model.upper()}_API_KEY"
-			env[env_var_name] = config.llm.api_key
-			console.print(f"[bold green]✓[/bold green] Set {env_var_name} from config")
-
-		process = subprocess.Popen(
-			[str(binary_path)],
-			cwd=str(bin_dir),
-			env=env,
-			stdout=subprocess.PIPE,
-			stderr=subprocess.STDOUT,
-			text=True,
-		)
-
-		console.print("[bold green]✓[/bold green] Server starting...")
-
-		# Wait for the server to be ready
-		if wait_for_server(SERVER_PORT):
-			url = f"http://localhost:{SERVER_PORT}"
-			console.print(f"[bold green]✓[/bold green] Server ready at {url}")
-			console.print("\n[bold]Opening browser...[/bold]")
-			webbrowser.open(url)
-			console.print(
-				"\n[dim]Press Ctrl+C to stop the server[/dim]\n"
-			)
-		else:
-			console.print(
-				"[bold yellow]⚠[/bold yellow] Server is taking longer than expected to start..."
-			)
-			console.print(f"[dim]Check http://localhost:{SERVER_PORT} manually[/dim]")
-
-		# Stream server output to console
-		if process.stdout:
-			for line in process.stdout:
-				# Filter out some of the verbose logging if needed
-				console.print(f"[dim]{line.rstrip()}[/dim]")
-
-		# Wait for process to complete
-		process.wait()
-
-	except KeyboardInterrupt:
-		console.print("\n[bold yellow]Shutting down...[/bold yellow]")
-		if process:
-			# Send SIGTERM for graceful shutdown
-			process.terminate()
-			try:
-				process.wait(timeout=5)
-			except subprocess.TimeoutExpired:
-				# Force kill if it doesn't respond
-				process.kill()
-				process.wait()
-		console.print("[bold green]✓[/bold green] Server stopped")
-		sys.exit(0)
-
-	except Exception as e:
-		console.print(f"[bold red]✗[/bold red] Failed to start server: {e}")
-		if process:
-			process.kill()
-		sys.exit(1)
+    """Start the nao chat UI.
+
+    Launches the nao chat server and opens the web interface in your browser.
+    """
+    console.print("\n[bold cyan]💬 Starting nao chat...[/bold cyan]\n")
+
+    binary_path = get_server_binary_path()
+    bin_dir = binary_path.parent
+
+    console.print(f"[dim]Server binary: {binary_path}[/dim]")
+    console.print(f"[dim]Working directory: {bin_dir}[/dim]")
+
+    # Try to load nao config from current directory
+    config = NaoConfig.try_load()
+    if config:
+        console.print(f"[bold green]✓[/bold green] Loaded config from {Path.cwd() / 'nao_config.yaml'}")
+    else:
+        console.print("[dim]No nao_config.yaml found in current directory[/dim]")
+
+    # Start the server process
+    process = None
+    try:
+        # Set up environment - inherit from parent but ensure we're in the bin dir
+        # so the server can find the public folder
+        env = os.environ.copy()
+
+        # Set LLM API key from config if available
+        if config and config.llm:
+            env_var_name = f"{config.llm.provider.upper()}_API_KEY"
+            env[env_var_name] = config.llm.api_key
+            console.print(f"[bold green]✓[/bold green] Set {env_var_name} from config")
+
+        process = subprocess.Popen(
+            [str(binary_path)],
+            cwd=str(bin_dir),
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+
+        console.print("[bold green]✓[/bold green] Server starting...")
+
+        # Wait for the server to be ready
+        if wait_for_server(SERVER_PORT):
+            url = f"http://localhost:{SERVER_PORT}"
+            console.print(f"[bold green]✓[/bold green] Server ready at {url}")
+            console.print("\n[bold]Opening browser...[/bold]")
+            webbrowser.open(url)
+            console.print("\n[dim]Press Ctrl+C to stop the server[/dim]\n")
+        else:
+            console.print("[bold yellow]⚠[/bold yellow] Server is taking longer than expected to start...")
+            console.print(f"[dim]Check http://localhost:{SERVER_PORT} manually[/dim]")
+
+        # Stream server output to console
+        if process.stdout:
+            for line in process.stdout:
+                # Filter out some of the verbose logging if needed
+                console.print(f"[dim]{line.rstrip()}[/dim]")
+
+        # Wait for process to complete
+        process.wait()
+
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]Shutting down...[/bold yellow]")
+        if process:
+            # Send SIGTERM for graceful shutdown
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                # Force kill if it doesn't respond
+                process.kill()
+                process.wait()
+        console.print("[bold green]✓[/bold green] Server stopped")
+        sys.exit(0)
+
+    except Exception as e:
+        console.print(f"[bold red]✗[/bold red] Failed to start server: {e}")
+        if process:
+            process.kill()
+        sys.exit(1)

nao_core/commands/debug.py

@@ -0,0 +1,144 @@
+import sys
+
+from rich.console import Console
+from rich.table import Table
+
+from nao_core.config import NaoConfig
+
+console = Console()
+
+
+def test_database_connection(db_config) -> tuple[bool, str]:
+    """Test connectivity to a database.
+
+    Returns:
+            Tuple of (success, message)
+    """
+    try:
+        conn = db_config.connect()
+        # Run a simple query to verify the connection works
+        if db_config.dataset_id:
+            # If dataset is specified, list tables in that dataset
+            tables = conn.list_tables()
+            table_count = len(tables)
+            return True, f"Connected successfully ({table_count} tables found)"
+        else:
+            # If no dataset, list datasets in the project instead
+            datasets = conn.list_databases()
+            dataset_count = len(datasets)
+            return True, f"Connected successfully ({dataset_count} datasets found)"
+    except Exception as e:
+        return False, str(e)
+
+
+def test_llm_connection(llm_config) -> tuple[bool, str]:
+    """Test connectivity to an LLM provider.
+
+    Returns:
+            Tuple of (success, message)
+    """
+    try:
+        if llm_config.provider.value == "openai":
+            import openai
+
+            client = openai.OpenAI(api_key=llm_config.api_key)
+            # Make a minimal API call to verify the key works
+            models = client.models.list()
+            # Just check we can iterate (don't need to consume all)
+            model_count = sum(1 for _ in models)
+            return True, f"Connected successfully ({model_count} models available)"
+        else:
+            return False, f"Unknown provider: {llm_config.provider}"
+    except Exception as e:
+        return False, str(e)
+
+
+def debug():
+    """Test connectivity to configured databases and LLMs.
+
+    Loads the nao configuration from the current directory and tests
+    connections to all configured databases and LLM providers.
+    """
+    console.print("\n[bold cyan]🔍 nao debug - Testing connections...[/bold cyan]\n")
+
+    # Load config
+    config = NaoConfig.try_load()
+    if not config:
+        console.print("[bold red]✗[/bold red] No nao_config.yaml found in current directory")
+        console.print("[dim]Run 'nao init' to create a configuration file[/dim]")
+        sys.exit(1)
+
+    console.print(f"[bold green]✓[/bold green] Loaded config: [cyan]{config.project_name}[/cyan]\n")
+
+    # Test databases
+    if config.databases:
+        console.print("[bold]Databases:[/bold]")
+        db_table = Table(show_header=True, header_style="bold")
+        db_table.add_column("Name")
+        db_table.add_column("Type")
+        db_table.add_column("Status")
+        db_table.add_column("Details")
+
+        for db in config.databases:
+            console.print(f"  Testing [cyan]{db.name}[/cyan]...", end=" ")
+            success, message = test_database_connection(db)
+
+            if success:
+                console.print("[bold green]✓[/bold green]")
+                db_table.add_row(
+                    db.name,
+                    db.type,
+                    "[green]Connected[/green]",
+                    message,
+                )
+            else:
+                console.print("[bold red]✗[/bold red]")
+                # Truncate long error messages
+                short_msg = message[:80] + "..." if len(message) > 80 else message
+                db_table.add_row(
+                    db.name,
+                    db.type,
+                    "[red]Failed[/red]",
+                    short_msg,
+                )
+
+        console.print()
+        console.print(db_table)
+    else:
+        console.print("[dim]No databases configured[/dim]")
+
+    console.print()
+
+    # Test LLM
+    if config.llm:
+        console.print("[bold]LLM Provider:[/bold]")
+        llm_table = Table(show_header=True, header_style="bold")
+        llm_table.add_column("Provider")
+        llm_table.add_column("Status")
+        llm_table.add_column("Details")
+
+        console.print(f"  Testing [cyan]{config.llm.provider.value}[/cyan]...", end=" ")
+        success, message = test_llm_connection(config.llm)
+
+        if success:
+            console.print("[bold green]✓[/bold green]")
+            llm_table.add_row(
+                config.llm.provider.value,
+                "[green]Connected[/green]",
+                message,
+            )
+        else:
+            console.print("[bold red]✗[/bold red]")
+            short_msg = message[:80] + "..." if len(message) > 80 else message
+            llm_table.add_row(
+                config.llm.provider.value,
+                "[red]Failed[/red]",
+                short_msg,
+            )
+
+        console.print()
+        console.print(llm_table)
+    else:
+        console.print("[dim]No LLM configured[/dim]")
+
+    console.print()

nao_core/commands/init.py

@@ -1,72 +1,175 @@
 from pathlib import Path
+from typing import Annotated
 
+from cyclopts import Parameter
 from rich.console import Console
 from rich.prompt import Confirm, Prompt
 
-from nao_core.config import LLMConfig, LLMProvider, NaoConfig
+from nao_core.config import BigQueryConfig, DatabaseConfig, DatabaseType, LLMConfig, LLMProvider, NaoConfig
 
 console = Console()
 
 
-def init():
-	"""Initialize a new nao project.
+class InitError(Exception):
+    """Base exception for init command errors."""
 
-	Creates a project folder with a nao_config.yaml configuration file.
-	"""
-	console.print("\n[bold cyan]🚀 nao project initialization[/bold cyan]\n")
+    pass
 
-	project_name = Prompt.ask("[bold]Enter your project name[/bold]")
 
-	if not project_name:
-		console.print("[bold red]✗[/bold red] Project name cannot be empty.")
-		return
+class EmptyProjectNameError(InitError):
+    """Raised when project name is empty."""
 
-	project_path = Path(project_name)
+    def __init__(self):
+        super().__init__("Project name cannot be empty.")
 
-	if project_path.exists():
-		console.print(
-			f"[bold red]✗[/bold red] Folder [yellow]'{project_name}'[/yellow] already exists."
-		)
-		return
 
-	# LLM Configuration
-	llm_config = None
-	setup_llm = Confirm.ask("\n[bold]Set up LLM configuration?[/bold]", default=True)
+class ProjectExistsError(InitError):
+    """Raised when project folder already exists."""
 
-	if setup_llm:
-		console.print("\n[bold cyan]LLM Configuration[/bold cyan]\n")
+    def __init__(self, project_name: str):
+        self.project_name = project_name
+        super().__init__(f"Folder '{project_name}' already exists.")
 
-		provider_choices = [p.value for p in LLMProvider]
-		llm_provider = Prompt.ask(
-			"[bold]Select LLM provider[/bold]",
-			choices=provider_choices,
-			default=provider_choices[0],
-		)
 
-		api_key = Prompt.ask(
-			f"[bold]Enter your {llm_provider.upper()} API key[/bold]",
-			password=True,
-		)
+class EmptyApiKeyError(InitError):
+    """Raised when API key is empty."""
 
-		if not api_key:
-			console.print("[bold red]✗[/bold red] API key cannot be empty.")
-			return
+    def __init__(self):
+        super().__init__("API key cannot be empty.")
 
-		llm_config = LLMConfig(
-			model=LLMProvider(llm_provider),
-			api_key=api_key,
-		)
 
-	project_path.mkdir(parents=True)
+def setup_project_name(force: bool = False) -> tuple[str, Path]:
+    """Setup the project name."""
+    project_name = Prompt.ask("[bold]Enter your project name[/bold]")
 
-	config = NaoConfig(project_name=project_name, llm=llm_config)
-	config.save(project_path)
+    if not project_name:
+        raise EmptyProjectNameError()
 
-	console.print()
-	console.print(f"[bold green]✓[/bold green] Created project [cyan]{project_name}[/cyan]")
-	console.print(
-		f"[bold green]✓[/bold green] Created [dim]{project_path / 'nao_config.yaml'}[/dim]"
-	)
-	console.print()
-	console.print("[bold green]Done![/bold green] Your nao project is ready. 🎉")
+    project_path = Path(project_name)
 
+    if project_path.exists() and not force:
+        raise ProjectExistsError(project_name)
+
+    project_path.mkdir(parents=True, exist_ok=True)
+
+    return project_name, project_path
+
+
+def setup_bigquery() -> BigQueryConfig:
+    """Setup a BigQuery database configuration."""
+    console.print("\n[bold cyan]BigQuery Configuration[/bold cyan]\n")
+
+    name = Prompt.ask("[bold]Connection name[/bold]", default="bigquery-prod")
+
+    project_id = Prompt.ask("[bold]GCP Project ID[/bold]")
+    if not project_id:
+        raise InitError("GCP Project ID cannot be empty.")
+
+    dataset_id = Prompt.ask("[bold]Default dataset[/bold] [dim](optional, press Enter to skip)[/dim]", default="")
+
+    credentials_path = Prompt.ask(
+        "[bold]Service account JSON path[/bold] [dim](optional, uses ADC if empty)[/dim]",
+        default="",
+    )
+
+    return BigQueryConfig(
+        name=name,
+        project_id=project_id,
+        dataset_id=dataset_id or None,
+        credentials_path=credentials_path or None,
+    )
+
+
+def setup_databases() -> list[DatabaseConfig]:
+    """Setup database configurations."""
+    databases: list[DatabaseConfig] = []
+
+    should_setup = Confirm.ask("\n[bold]Set up database connections?[/bold]", default=True)
+
+    if not should_setup:
+        return databases
+
+    while True:
+        console.print("\n[bold cyan]Database Configuration[/bold cyan]\n")
+
+        db_type_choices = [t.value for t in DatabaseType]
+        db_type = Prompt.ask(
+            "[bold]Select database type[/bold]",
+            choices=db_type_choices,
+            default=db_type_choices[0],
+        )
+
+        if db_type == DatabaseType.BIGQUERY.value:
+            db_config = setup_bigquery()
+            databases.append(db_config)
+            console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
+
+        add_another = Confirm.ask("\n[bold]Add another database?[/bold]", default=False)
+        if not add_another:
+            break
+
+    return databases
+
+
+def setup_llm() -> LLMConfig | None:
+    """Setup the LLM configuration."""
+    llm_config = None
+    should_setup = Confirm.ask("\n[bold]Set up LLM configuration?[/bold]", default=True)
+
+    if should_setup:
+        console.print("\n[bold cyan]LLM Configuration[/bold cyan]\n")
+
+        provider_choices = [p.value for p in LLMProvider]
+        llm_provider = Prompt.ask(
+            "[bold]Select LLM provider[/bold]",
+            choices=provider_choices,
+            default=provider_choices[0],
+        )
+
+        api_key = Prompt.ask(
+            f"[bold]Enter your {llm_provider.upper()} API key[/bold]",
+            password=True,
+        )
+
+        if not api_key:
+            raise EmptyApiKeyError()
+
+        llm_config = LLMConfig(
+            provider=LLMProvider(llm_provider),
+            api_key=api_key,
+        )
+
+    return llm_config
+
+
+def init(
+    *,
+    force: Annotated[bool, Parameter(name=["-f", "--force"])] = False,
+):
+    """Initialize a new nao project.
+
+    Creates a project folder with a nao_config.yaml configuration file.
+
+    Parameters
+    ----------
+    force : bool
+        Force re-initialization even if the folder already exists.
+    """
+    console.print("\n[bold cyan]🚀 nao project initialization[/bold cyan]\n")
+
+    try:
+        project_name, project_path = setup_project_name(force=force)
+        config = NaoConfig(
+            project_name=project_name,
+            databases=setup_databases(),
+            llm=setup_llm(),
+        )
+        config.save(project_path)
+
+        console.print()
+        console.print(f"[bold green]✓[/bold green] Created project [cyan]{project_name}[/cyan]")
+        console.print(f"[bold green]✓[/bold green] Created [dim]{project_path / 'nao_config.yaml'}[/dim]")
+        console.print()
+        console.print("[bold green]Done![/bold green] Your nao project is ready. 🎉")
+    except InitError as e:
+        console.print(f"[bold red]✗[/bold red] {e}")

nao_core/commands/sync.py

@@ -0,0 +1,150 @@
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+
+from nao_core.config import NaoConfig
+
+console = Console()
+
+
+def get_table_schema_markdown(conn, dataset: str, table: str) -> str:
+    """Generate markdown content describing a table's columns."""
+    try:
+        # Get the table reference and its schema
+        full_table_name = f"{dataset}.{table}"
+        t = conn.table(full_table_name)
+        schema = t.schema()
+
+        lines = [
+            f"# {table}",
+            "",
+            f"**Dataset:** `{dataset}`",
+            "",
+            "## Columns",
+            "",
+            "| Column | Type | Nullable |",
+            "|--------|------|----------|",
+        ]
+
+        for name, dtype in schema.items():
+            nullable = "Yes" if dtype.nullable else "No"
+            lines.append(f"| `{name}` | `{dtype}` | {nullable} |")
+
+        return "\n".join(lines)
+    except Exception as e:
+        return f"# {table}\n\nError fetching schema: {e}"
+
+
+def sync_bigquery(db_config, base_path: Path, progress: Progress) -> tuple[int, int]:
+    """Sync BigQuery database schema to markdown files.
+
+    Returns:
+            Tuple of (datasets_synced, tables_synced)
+    """
+    conn = db_config.connect()
+    db_path = base_path / "bigquery" / db_config.name
+
+    datasets_synced = 0
+    tables_synced = 0
+
+    # Get datasets to sync
+    if db_config.dataset_id:
+        datasets = [db_config.dataset_id]
+    else:
+        datasets = conn.list_databases()
+
+    dataset_task = progress.add_task(
+        f"[dim]{db_config.name}[/dim]",
+        total=len(datasets),
+    )
+
+    for dataset in datasets:
+        dataset_path = db_path / dataset
+        dataset_path.mkdir(parents=True, exist_ok=True)
+        datasets_synced += 1
+
+        # List tables in this dataset
+        try:
+            tables = conn.list_tables(database=dataset)
+        except Exception:
+            progress.update(dataset_task, advance=1)
+            continue
+
+        table_task = progress.add_task(
+            f"  [cyan]{dataset}[/cyan]",
+            total=len(tables),
+        )
+
+        for table in tables:
+            table_path = dataset_path / table
+            table_path.mkdir(parents=True, exist_ok=True)
+
+            columns_md = get_table_schema_markdown(conn, dataset, table)
+            columns_file = table_path / "columns.md"
+            columns_file.write_text(columns_md)
+            tables_synced += 1
+
+            progress.update(table_task, advance=1)
+
+        progress.update(dataset_task, advance=1)
+
+    return datasets_synced, tables_synced
+
+
+def sync(output_dir: str = "databases"):
+    """Sync database schemas to local markdown files.
+
+    Creates a folder structure with table schemas:
+      databases/bigquery/<connection>/<dataset>/<table>/columns.md
+
+    Args:
+            output_dir: Output directory for the database schemas (default: "databases")
+    """
+    console.print("\n[bold cyan]🔄 nao sync[/bold cyan]\n")
+
+    # Load config
+    config = NaoConfig.try_load()
+    if not config:
+        console.print("[bold red]✗[/bold red] No nao_config.yaml found in current directory")
+        console.print("[dim]Run 'nao init' to create a configuration file[/dim]")
+        sys.exit(1)
+
+    console.print(f"[dim]Project:[/dim] {config.project_name}")
+
+    if not config.databases:
+        console.print("[dim]No databases configured[/dim]")
+        return
+
+    base_path = Path(output_dir)
+    total_datasets = 0
+    total_tables = 0
+
+    console.print()
+
+    with Progress(
+        SpinnerColumn(style="dim"),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=30, style="dim", complete_style="cyan", finished_style="green"),
+        TaskProgressColumn(),
+        console=console,
+        transient=False,
+    ) as progress:
+        for db in config.databases:
+            try:
+                if db.type == "bigquery":
+                    datasets, tables = sync_bigquery(db, base_path, progress)
+                    total_datasets += datasets
+                    total_tables += tables
+                else:
+                    console.print(f"[yellow]⚠ Unsupported database type: {db.type}[/yellow]")
+            except Exception as e:
+                console.print(f"[bold red]✗[/bold red] Failed to sync {db.name}: {e}")
+
+    console.print()
+    console.print(
+        f"[green]✓[/green] Synced [bold]{total_tables}[/bold] tables across [bold]{total_datasets}[/bold] datasets"
+    )
+    console.print(f"[dim]  → {base_path.absolute()}[/dim]")
+    console.print()

nao_core/config.py

@@ -1,64 +1,136 @@
 from enum import Enum
 from pathlib import Path
+from typing import Literal
 
+import ibis
 import yaml
-from pydantic import BaseModel, Field
+from ibis import BaseBackend
+from pydantic import BaseModel, Field, model_validator
 
 
 class LLMProvider(str, Enum):
-	"""Supported LLM providers."""
+    """Supported LLM providers."""
 
-	OPENAI = "openai"
+    OPENAI = "openai"
+
+
+class DatabaseType(str, Enum):
+    """Supported database types."""
+
+    BIGQUERY = "bigquery"
+
+
+class BigQueryConfig(BaseModel):
+    """BigQuery-specific configuration."""
+
+    type: Literal["bigquery"] = "bigquery"
+    name: str = Field(description="A friendly name for this connection")
+    project_id: str = Field(description="GCP project ID")
+    dataset_id: str | None = Field(default=None, description="Default BigQuery dataset")
+    credentials_path: str | None = Field(
+        default=None,
+        description="Path to service account JSON file. If not provided, uses Application Default Credentials (ADC)",
+    )
+
+    def connect(self) -> BaseBackend:
+        """Create an Ibis BigQuery connection."""
+        kwargs: dict = {"project_id": self.project_id}
+
+        if self.dataset_id:
+            kwargs["dataset_id"] = self.dataset_id
+
+        if self.credentials_path:
+            from google.oauth2 import service_account
+
+            credentials = service_account.Credentials.from_service_account_file(
+                self.credentials_path,
+                scopes=["https://www.googleapis.com/auth/bigquery"],
+            )
+            kwargs["credentials"] = credentials
+
+        return ibis.bigquery.connect(**kwargs)
+
+
+DatabaseConfig = BigQueryConfig
+
+
+def parse_database_config(data: dict) -> DatabaseConfig:
+    """Parse a database config dict into the appropriate type."""
+    db_type = data.get("type")
+    if db_type == "bigquery":
+        return BigQueryConfig.model_validate(data)
+    else:
+        raise ValueError(f"Unknown database type: {db_type}")
 
 
 class LLMConfig(BaseModel):
-	"""LLM configuration."""
+    """LLM configuration."""
+
+    provider: LLMProvider = Field(description="The LLM provider to use")
+    api_key: str = Field(description="The API key to use")
 
-	model: LLMProvider = Field(description="The LLM provider to use")
-	api_key: str = Field(description="The API key to use")
 
 class NaoConfig(BaseModel):
-	"""nao project configuration."""
-
-	project_name: str = Field(description="The name of the nao project")
-	llm: LLMConfig | None = Field(default=None, description="The LLM configuration")
-
-	
-	def save(self, path: Path) -> None:
-		"""Save the configuration to a YAML file."""
-		config_file = path / "nao_config.yaml"
-		with config_file.open("w") as f:
-			yaml.dump(
-				self.model_dump(mode="json"),
-				f,
-				default_flow_style=False,
-				sort_keys=False,
-				allow_unicode=True,
-			)
-
-	@classmethod
-	def load(cls, path: Path) -> "NaoConfig":
-		"""Load the configuration from a YAML file."""
-		config_file = path / "nao_config.yaml"
-		with config_file.open() as f:
-			data = yaml.safe_load(f)
-		return cls.model_validate(data)
-
-	@classmethod
-	def try_load(cls, path: Path | None = None) -> "NaoConfig | None":
-		"""Try to load config from path, returns None if not found or invalid.
-		
-		Args:
-			path: Directory containing nao_config.yaml. Defaults to current directory.
-		"""
-		if path is None:
-			path = Path.cwd()
-		try:
-			return cls.load(path)
-		except (FileNotFoundError, ValueError, yaml.YAMLError):
-			return None
-
-	@classmethod
-	def json_schema(cls) -> dict:
-		"""Generate JSON schema for the configuration."""
-		return cls.model_json_schema()
+    """nao project configuration."""
+
+    project_name: str = Field(description="The name of the nao project")
+    databases: list[BigQueryConfig] = Field(description="The databases to use")
+    llm: LLMConfig | None = Field(default=None, description="The LLM configuration")
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_databases(cls, data: dict) -> dict:
+        """Parse database configs into their specific types."""
+        if "databases" in data and isinstance(data["databases"], list):
+            data["databases"] = [parse_database_config(db) if isinstance(db, dict) else db for db in data["databases"]]
+        return data
+
+    def save(self, path: Path) -> None:
+        """Save the configuration to a YAML file."""
+        config_file = path / "nao_config.yaml"
+        with config_file.open("w") as f:
+            yaml.dump(
+                self.model_dump(mode="json", by_alias=True),
+                f,
+                default_flow_style=False,
+                sort_keys=False,
+                allow_unicode=True,
+            )
+
+    @classmethod
+    def load(cls, path: Path) -> "NaoConfig":
+        """Load the configuration from a YAML file."""
+        config_file = path / "nao_config.yaml"
+        with config_file.open() as f:
+            data = yaml.safe_load(f)
+        return cls.model_validate(data)
+
+    def get_connection(self, name: str) -> BaseBackend:
+        """Get an Ibis connection by database name."""
+        for db in self.databases:
+            if db.name == name:
+                return db.connect()
+        raise ValueError(f"Database '{name}' not found in configuration")
+
+    def get_all_connections(self) -> dict[str, BaseBackend]:
+        """Get all Ibis connections as a dict keyed by name."""
+        return {db.name: db.connect() for db in self.databases}
+
+    @classmethod
+    def try_load(cls, path: Path | None = None) -> "NaoConfig | None":
+        """Try to load config from path, returns None if not found or invalid.
+
+        Args:
+                path: Directory containing nao_config.yaml. Defaults to current directory.
+        """
+        if path is None:
+            path = Path.cwd()
+        try:
+            return cls.load(path)
+        except (FileNotFoundError, ValueError, yaml.YAMLError):
+            return None
+
+    @classmethod
+    def json_schema(cls) -> dict:
+        """Generate JSON schema for the configuration."""
+        return cls.model_json_schema()

nao_core/main.py

@@ -1,11 +1,13 @@
 from cyclopts import App
 
-from nao_core.commands import chat, init
+from nao_core.commands import chat, debug, init, sync
 
 app = App()
 
 app.command(chat)
+app.command(debug)
 app.command(init)
+app.command(sync)
 
 if __name__ == "__main__":
-	app()
+    app()

nao_core-0.0.11.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: nao-core
+Version: 0.0.11
+Summary: nao Core is your analytics context builder with the best chat interface.
+Project-URL: Homepage, https://getnao.io
+Project-URL: Repository, https://github.com/naolabs/chat
+Author: nao Labs
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,analytics,chat
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: cyclopts>=4.4.4
+Requires-Dist: ibis-framework[bigquery]>=9.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=14.0.0
+Description-Content-Type: text/markdown
+
+# nao CLI
+
+Command-line interface for nao chat.
+
+## Installation
+
+```bash
+pip install nao-core
+```
+
+## Usage
+
+```bash
+nao --help
+Usage: nao COMMAND
+
+╭─ Commands ────────────────────────────────────────────────────────────────╮
+│ chat         Start the nao chat UI.                                       │
+│ init         Initialize a new nao project.                                │
+│ --help (-h)  Display this message and exit.                               │
+│ --version    Display application version.                                 │
+╰───────────────────────────────────────────────────────────────────────────╯
+```
+
+### Initialize a new nao project
+
+```bash
+nao init
+```
+
+This will create a new nao project in the current directory. It will prompt you for a project name and ask you if you want to set up an LLM configuration.
+
+### Start the nao chat UI
+
+```bash
+nao chat
+```
+
+This will start the nao chat UI. It will open the chat interface in your browser at `http://localhost:5005`.
+
+## Development
+
+### Building the package
+
+```bash
+cd cli
+python build.py --help
+Usage: build.py [OPTIONS]
+
+Build and package nao-core CLI.
+
+╭─ Commands ────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --help (-h)  Display this message and exit.                                                               │
+│ --version    Display application version.                                                                 │
+╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Parameters ──────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --force -f --no-force              Force rebuild the server binary [default: False]                       │
+│ --skip-server -s --no-skip-server  Skip server build, only build Python package [default: False]          │
+│ --bump                             Bump version before building (patch, minor, major) [choices: patch,    │
+│                                    minor, major]                                                          │
+╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+This will:
+1. Build the frontend with Vite
+2. Compile the backend with Bun into a standalone binary
+3. Bundle everything into a Python wheel in `dist/`
+
+Options:
+- `--force` / `-f`: Force rebuild the server binary
+- `--skip-server`: Skip server build, only build Python package
+- `--bump`: Bump version before building (patch, minor, major)
+
+### Installing for development
+
+```bash
+cd cli
+pip install -e .
+```
+
+### Publishing to PyPI
+
+```bash
+# Build first
+python build.py
+
+# Publish
+uv publish dist/*
+```
+
+## Architecture
+
+```
+nao chat (CLI command)
+    ↓ spawns
+nao-chat-server (Bun-compiled binary)
+    ↓ serves
+Backend API + Frontend Static Files
+    ↓
+Browser at http://localhost:5005
+```

nao_core-0.0.11.dist-info/RECORD

@@ -0,0 +1,20 @@
+nao_core/__init__.py,sha256=OTB7vGhVCdxrovMSyxjPvmW5myiN0jPFano1PGXh6Dc,46
+nao_core/config.py,sha256=uNZ_q6f6IC3i7e8SFu-CXJhcCboNNm3UjnL4KHpw-cw,4527
+nao_core/main.py,sha256=f00vLL4s2B2kCMa8y3lI56LX3TnUppWzYmqM6eOGomA,205
+nao_core/bin/db.sqlite,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nao_core/bin/nao-chat-server,sha256=zqD16vlL_FKNOrbrRyvaEJGpfwfIOtWgLkvdgfxDP44,63220848
+nao_core/bin/public/favicon.ico,sha256=PRD32mxgMXg0AIFmjErFs66XQ8qaJiqw_NMS-7n0i90,3870
+nao_core/bin/public/index.html,sha256=NTU3lowrcs_NGlGdrPulJb7k9vmfbHTm55HKk9SfVV0,673
+nao_core/bin/public/assets/index-BSxC58nD.js,sha256=KfT52WftnDWjgEEplssDzkzOPgCR_1jaXnczs_Gn3bk,178296
+nao_core/bin/public/assets/index-Dh3br3Ia.js,sha256=UlskObLoJLwNKErNk6DrjrBdsbemOJ9BT16_ejD5234,333150
+nao_core/bin/public/assets/index-heKLHGGE.css,sha256=9tGsJsaCXrJ0-GQptxyrmuQhX4rWcUNLvWmR8n0-5vY,30119
+nao_core/commands/__init__.py,sha256=rFCuUyA9wM4hS6CxCt2M_5W4VysyQXh6HkA_hyRCxPc,207
+nao_core/commands/chat.py,sha256=xhcBfP40IedunfLX73VNDM5VOGBDnqqii4khoVE-imY,4430
+nao_core/commands/debug.py,sha256=Hdtb6_2F-a9Nr-aU_exdnPZY0-Lf9dgV1QX6QxPr9P8,4794
+nao_core/commands/init.py,sha256=lL4Zn8KIhgH2hRTFOBuQIHpiReSeOF517J4s4zBdwEk,5175
+nao_core/commands/sync.py,sha256=P_AHbTwIifmvhvAJuYR3zA9gdBD2QbaONHQArzS4nXc,4654
+nao_core-0.0.11.dist-info/METADATA,sha256=XWK2ujf5mNjTE0aEjG2FYforbf8nE8PI6GtwLtbYiaI,5143
+nao_core-0.0.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nao_core-0.0.11.dist-info/entry_points.txt,sha256=SZakIiNybgS3pl_OEZVLyLSweadeBFoEMBECMoj9czY,42
+nao_core-0.0.11.dist-info/licenses/LICENSE,sha256=rn5YtWB6E5hPQI49tCTNSyqlArWGsB6HzA5FfSbRHRs,1066
+nao_core-0.0.11.dist-info/RECORD,,

nao_core-0.0.9.dist-info/METADATA

@@ -1,93 +0,0 @@
-Metadata-Version: 2.4
-Name: nao-core
-Version: 0.0.9
-Summary: nao Core is your analytics context builder with the best chat interface.
-Project-URL: Homepage, https://github.com/naolabs/chat
-Project-URL: Repository, https://github.com/naolabs/chat
-Author: nao Labs
-License-Expression: MIT
-License-File: LICENSE
-Keywords: ai,analytics,chat
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: cyclopts>=4.4.4
-Requires-Dist: pydantic>=2.10.0
-Requires-Dist: pyyaml>=6.0.0
-Requires-Dist: rich>=14.0.0
-Description-Content-Type: text/markdown
-
-# nao CLI
-
-Command-line interface for nao chat.
-
-## Installation
-
-```bash
-pip install nao-core
-```
-
-## Usage
-
-### Start the chat interface
-
-```bash
-nao chat
-```
-
-This will start the nao chat server and open the web interface in your browser at `http://localhost:5005`.
-
-## Development
-
-### Building the package
-
-```bash
-cd cli
-python build.py
-```
-
-This will:
-1. Build the frontend with Vite
-2. Compile the backend with Bun into a standalone binary
-3. Bundle everything into a Python wheel in `dist/`
-
-Options:
-- `--force` / `-f`: Force rebuild the server binary
-- `--skip-server`: Skip server build, only build Python package
-
-### Installing for development
-
-```bash
-cd cli
-pip install -e .
-```
-
-### Publishing to PyPI
-
-```bash
-# Build first
-python build.py
-
-# Publish
-uv publish dist/*
-```
-
-## Architecture
-
-```
-nao chat (CLI command)
-    ↓ spawns
-nao-chat-server (Bun-compiled binary)
-    ↓ serves
-Backend API + Frontend Static Files
-    ↓
-Browser at http://localhost:5005
-```

nao_core-0.0.9.dist-info/RECORD

@@ -1,18 +0,0 @@
-nao_core/__init__.py,sha256=u4cYroaAmhjQLYOiejO2wTSrfGh4JcAAqucY_38BWw4,46
-nao_core/config.py,sha256=O6H-qnsv6cLeNdyMmI4gBivLk3mlbJGM2xaF6kMgOlE,1644
-nao_core/main.py,sha256=4RbHIM9lZOZoZKAJhibPGUI_ZaE1FaBgN4YDhgF2mpU,152
-nao_core/bin/db.sqlite,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nao_core/bin/nao-chat-server,sha256=zqD16vlL_FKNOrbrRyvaEJGpfwfIOtWgLkvdgfxDP44,63220848
-nao_core/bin/public/favicon.ico,sha256=PRD32mxgMXg0AIFmjErFs66XQ8qaJiqw_NMS-7n0i90,3870
-nao_core/bin/public/index.html,sha256=NTU3lowrcs_NGlGdrPulJb7k9vmfbHTm55HKk9SfVV0,673
-nao_core/bin/public/assets/index-BSxC58nD.js,sha256=KfT52WftnDWjgEEplssDzkzOPgCR_1jaXnczs_Gn3bk,178296
-nao_core/bin/public/assets/index-Dh3br3Ia.js,sha256=UlskObLoJLwNKErNk6DrjrBdsbemOJ9BT16_ejD5234,333150
-nao_core/bin/public/assets/index-heKLHGGE.css,sha256=9tGsJsaCXrJ0-GQptxyrmuQhX4rWcUNLvWmR8n0-5vY,30119
-nao_core/commands/__init__.py,sha256=d6Aq8CSfgpfsFkyT2i7IywC1guB853UH5RYw2MvjelE,109
-nao_core/commands/chat.py,sha256=iuG2R_v3XBg04AEjUDyxSQbOaznRmWWujXe4FNVBKOo,3856
-nao_core/commands/init.py,sha256=howdDyAAZ-Ox3Betmqk6C2TfuUBWEwkEUk-Nm40gcTY,1866
-nao_core-0.0.9.dist-info/METADATA,sha256=6khBkxOY8G745XqHHJwplPtvX721t3oY9Ve1tMRp9dU,1971
-nao_core-0.0.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nao_core-0.0.9.dist-info/entry_points.txt,sha256=SZakIiNybgS3pl_OEZVLyLSweadeBFoEMBECMoj9czY,42
-nao_core-0.0.9.dist-info/licenses/LICENSE,sha256=rn5YtWB6E5hPQI49tCTNSyqlArWGsB6HzA5FfSbRHRs,1066
-nao_core-0.0.9.dist-info/RECORD,,