nao-core 0.0.38__py3-none-manylinux2014_aarch64.whl

nao_core/config/databases/postgres.py

@@ -0,0 +1,83 @@
+from typing import Literal
+
+import ibis
+from ibis import BaseBackend
+from pydantic import Field
+from rich.prompt import Prompt
+
+from nao_core.config.exceptions import InitError
+
+from .base import DatabaseConfig, console
+
+
+class PostgresConfig(DatabaseConfig):
+    """PostgreSQL-specific configuration."""
+
+    type: Literal["postgres"] = "postgres"
+    host: str = Field(description="PostgreSQL host")
+    port: int = Field(default=5432, description="PostgreSQL port")
+    database: str = Field(description="Database name")
+    user: str = Field(description="Username")
+    password: str = Field(description="Password")
+    schema_name: str | None = Field(default=None, description="Default schema (optional, uses 'public' if not set)")
+
+    @classmethod
+    def promptConfig(cls) -> "PostgresConfig":
+        """Interactively prompt the user for PostgreSQL configuration."""
+        console.print("\n[bold cyan]PostgreSQL Configuration[/bold cyan]\n")
+
+        name = Prompt.ask("[bold]Connection name[/bold]", default="postgres-prod")
+
+        host = Prompt.ask("[bold]Host[/bold]", default="localhost")
+
+        port = Prompt.ask("[bold]Port[/bold]", default="5432")
+        if not port.isdigit():
+            raise InitError("Port must be a valid integer.")
+
+        database = Prompt.ask("[bold]Database name[/bold]")
+        if not database:
+            raise InitError("Database name cannot be empty.")
+
+        user = Prompt.ask("[bold]Username[/bold]")
+        if not user:
+            raise InitError("Username cannot be empty.")
+
+        password = Prompt.ask("[bold]Password[/bold]", password=True)
+
+        schema_name = Prompt.ask(
+            "[bold]Default schema[/bold] [dim](optional, uses 'public' if empty)[/dim]",
+            default="",
+        )
+
+        return PostgresConfig(
+            name=name,
+            host=host,
+            port=int(port),
+            database=database,
+            user=user,
+            password=password,
+            schema_name=schema_name or None,
+        )
+
+    def connect(self) -> BaseBackend:
+        """Create an Ibis PostgreSQL connection."""
+
+        kwargs: dict = {
+            "host": self.host,
+            "port": self.port,
+            "database": self.database,
+            "user": self.user,
+            "password": self.password,
+        }
+
+        if self.schema_name:
+            kwargs["schema"] = self.schema_name
+
+        return ibis.postgres.connect(
+            **kwargs,
+        )
+
+    def get_database_name(self) -> str:
+        """Get the database name for Postgres."""
+
+        return self.database

nao_core/config/databases/snowflake.py

