nao-core 0.0.38__py3-none-manylinux2014_aarch64.whl

nao_core/commands/init.py

@@ -0,0 +1,358 @@
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated
+
+from cyclopts import Parameter
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from nao_core.config import (
+    AnyDatabaseConfig,
+    BigQueryConfig,
+    DatabaseType,
+    DatabricksConfig,
+    DuckDBConfig,
+    LLMConfig,
+    LLMProvider,
+    NaoConfig,
+    PostgresConfig,
+    SlackConfig,
+    SnowflakeConfig,
+)
+from nao_core.config.exceptions import InitError
+from nao_core.config.repos import RepoConfig
+
+console = Console()
+
+
+class EmptyProjectNameError(InitError):
+    """Raised when project name is empty."""
+
+    def __init__(self):
+        super().__init__("Project name cannot be empty.")
+
+
+class ProjectExistsError(InitError):
+    """Raised when project folder already exists."""
+
+    def __init__(self, project_name: str):
+        self.project_name = project_name
+        super().__init__(f"Folder '{project_name}' already exists.")
+
+
+class EmptyApiKeyError(InitError):
+    """Raised when API key is empty."""
+
+    def __init__(self):
+        super().__init__("API key cannot be empty.")
+
+
+@dataclass
+class CreatedFile:
+    path: Path
+    content: str | None
+
+
+def setup_project_name(force: bool = False) -> tuple[str, Path]:
+    """Setup the project name."""
+    # Check if we're in a directory with an existing nao_config.yaml
+    current_dir = Path.cwd()
+    config_file = current_dir / "nao_config.yaml"
+
+    if config_file.exists():
+        # Load existing config to get project name
+        existing_config = NaoConfig.try_load(current_dir)
+        if existing_config:
+            console.print("\n[bold yellow]Found existing nao_config.yaml[/bold yellow]")
+            console.print(f"[dim]Project: {existing_config.project_name}[/dim]\n")
+
+            if force or Confirm.ask("[bold]Re-initialize this project?[/bold]", default=True):
+                return existing_config.project_name, current_dir
+            else:
+                raise InitError("Initialization cancelled.")
+
+    # Normal flow: prompt for project name
+    project_name = Prompt.ask("[bold]Enter your project name[/bold]")
+
+    if not project_name:
+        raise EmptyProjectNameError()
+
+    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."""
+    return BigQueryConfig.promptConfig()
+
+
+def setup_duckdb() -> DuckDBConfig:
+    """Setup a DuckDB database configuration."""
+    return DuckDBConfig.promptConfig()
+
+
+def setup_databricks() -> DatabricksConfig:
+    """Setup a Databricks database configuration."""
+    return DatabricksConfig.promptConfig()
+
+
+def setup_snowflake() -> SnowflakeConfig:
+    """Setup a Snowflake database configuration."""
+    return SnowflakeConfig.promptConfig()
+
+
+def setup_postgres() -> PostgresConfig:
+    """Setup a PostgreSQL database configuration."""
+    return PostgresConfig.promptConfig()
+
+
+def setup_databases() -> list[AnyDatabaseConfig]:
+    """Setup database configurations."""
+    databases: list[AnyDatabaseConfig] = []
+
+    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]")
+        elif db_type == DatabaseType.POSTGRES.value:
+            db_config = setup_postgres()
+            databases.append(db_config)
+            console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
+
+        elif db_type == DatabaseType.DUCKDB.value:
+            db_config = setup_duckdb()
+            databases.append(db_config)
+            console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
+
+        elif db_type == DatabaseType.DATABRICKS.value:
+            db_config = setup_databricks()
+            databases.append(db_config)
+            console.print(f"\n[bold green]✓[/bold green] Added database [cyan]{db_config.name}[/cyan]")
+
+        elif db_type == DatabaseType.SNOWFLAKE.value:
+            db_config = setup_snowflake()
+            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_repos() -> list[RepoConfig]:
+    """Setup repository configurations."""
+    repos: list[RepoConfig] = []
+    should_setup = Confirm.ask("\n[bold]Set up git repositories?[/bold]", default=True)
+
+    if not should_setup:
+        return repos
+
+    while True:
+        console.print("\n[bold cyan]Git Repository Configuration[/bold cyan]\n")
+        name = Prompt.ask("[bold]Repository name[/bold]")
+        url = Prompt.ask("[bold]Repository URL[/bold]")
+
+        repos.append(RepoConfig(name=name, url=url))
+        console.print(f"\n[bold green]✓[/bold green] Added repository [cyan]{name}[/cyan]")
+
+        add_another = Confirm.ask("\n[bold]Add another repository?[/bold]", default=False)
+        if not add_another:
+            break
+
+    return repos
+
+
+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 setup_slack() -> SlackConfig | None:
+    """Setup the Slack configuration."""
+    slack_config = None
+    should_setup = Confirm.ask("\n[bold]Set up Slack integration?[/bold]", default=False)
+
+    if should_setup:
+        console.print("\n[bold cyan]Slack Configuration[/bold cyan]\n")
+
+        bot_token = Prompt.ask(
+            "[bold]Enter your Slack bot token[/bold]",
+            password=True,
+        )
+
+        if not bot_token:
+            raise InitError("Slack bot token cannot be empty.")
+
+        signing_secret = Prompt.ask(
+            "[bold]Enter your Slack signing secret[/bold]",
+            password=True,
+        )
+
+        if not signing_secret:
+            raise InitError("Slack signing secret cannot be empty.")
+
+        slack_config = SlackConfig(
+            bot_token=bot_token,
+            signing_secret=signing_secret,
+        )
+
+    return slack_config
+
+
+def create_empty_structure(project_path: Path) -> tuple[list[str], list[CreatedFile]]:
+    """Create project folder structure to guide users.
+
+    To add new folders, simply append them to the FOLDERS list below.
+    Each folder will be created automatically (can be empty).
+    """
+    FOLDERS = [
+        "databases",
+        "queries",
+        "docs",
+        "semantics",
+        "repos",
+        "agent/tools",
+        "agent/mcps",
+    ]
+
+    FILES = [
+        CreatedFile(path=Path("RULES.md"), content=None),
+        CreatedFile(path=Path(".naoignore"), content="templates/\n*.j2\n"),
+    ]
+
+    created_folders = []
+    for folder in FOLDERS:
+        folder_path = project_path / folder
+        folder_path.mkdir(parents=True, exist_ok=True)
+        created_folders.append(folder)
+
+    created_files = []
+    for file in FILES:
+        file_path = project_path / file.path
+        if file.content:
+            file_path.write_text(file.content)
+        else:
+            file_path.touch()
+        created_files.append(file)
+
+    return created_folders, created_files
+
+
+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(),
+            repos=setup_repos(),
+            llm=setup_llm(),
+            slack=setup_slack(),
+        )
+        config.save(project_path)
+
+        # Create project folder structure
+        created_folders, created_files = create_empty_structure(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. 🎉")
+
+        is_subfolder = project_path.resolve() != Path.cwd().resolve()
+
+        has_connections = config.databases or config.llm
+        if has_connections:
+            # Change directory for the debug command to run in the right context
+            os.chdir(project_path)
+            from nao_core.commands.debug import debug
+
+            debug()
+
+        console.print()
+
+        cd_instruction = ""
+        if is_subfolder:
+            cd_instruction = f"\n[bold]First, navigate to your project:[/bold]\n[cyan]cd {project_path}[/cyan]\n\n"
+
+        help_content = f"""{cd_instruction}[bold]Available Commands:[/bold]
+
+[cyan]nao debug[/cyan]   - Test connectivity to your configured databases and LLM
+              Verifies that all connections are working properly
+
+[cyan]nao sync[/cyan]    - Sync database schemas to local markdown files
+              Creates documentation for your tables and columns
+
+[cyan]nao chat[/cyan]    - Start the nao chat interface
+              Launch the web UI to chat with your data
+"""
+        console.print(Panel(help_content, border_style="cyan", title="🚀 Get Started", title_align="left"))
+        console.print()
+
+    except InitError as e:
+        console.print(f"[bold red]✗[/bold red] {e}")

nao_core/commands/sync/__init__.py

@@ -0,0 +1,124 @@
+"""Sync command for synchronizing repositories and database schemas."""
+
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from nao_core.config import NaoConfig
+from nao_core.templates.render import render_all_templates
+
+from .providers import SyncProvider, SyncResult, get_all_providers
+
+console = Console()
+
+
+def sync(
+    output_dirs: dict[str, str] | None = None,
+    providers: list[SyncProvider] | None = None,
+    render_templates: bool = True,
+):
+    """Sync resources using configured providers.
+
+    Creates folder structures based on each provider's default output directory:
+      - repos/<repo_name>/         (git repositories)
+      - databases/<type>/<connection>/<dataset>/<table>/*.md  (database schemas)
+
+    After syncing providers, renders any Jinja templates (*.j2 files) found in
+    the project directory, making the `nao` context object available for
+    accessing provider data.
+
+    Args:
+            output_dirs: Optional dict mapping provider names to custom output directories.
+                                     If not specified, uses each provider's default_output_dir.
+            providers: Optional list of providers to use. If not specified, uses all
+                               registered providers.
+            render_templates: Whether to render Jinja templates after syncing providers.
+                                              Defaults to True.
+    """
+    console.print("\n[bold cyan]🔄 nao sync[/bold cyan]\n")
+
+    config = NaoConfig.try_load()
+    if config is None:
+        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)
+    assert config is not None  # Help type checker after sys.exit
+
+    # Get project path (current working directory after NaoConfig.try_load)
+    project_path = Path.cwd()
+
+    console.print(f"[dim]Project:[/dim] {config.project_name}")
+
+    # Use provided providers or default to all registered providers
+    active_providers = providers if providers is not None else get_all_providers()
+    output_dirs = output_dirs or {}
+
+    # Run each provider
+    results: list[SyncResult] = []
+    for provider in active_providers:
+        # Get output directory (custom or default)
+        output_dir = output_dirs.get(provider.name, provider.default_output_dir)
+        output_path = Path(output_dir)
+
+        try:
+            provider.pre_sync(config, output_path)
+
+            if not provider.should_sync(config):
+                continue
+
+            # Get items and sync
+            items = provider.get_items(config)
+            result = provider.sync(items, output_path, project_path=project_path)
+            results.append(result)
+        except Exception as e:
+            # Capture error but continue with other providers
+            results.append(SyncResult.from_error(provider.name, e))
+            console.print(f"  [yellow]⚠[/yellow] {provider.emoji} {provider.name}: [red]{e}[/red]")
+
+    # Render user Jinja templates
+    template_result = None
+    if render_templates:
+        console.print("\n[bold cyan]📝 Rendering templates[/bold cyan]\n")
+        template_result = render_all_templates(project_path, config, console)
+
+    # Separate successful and failed results
+    successful_results = [r for r in results if r.success]
+    failed_results = [r for r in results if not r.success]
+
+    # Print summary with appropriate status
+    if failed_results:
+        if successful_results:
+            console.print("\n[bold yellow]⚠ Sync Completed with Errors[/bold yellow]\n")
+        else:
+            console.print("\n[bold red]✗ Sync Failed[/bold red]\n")
+    else:
+        console.print("\n[bold green]✓ Sync Complete[/bold green]\n")
+
+    has_results = False
+
+    # Show successful syncs
+    for result in successful_results:
+        if result.items_synced > 0:
+            has_results = True
+            console.print(f"  [dim]{result.provider_name}:[/dim] {result.get_summary()}")
+
+    # Show template results
+    if template_result and (template_result.templates_rendered > 0 or template_result.templates_failed > 0):
+        has_results = True
+        console.print(f"  [dim]Templates:[/dim] {template_result.get_summary()}")
+
+    # Show errors section if any
+    if failed_results:
+        has_results = True
+        console.print("\n  [bold red]Errors:[/bold red]")
+        for result in failed_results:
+            console.print(f"    [red]•[/red] {result.provider_name}: {result.error}")
+
+    if not has_results:
+        console.print("  [dim]Nothing to sync[/dim]")
+
+    console.print()
+
+
+__all__ = ["sync"]