vibetuner 2.26.6__py3-none-any.whl

vibetuner/__init__.py

@@ -0,0 +1,2 @@
+# Your code goes here (add your code between this line and the EOF comment)
+# End of file

vibetuner/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app
+
+
+app()

vibetuner/cli/__init__.py

@@ -0,0 +1,141 @@
+# ABOUTME: Core CLI setup with AsyncTyper wrapper and base configuration
+# ABOUTME: Provides main CLI entry point and logging configuration
+import importlib.metadata
+import inspect
+from functools import partial, wraps
+from importlib import import_module
+from pathlib import Path
+from typing import Annotated
+
+import asyncer
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from vibetuner.cli.run import run_app
+from vibetuner.cli.scaffold import scaffold_app
+from vibetuner.logging import LogLevel, logger, setup_logging
+
+
+console = Console()
+
+
+class AsyncTyper(typer.Typer):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("no_args_is_help", True)
+        super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def maybe_run_async(decorator, f):
+        if inspect.iscoroutinefunction(f):
+
+            @wraps(f)
+            def runner(*args, **kwargs):
+                return asyncer.runnify(f)(*args, **kwargs)
+
+            decorator(runner)
+        else:
+            decorator(f)
+        return f
+
+    def callback(self, *args, **kwargs):
+        decorator = super().callback(*args, **kwargs)
+        return partial(self.maybe_run_async, decorator)
+
+    def command(self, *args, **kwargs):
+        decorator = super().command(*args, **kwargs)
+        return partial(self.maybe_run_async, decorator)
+
+
+def _get_app_help():
+    try:
+        from vibetuner.config import settings
+
+        return f"{settings.project.project_name.title()} CLI"
+    except (RuntimeError, ImportError):
+        return "Vibetuner CLI"
+
+
+app = AsyncTyper(help=_get_app_help())
+
+LOG_LEVEL_OPTION = typer.Option(
+    LogLevel.INFO,
+    "--log-level",
+    "-l",
+    case_sensitive=False,
+    help="Set the logging level",
+)
+
+
+@app.callback()
+def callback(log_level: LogLevel | None = LOG_LEVEL_OPTION) -> None:
+    """Initialize logging and other global settings."""
+    setup_logging(level=log_level)
+
+
+@app.command()
+def version(
+    show_app: bool = typer.Option(
+        False,
+        "--app",
+        "-a",
+        help="Show app settings version even if not in a project directory",
+    ),
+) -> None:
+    """Show version information."""
+    try:
+        # Get vibetuner package version
+        vibetuner_version = importlib.metadata.version("vibetuner")
+    except importlib.metadata.PackageNotFoundError:
+        vibetuner_version = "unknown"
+
+    # Create table for nice display
+    table = Table(title="Version Information")
+    table.add_column("Component", style="cyan", no_wrap=True)
+    table.add_column("Version", style="green", no_wrap=True)
+
+    # Always show vibetuner package version
+    table.add_row("vibetuner package", vibetuner_version)
+
+    # Show app version if requested or if in a project
+    try:
+        from vibetuner.config import CoreConfiguration
+
+        settings = CoreConfiguration()
+        table.add_row(f"{settings.project.project_name} settings", settings.version)
+    except Exception:
+        if show_app:
+            table.add_row("app settings", "not in project directory")
+        # else: don't show app version if not in project and not requested
+
+    console.print(table)
+
+
+@app.command()
+def core_template_symlink(
+    target: Annotated[
+        Path,
+        typer.Argument(
+            help="Path where the 'core' symlink should be created or updated",
+        ),
+    ],
+) -> None:
+    """Create or update a 'core' symlink to the package templates directory."""
+    from vibetuner.paths import create_core_templates_symlink
+
+    create_core_templates_symlink(target)
+
+
+app.add_typer(run_app, name="run")
+app.add_typer(scaffold_app, name="scaffold")
+
+try:
+    import_module("app.cli")
+except ModuleNotFoundError:
+    # Silent pass for missing app.cli module (expected in some projects)
+    pass
+except ImportError as e:
+    # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+    logger.warning(
+        f"Failed to import app.cli: {e}. User CLI commands will not be available."
+    )