@@ -0,0 +1,125 @@
+from typing import Literal
+
+import ibis
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+from ibis import BaseBackend
+from pydantic import Field
+from rich.prompt import Confirm, Prompt
+
+from nao_core.config.exceptions import InitError
+
+from .base import DatabaseConfig, console
+
+
+class SnowflakeConfig(DatabaseConfig):
+    """Snowflake-specific configuration."""
+
+    type: Literal["snowflake"] = "snowflake"
+    username: str = Field(description="Snowflake username")
+    account_id: str = Field(description="Snowflake account identifier (e.g., 'xy12345.us-east-1')")
+    password: str | None = Field(default=None, description="Snowflake password")
+    database: str = Field(description="Snowflake database")
+    schema_name: str | None = Field(
+        default=None,
+        validation_alias="schema",
+        serialization_alias="schema",
+        description="Snowflake schema (optional)",
+    )
+    warehouse: str | None = Field(default=None, description="Snowflake warehouse to use (optional)")
+    private_key_path: str | None = Field(
+        default=None,
+        description="Path to private key file for key-pair authentication",
+    )
+    passphrase: str | None = Field(
+        default=None,
+        description="Passphrase for the private key if it is encrypted",
+    )
+
+    @classmethod
+    def promptConfig(cls) -> "SnowflakeConfig":
+        """Interactively prompt the user for Snowflake configuration."""
+        console.print("\n[bold cyan]Snowflake Configuration[/bold cyan]\n")
+
+        name = Prompt.ask("[bold]Connection name[/bold]", default="snowflake-prod")
+
+        username = Prompt.ask("[bold]Snowflake username[/bold]")
+        if not username:
+            raise InitError("Snowflake username cannot be empty.")
+
+        account_id = Prompt.ask("[bold]Snowflake account identifier[/bold]")
+        if not account_id:
+            raise InitError("Snowflake account identifier cannot be empty.")
+
+        database = Prompt.ask("[bold]Snowflake database[/bold]")
+        if not database:
+            raise InitError("Snowflake database cannot be empty.")
+
+        warehouse = Prompt.ask(
+            "[bold]Snowflake warehouse[/bold] [dim](optional, press Enter to skip)[/dim]", default=None
+        )
+
+        schema = Prompt.ask("[bold]Default schema[/bold] [dim](optional, press Enter to skip)[/dim]", default=None)
+
+        key_pair_auth = Confirm.ask("[bold]Use key-pair authentication for authentication?[/bold]", default=False)
+
+        if key_pair_auth:
+            private_key_path = Prompt.ask("[bold]Path to private key file[/bold]")
+            if not private_key_path:
+                raise InitError("Path to private key file cannot be empty.")
+            passphrase = Prompt.ask(
+                "[bold]Passphrase for the private key[/bold] [dim](optional, press Enter to skip)[/dim]",
+                default=None,
+                password=True,
+            )
+        else:
+            password = Prompt.ask("[bold]Snowflake password[/bold]", password=True)
+            if not password:
+                raise InitError("Snowflake password cannot be empty.")
+
+        return SnowflakeConfig(
+            name=name,
+            username=username,
+            password=password if not key_pair_auth else None,
+            account_id=account_id,
+            database=database,
+            warehouse=warehouse,
+            schema_name=schema,
+            private_key_path=private_key_path if key_pair_auth else None,
+            passphrase=passphrase if key_pair_auth else None,
+        )
+
+    def connect(self) -> BaseBackend:
+        """Create an Ibis Snowflake connection."""
+        kwargs: dict = {"user": self.username}
+        kwargs["account"] = self.account_id
+
+        if self.database and self.schema_name:
+            kwargs["database"] = f"{self.database}/{self.schema_name}"
+        elif self.database:
+            kwargs["database"] = self.database
+
+        if self.warehouse:
+            kwargs["warehouse"] = self.warehouse
+
+        if self.private_key_path:
+            with open(self.private_key_path, "rb") as key_file:
+                private_key = serialization.load_pem_private_key(
+                    key_file.read(),
+                    password=self.passphrase.encode() if self.passphrase else None,
+                    backend=default_backend(),
+                )
+                # Convert to DER format which Snowflake expects
+                kwargs["private_key"] = private_key.private_bytes(
+                    encoding=serialization.Encoding.DER,
+                    format=serialization.PrivateFormat.PKCS8,
+                    encryption_algorithm=serialization.NoEncryption(),
+                )
+        kwargs["password"] = self.password
+
+        return ibis.snowflake.connect(**kwargs)
+
+    def get_database_name(self) -> str:
+        """Get the database name for Snowflake."""
+
+        return self.database

nao_core/config/exceptions.py

@@ -0,0 +1,7 @@
+"""Shared exceptions for nao_core."""
+
+
+class InitError(Exception):
+    """Base exception for init command errors."""
+
+    pass

nao_core/config/llm/__init__.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class LLMProvider(str, Enum):
+    """Supported LLM providers."""
+
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    MISTRAL = "mistral"
+    GEMINI = "gemini"
+
+
+class LLMConfig(BaseModel):
+    """LLM configuration."""
+
+    provider: LLMProvider = Field(description="The LLM provider to use")
+    api_key: str = Field(description="The API key to use")

nao_core/config/notion/__init__.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+
+
+class NotionConfig(BaseModel):
+    """Notion configuration."""
+
+    api_key: str = Field(description="The API key to use")
+    pages: list[str] = Field(description="The pages to sync")