vibetuner/cli/run.py

@@ -0,0 +1,160 @@
+# ABOUTME: Run commands for starting the application in different modes
+# ABOUTME: Supports dev/prod modes for frontend and worker services
+import os
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+
+console = Console()
+
+run_app = typer.Typer(
+    help="Run the application in different modes", no_args_is_help=True
+)
+
+
+@run_app.command(name="dev")
+def dev(
+    service: Annotated[
+        str, typer.Argument(help="Service to run: 'frontend' or 'worker'")
+    ] = "frontend",
+    port: int = typer.Option(
+        None, help="Port to run on (8000 for frontend, 11111 for worker)"
+    ),
+    host: str = typer.Option("0.0.0.0", help="Host to bind to (frontend only)"),  # noqa: S104
+    workers_count: int = typer.Option(
+        1, "--workers", help="Number of worker processes"
+    ),
+) -> None:
+    """Run in development mode with hot reload (frontend or worker)."""
+    os.environ["DEBUG"] = "1"
+
+    if service == "worker":
+        # Worker mode
+        from streaq.cli import main as streaq_main
+
+        worker_port = port if port else 11111
+        console.print(
+            f"[green]Starting worker in dev mode on port {worker_port}[/green]"
+        )
+        console.print("[dim]Hot reload enabled[/dim]")
+
+        if workers_count > 1:
+            console.print(
+                "[yellow]Warning: Multiple workers not supported in dev mode, using 1[/yellow]"
+            )
+
+        # Call streaq programmatically
+        streaq_main(
+            worker_path="vibetuner.tasks.worker.worker",
+            workers=1,
+            reload=True,
+            verbose=True,
+            web=True,
+            host="0.0.0.0",  # noqa: S104
+            port=worker_port,
+        )
+    elif service == "frontend":
+        # Frontend mode
+        from pathlib import Path
+
+        from granian import Granian
+        from granian.constants import Interfaces
+
+        frontend_port = port if port else 8000
+        console.print(
+            f"[green]Starting frontend in dev mode on {host}:{frontend_port}[/green]"
+        )
+        console.print("[dim]Watching for changes in src/ and templates/[/dim]")
+
+        # Define paths to watch for changes
+        reload_paths = [
+            Path("src/app"),
+            Path("templates/frontend"),
+            Path("templates/email"),
+            Path("templates/markdown"),
+        ]
+
+        server = Granian(
+            target="vibetuner.frontend:app",
+            address=host,
+            port=frontend_port,
+            interface=Interfaces.ASGI,
+            workers=workers_count,
+            reload=True,
+            reload_paths=reload_paths,
+            log_level="info",
+            log_access=True,
+        )
+
+        server.serve()
+    else:
+        console.print(f"[red]Error: Unknown service '{service}'[/red]")
+        console.print("[yellow]Valid services: 'frontend' or 'worker'[/yellow]")
+        raise typer.Exit(code=1)
+
+
+@run_app.command(name="prod")
+def prod(
+    service: Annotated[
+        str, typer.Argument(help="Service to run: 'frontend' or 'worker'")
+    ] = "frontend",
+    port: int = typer.Option(
+        None, help="Port to run on (8000 for frontend, 11111 for worker)"
+    ),
+    host: str = typer.Option("0.0.0.0", help="Host to bind to (frontend only)"),  # noqa: S104
+    workers_count: int = typer.Option(
+        4, "--workers", help="Number of worker processes"
+    ),
+) -> None:
+    """Run in production mode (frontend or worker)."""
+    os.environ["ENVIRONMENT"] = "production"
+
+    if service == "worker":
+        # Worker mode
+        from streaq.cli import main as streaq_main
+
+        worker_port = port if port else 11111
+        console.print(
+            f"[green]Starting worker in prod mode on port {worker_port}[/green]"
+        )
+        console.print(f"[dim]Workers: {workers_count}[/dim]")
+
+        # Call streaq programmatically
+        streaq_main(
+            worker_path="vibetuner.tasks.worker.worker",
+            workers=workers_count,
+            reload=False,
+            verbose=False,
+            web=True,
+            host="0.0.0.0",  # noqa: S104
+            port=worker_port,
+        )
+    elif service == "frontend":
+        # Frontend mode
+        from granian import Granian
+        from granian.constants import Interfaces
+
+        frontend_port = port if port else 8000
+        console.print(
+            f"[green]Starting frontend in prod mode on {host}:{frontend_port}[/green]"
+        )
+        console.print(f"[dim]Workers: {workers_count}[/dim]")
+
+        server = Granian(
+            target="vibetuner.frontend:app",
+            address=host,
+            port=frontend_port,
+            interface=Interfaces.ASGI,
+            workers=workers_count,
+            reload=False,
+            log_level="info",
+            log_access=True,
+        )
+
+        server.serve()
+    else:
+        console.print(f"[red]Error: Unknown service '{service}'[/red]")
+        console.print("[yellow]Valid services: 'frontend' or 'worker'[/yellow]")
+        raise typer.Exit(code=1)