nao_core/config/repos/__init__.py

@@ -0,0 +1,3 @@
+from .base import RepoConfig
+
+__all__ = ["RepoConfig"]

nao_core/config/repos/base.py

@@ -0,0 +1,11 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class RepoConfig(BaseModel):
+    """Repository configuration."""
+
+    name: str = Field(description="The name of the repository")
+    url: str = Field(description="The URL of the repository")
+    branch: Optional[str] = Field(default=None, description="The branch of the repository")

nao_core/config/slack/__init__.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+
+class SlackConfig(BaseModel):
+    """Slack configuration."""
+
+    bot_token: str = Field(description="The bot token to use")
+    signing_secret: str = Field(description="The signing secret for verifying requests")
+    post_message_url: str = Field(
+        default="https://slack.com/api/chat.postMessage",
+        description="The Slack API URL for posting messages",
+    )

nao_core/context/__init__.py

@@ -0,0 +1,54 @@
+"""Context provider module for loading nao project context from various sources."""
+
+import os
+from pathlib import Path
+
+from .base import ContextProvider
+from .git import GitContextProvider
+from .local import LocalContextProvider
+
+
+def get_context_provider() -> ContextProvider:
+    """Factory function to create the appropriate context provider based on environment variables.
+
+    Environment variables:
+        NAO_CONTEXT_SOURCE: 'local' (default) or 'git'
+        NAO_DEFAULT_PROJECT_PATH: Target path for context (required)
+
+    For git source:
+        NAO_CONTEXT_GIT_URL: Git repository URL (required)
+        NAO_CONTEXT_GIT_BRANCH: Branch to clone/pull (default: 'main')
+        NAO_CONTEXT_GIT_TOKEN: Auth token for private repos (optional)
+
+    Returns:
+        ContextProvider instance based on configuration
+    """
+    source = os.environ.get("NAO_CONTEXT_SOURCE", "local").lower()
+    target_path = Path(os.environ.get("NAO_DEFAULT_PROJECT_PATH", "/app/context"))
+
+    if source == "git":
+        git_url = os.environ.get("NAO_CONTEXT_GIT_URL")
+        if not git_url:
+            raise ValueError("NAO_CONTEXT_GIT_URL is required when NAO_CONTEXT_SOURCE=git")
+
+        branch = os.environ.get("NAO_CONTEXT_GIT_BRANCH", "main")
+        token = os.environ.get("NAO_CONTEXT_GIT_TOKEN")
+
+        return GitContextProvider(
+            repo_url=git_url,
+            target_path=target_path,
+            branch=branch,
+            token=token,
+        )
+    elif source == "local":
+        return LocalContextProvider(target_path=target_path)
+    else:
+        raise ValueError(f"Unknown NAO_CONTEXT_SOURCE: {source}. Must be 'local' or 'git'")
+
+
+__all__ = [
+    "ContextProvider",
+    "GitContextProvider",
+    "LocalContextProvider",
+    "get_context_provider",
+]

nao_core/context/base.py