vibetuner/cli/scaffold.py

@@ -0,0 +1,187 @@
+# ABOUTME: Scaffolding commands for creating new projects from the vibetuner template
+# ABOUTME: Uses Copier to generate FastAPI+MongoDB+HTMX projects with interactive prompts
+from pathlib import Path
+from typing import Annotated
+
+import copier
+import typer
+from rich.console import Console
+
+
+console = Console()
+
+scaffold_app = typer.Typer(
+    help="Create new projects from the vibetuner template", no_args_is_help=True
+)
+
+
+@scaffold_app.command(name="new")
+def new(
+    destination: Annotated[
+        Path,
+        typer.Argument(
+            help="Destination directory for the new project",
+            exists=False,
+        ),
+    ],
+    defaults: Annotated[
+        bool,
+        typer.Option(
+            "--defaults",
+            "-d",
+            help="Use default values for all prompts (non-interactive mode)",
+        ),
+    ] = False,
+    data: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--data",
+            help="Override template variables in key=value format (can be used multiple times)",
+        ),
+    ] = None,
+    branch: Annotated[
+        str | None,
+        typer.Option(
+            "--branch",
+            "-b",
+            help="Use specific branch/tag from the vibetuner template repository",
+        ),
+    ] = None,
+) -> None:
+    """Create a new project from the vibetuner template.
+
+    Examples:
+
+        # Interactive mode (prompts for all values)
+        vibetuner scaffold new my-project
+
+        # Use defaults for all prompts
+        vibetuner scaffold new my-project --defaults
+
+        # Override specific values
+        vibetuner scaffold new my-project --data project_name="My App" --data python_version="3.13"
+
+        # Use specific branch for testing
+        vibetuner scaffold new my-project --branch fix/scaffold-command
+    """
+    # Use the official vibetuner template from GitHub
+    template_src = "gh:alltuner/vibetuner"
+    vcs_ref = branch or "main"  # Use specified branch or default to main
+
+    if branch:
+        console.print(
+            f"[dim]Using vibetuner template from GitHub ({branch} branch)[/dim]"
+        )
+    else:
+        console.print("[dim]Using vibetuner template from GitHub (main branch)[/dim]")
+
+    # Parse data overrides
+    data_dict = {}
+    if data:
+        for item in data:
+            if "=" not in item:
+                console.print(
+                    f"[red]Error: Invalid data format '{item}'. Expected key=value[/red]"
+                )
+                raise typer.Exit(code=1)
+            key, value = item.split("=", 1)
+            data_dict[key] = value
+
+    # When using defaults, provide sensible default values for required fields
+    if defaults:
+        default_values = {
+            "company_name": "Acme Corp",
+            "author_name": "Developer",
+            "author_email": "dev@example.com",
+            "supported_languages": [],
+        }
+        # Merge: user overrides take precedence over defaults
+        data_dict = {**default_values, **data_dict}
+
+    # Run copier
+    try:
+        console.print(f"\n[green]Creating new project in: {destination}[/green]\n")
+
+        copier.run_copy(
+            src_path=str(template_src),
+            dst_path=destination,
+            data=data_dict if data_dict else None,
+            defaults=defaults,
+            quiet=defaults,  # Suppress prompts when using defaults
+            unsafe=True,  # Allow running post-generation tasks
+            vcs_ref=vcs_ref,  # Use the specified branch or default to main
+        )
+
+        console.print("\n[green]✓ Project created successfully![/green]")
+        console.print("\nNext steps:")
+        console.print(f"  cd {destination}")
+        console.print("  just dev")
+
+    except Exception as e:
+        console.print(f"[red]Error creating project: {e}[/red]")
+        raise typer.Exit(code=1) from None
+
+
+@scaffold_app.command(name="update")
+def update(
+    path: Annotated[
+        Path | None,
+        typer.Argument(
+            help="Path to the project to update",
+        ),
+    ] = None,
+    skip_answered: Annotated[
+        bool,
+        typer.Option(
+            "--skip-answered",
+            "-s",
+            help="Skip questions that have already been answered",
+        ),
+    ] = True,
+) -> None:
+    """Update an existing project to the latest template version.
+
+    This will update the project's files to match the latest template version,
+    while preserving your answers to the original questions.
+
+    Examples:
+
+        # Update current directory
+        vibetuner scaffold update
+
+        # Update specific directory
+        vibetuner scaffold update /path/to/project
+
+        # Re-prompt for all questions
+        vibetuner scaffold update --no-skip-answered
+    """
+    if path is None:
+        path = Path.cwd()
+
+    if not path.exists():
+        console.print(f"[red]Error: Directory does not exist: {path}[/red]")
+        raise typer.Exit(code=1)
+
+    # Check if it's a copier project
+    answers_file = path / ".copier-answers.yml"
+    if not answers_file.exists():
+        console.print(
+            "[red]Error: Not a copier project (missing .copier-answers.yml)[/red]"
+        )
+        console.print(f"[yellow]Directory: {path}[/yellow]")
+        raise typer.Exit(code=1)
+
+    try:
+        console.print(f"\n[green]Updating project: {path}[/green]\n")
+
+        copier.run_update(
+            dst_path=path,
+            skip_answered=skip_answered,
+            unsafe=True,  # Allow running post-generation tasks
+        )
+
+        console.print("\n[green]✓ Project updated successfully![/green]")
+
+    except Exception as e:
+        console.print(f"[red]Error updating project: {e}[/red]")
+        raise typer.Exit(code=1) from None