@@ -0,0 +1,57 @@
+"""Base class for context providers."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class ContextProvider(ABC):
+    """Abstract base class for context providers.
+
+    A context provider is responsible for loading the nao project context
+    from a source (local filesystem, git repository, etc.) to the target path.
+    """
+
+    def __init__(self, target_path: Path):
+        """Initialize the context provider.
+
+        Args:
+            target_path: The local filesystem path where context should be available.
+        """
+        self.target_path = target_path
+
+    @abstractmethod
+    def init(self) -> None:
+        """Initialize the context.
+
+        This is called on container startup to ensure context is available.
+        For local provider, this validates the path exists.
+        For git provider, this clones or pulls the repository.
+        """
+        pass
+
+    @abstractmethod
+    def refresh(self) -> bool:
+        """Refresh the context from the source.
+
+        Returns:
+            True if context was updated, False if no changes.
+        """
+        pass
+
+    @abstractmethod
+    def is_initialized(self) -> bool:
+        """Check if context has been initialized.
+
+        Returns:
+            True if context is available and ready.
+        """
+        pass
+
+    def validate(self) -> bool:
+        """Validate that the context contains required files.
+
+        Returns:
+            True if nao_config.yaml exists in target path.
+        """
+        config_file = self.target_path / "nao_config.yaml"
+        return config_file.exists()

nao_core/context/git.py

@@ -0,0 +1,177 @@
+"""Git-based context provider."""
+
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+from .base import ContextProvider
+
+console = Console()
+
+
+class GitContextProvider(ContextProvider):
+    """Context provider that clones/pulls from a git repository.
+
+    This provider enables containerized deployments without volume mounts
+    by fetching context from a git repository on startup and refresh.
+    """
+
+    def __init__(
+        self,
+        repo_url: str,
+        target_path: Path,
+        branch: str = "main",
+        token: str | None = None,
+    ):
+        """Initialize the git context provider.
+
+        Args:
+            repo_url: Git repository URL (https:// or git@).
+            target_path: Local path where repo will be cloned.
+            branch: Branch to clone/pull (default: 'main').
+            token: Auth token for private repos (optional).
+        """
+        super().__init__(target_path)
+        self.repo_url = repo_url
+        self.branch = branch
+        self.token = token
+
+    def _get_auth_url(self) -> str:
+        """Inject token into URL for private repos.
+
+        Returns:
+            Repository URL with token if provided, original URL otherwise.
+        """
+        if not self.token:
+            return self.repo_url
+
+        # Handle HTTPS URLs
+        if self.repo_url.startswith("https://"):
+            # https://github.com/org/repo → https://token@github.com/org/repo
+            return self.repo_url.replace("https://", f"https://{self.token}@")
+
+        # For SSH URLs or other formats, return as-is
+        return self.repo_url
+
+    def init(self) -> None:
+        """Clone the repository if not exists, otherwise pull.
+
+        Raises:
+            subprocess.CalledProcessError: If git command fails.
+            ValueError: If cloned repo doesn't contain nao_config.yaml.
+        """
+        if self.is_initialized():
+            console.print(f"[dim]Context already initialized at {self.target_path}[/dim]")
+            self.refresh()
+        else:
+            self._clone()
+
+        if not self.validate():
+            raise ValueError(
+                "nao_config.yaml not found in cloned repository.\n"
+                "Ensure the repository contains a valid nao project at its root."
+            )
+
+    def _clone(self) -> None:
+        """Clone the repository.
+
+        Uses shallow clone (--depth 1) for faster initial setup.
+        """
+        console.print(f"[cyan]Cloning context from {self.repo_url}...[/cyan]")
+
+        # Ensure parent directory exists
+        self.target_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Remove target if it exists but isn't a git repo
+        if self.target_path.exists() and not (self.target_path / ".git").exists():
+            import shutil
+
+            shutil.rmtree(self.target_path)
+
+        cmd = [
+            "git",
+            "clone",
+            "--branch",
+            self.branch,
+            "--depth",
+            "1",
+            "--single-branch",
+            self._get_auth_url(),
+            str(self.target_path),
+        ]
+
+        try:
+            subprocess.run(
+                cmd,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            console.print(f"[green]✓[/green] Context cloned to {self.target_path}")
+        except subprocess.CalledProcessError as e:
+            # Sanitize error message to not expose token
+            error_msg = e.stderr.replace(self.token, "***") if self.token else e.stderr
+            console.print(f"[red]✗[/red] Failed to clone repository: {error_msg}")
+            raise
+
+    def refresh(self) -> bool:
+        """Pull latest changes from the repository.
+
+        Returns:
+            True if changes were pulled, False if already up-to-date.
+
+        Raises:
+            subprocess.CalledProcessError: If git pull fails.
+        """
+        if not self.is_initialized():
+            console.print("[yellow]Context not initialized, running init instead[/yellow]")
+            self.init()
+            return True
+
+        console.print(f"[cyan]Refreshing context from {self.repo_url}...[/cyan]")
+
+        try:
+            # Fetch with the auth URL
+            subprocess.run(
+                ["git", "fetch", self._get_auth_url(), self.branch],
+                cwd=self.target_path,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            # Check if there are changes
+            diff_result = subprocess.run(
+                ["git", "diff", "HEAD..FETCH_HEAD", "--stat"],
+                cwd=self.target_path,
+                capture_output=True,
+                text=True,
+            )
+
+            if diff_result.stdout.strip():
+                # There are changes, do a hard reset to FETCH_HEAD
+                subprocess.run(
+                    ["git", "reset", "--hard", "FETCH_HEAD"],
+                    cwd=self.target_path,
+                    check=True,
+                    capture_output=True,
+                )
+                console.print("[green]✓[/green] Context updated")
+                return True
+            else:
+                console.print("[dim]Context already up-to-date[/dim]")
+                return False
+
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.replace(self.token, "***") if self.token else e.stderr
+            console.print(f"[red]✗[/red] Failed to refresh context: {error_msg}")
+            raise
+
+    def is_initialized(self) -> bool:
+        """Check if repository has been cloned.
+
+        Returns:
+            True if .git directory exists at target path.
+        """
+        return (self.target_path / ".git").exists()

nao_core/context/local.py

@@ -0,0 +1,59 @@
+"""Local filesystem context provider."""
+
+from pathlib import Path
+
+from .base import ContextProvider
+
+
+class LocalContextProvider(ContextProvider):
+    """Context provider for local filesystem.
+
+    This is the default provider that expects context to already exist
+    at the target path (e.g., via Docker volume mount).
+    """
+
+    def __init__(self, target_path: Path):
+        """Initialize the local context provider.
+
+        Args:
+            target_path: Path where context should exist.
+        """
+        super().__init__(target_path)
+
+    def init(self) -> None:
+        """Validate that the local context path exists.
+
+        Raises:
+            FileNotFoundError: If target path does not exist.
+            ValueError: If nao_config.yaml is not found.
+        """
+        if not self.target_path.exists():
+            raise FileNotFoundError(
+                f"Context path does not exist: {self.target_path}\n"
+                "For local mode, ensure the path is mounted as a Docker volume "
+                "or use NAO_CONTEXT_SOURCE=git for git-based context."
+            )
+
+        if not self.validate():
+            raise ValueError(
+                f"nao_config.yaml not found in {self.target_path}\n"
+                "Ensure the context path contains a valid nao project."
+            )
+
+    def refresh(self) -> bool:
+        """Refresh is a no-op for local provider.
+
+        Local context is managed externally (e.g., volume mount updates).
+
+        Returns:
+            False (no refresh performed)
+        """
+        return False
+
+    def is_initialized(self) -> bool:
+        """Check if local context is available.
+
+        Returns:
+            True if target path exists and contains nao_config.yaml.
+        """
+        return self.target_path.exists() and self.validate()

nao_core/main.py

@@ -0,0 +1,13 @@
+from cyclopts import App
+
+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()

nao_core/templates/__init__.py

@@ -0,0 +1,41 @@
+"""Template engine module for nao providers.
+
+This module provides a Jinja2-based templating system that allows users
+to customize the output of sync providers (databases, repos, etc.).
+
+Default templates are stored in this package and can be overridden by
+placing templates with the same name in the project's `templates/` directory.
+
+Additionally, this module supports rendering user Jinja templates in the
+context folder, making the `nao` object available for accessing provider data.
+
+Example user template (docs/report.md.j2):
+    # {{ nao.config.project_name }}
+
+    {{ nao.notion.page('https://notion.so/...').content }}
+"""
+
+from .context import NaoContext, NotionPage, NotionProvider, create_nao_context
+from .engine import TemplateEngine, get_template_engine
+from .render import (
+    TemplateRenderResult,
+    discover_templates,
+    render_all_templates,
+    render_template,
+)
+
+__all__ = [
+    # Engine
+    "TemplateEngine",
+    "get_template_engine",
+    # Context
+    "NaoContext",
+    "NotionPage",
+    "NotionProvider",
+    "create_nao_context",
+    # Render
+    "TemplateRenderResult",
+    "discover_templates",
+    "render_template",
+    "render_all_templates",
+]