vibetuner/config.py

@@ -0,0 +1,143 @@
+import base64
+import hashlib
+from datetime import datetime
+from functools import cached_property
+from typing import Annotated
+
+import yaml
+from pydantic import (
+    UUID4,
+    Field,
+    HttpUrl,
+    MongoDsn,
+    RedisDsn,
+    SecretStr,
+    computed_field,
+)
+from pydantic_extra_types.language_code import LanguageAlpha2
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from vibetuner.logging import logger
+
+from .paths import config_vars as config_vars_path
+from .versioning import version
+
+
+current_year: int = datetime.now().year
+
+
+def _load_project_config() -> "ProjectConfiguration":
+    if config_vars_path is None:
+        raise RuntimeError(
+            "Project root not detected. Cannot load project configuration. "
+            "Ensure you're running from within a project directory with .copier-answers.yml"
+        )
+    if not config_vars_path.exists():
+        return ProjectConfiguration()
+
+    yaml_data = yaml.safe_load(config_vars_path.read_text(encoding="utf-8"))
+    return ProjectConfiguration(**yaml_data)
+
+
+class ProjectConfiguration(BaseSettings):
+    @classmethod
+    def from_project_config(cls) -> "ProjectConfiguration":
+        return _load_project_config()
+
+    project_slug: str = "default_project"
+    project_name: str = "default_project"
+
+    project_description: str = "A default project description."
+
+    # Language Related Settings
+    supported_languages: set[LanguageAlpha2] | None = None
+    default_language: LanguageAlpha2 = LanguageAlpha2("en")
+
+    # AWS Parameters
+    aws_default_region: str = "eu-central-1"
+
+    # Company Name
+    company_name: str = "Acme Corp"
+
+    # From Email for transactional emails
+    from_email: str = "no-reply@example.com"
+
+    # Copyright
+    copyright_start: Annotated[int, Field(strict=True, gt=1714, lt=2048)] = current_year
+
+    # Analytics
+    umami_website_id: UUID4 | None = None
+
+    # Fully Qualified Domain Name
+    fqdn: str | None = None
+
+    @cached_property
+    def languages(self) -> set[str]:
+        if self.supported_languages is None:
+            return {self.language}
+
+        return {
+            str(lang) for lang in (*self.supported_languages, self.default_language)
+        }
+
+    @cached_property
+    def language(self) -> str:
+        return str(self.default_language)
+
+    @cached_property
+    def copyright(self) -> str:
+        year_part = (
+            f"{self.copyright_start}-{current_year}"
+            if self.copyright_start and self.copyright_start != current_year
+            else str(current_year)
+        )
+        return f"© {year_part}{f' {self.company_name}' if self.company_name else ''}"
+
+    model_config = SettingsConfigDict(case_sensitive=False, extra="ignore")
+
+
+class CoreConfiguration(BaseSettings):
+    project: ProjectConfiguration = ProjectConfiguration.from_project_config()
+
+    debug: bool = False
+    version: str = version
+    session_key: SecretStr = SecretStr("ct-!secret-must-change-me")
+
+    # Database and Cache URLs
+    mongodb_url: MongoDsn = MongoDsn("mongodb://localhost:27017")
+    redis_url: RedisDsn = RedisDsn("redis://localhost:6379")
+
+    aws_access_key_id: SecretStr | None = None
+    aws_secret_access_key: SecretStr | None = None
+
+    r2_default_bucket_name: str | None = None
+    r2_bucket_endpoint_url: HttpUrl | None = None
+    r2_access_key: SecretStr | None = None
+    r2_secret_key: SecretStr | None = None
+    r2_default_region: str = "auto"
+
+    @computed_field
+    @cached_property
+    def v_hash(self) -> str:
+        hash_object = hashlib.sha256(self.version.encode("utf-8"))
+        hash_bytes = hash_object.digest()
+
+        b64_hash = base64.urlsafe_b64encode(hash_bytes).decode("utf-8")
+
+        url_safe_hash = b64_hash.rstrip("=")[:8]
+
+        return url_safe_hash
+
+    @cached_property
+    def mongo_dbname(self) -> str:
+        return self.project.project_slug
+
+    model_config = SettingsConfigDict(
+        case_sensitive=False, extra="ignore", env_file=".env"
+    )
+
+
+settings = CoreConfiguration()
+
+
+logger.info("Configuration loaded for project: {}", settings.project.project_name)

vibetuner/context.py

@@ -0,0 +1,28 @@
+from pydantic import UUID4, BaseModel
+
+from vibetuner.config import settings
+
+
+class Context(BaseModel):
+    DEBUG: bool = settings.debug
+
+    project_name: str = settings.project.project_name
+    project_slug: str = settings.project.project_slug
+    project_description: str = settings.project.project_description
+
+    version: str = settings.version
+    v_hash: str = settings.v_hash
+
+    copyright: str = settings.project.copyright
+
+    default_language: str = settings.project.language
+    supported_languages: set[str] = settings.project.languages
+
+    umami_website_id: UUID4 | None = settings.project.umami_website_id
+
+    fqdn: str | None = settings.project.fqdn
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+ctx = Context()