moltpy 0.1.0__py3-none-any.whl

moltpy/__init__.py

@@ -0,0 +1,4 @@
+"""MoltPy — Interactive CLI tool for generating production-ready FastAPI projects."""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

moltpy/builder.py

@@ -0,0 +1,341 @@
+"""Project builder orchestrates the full generation flow."""
+
+from __future__ import annotations
+
+import py_compile
+import re
+import secrets
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from moltpy.config import ProjectConfig
+from moltpy.registry import ModuleRegistry
+from moltpy.renderer import RenderedFile, TemplateRenderer
+
+console = Console()
+
+
+class ProjectBuilder:
+    """Orchestrates project generation from configuration to rendered output."""
+
+    def __init__(
+        self,
+        config: ProjectConfig,
+        registry: ModuleRegistry | None = None,
+        template_dir: Path | None = None,
+    ) -> None:
+        """Initialize builder with project configuration."""
+        self.config = config
+        self.registry = registry or ModuleRegistry()
+        self.renderer = TemplateRenderer(config, self.registry, template_overrides_dir=template_dir)
+
+    def build(
+        self,
+        target_dir: Path | None = None,
+        force: bool = False,
+        dry_run: bool = False,
+        skip_post_generation: bool = False,
+    ) -> Path:
+        """Build the complete project.
+
+        Args:
+            target_dir: Output directory. Defaults to ./<project_name>
+            force: Overwrite existing non-empty directory.
+            dry_run: Preview files without writing them.
+            skip_post_generation: Skip uv sync, git init, and pre-commit install.
+
+        Returns:
+            Path to the generated project directory.
+        """
+        if target_dir is None:
+            target_dir = Path.cwd() / self.config.name
+
+        # Check for overwrite
+        if target_dir.exists() and any(target_dir.iterdir()) and not force and not dry_run:
+            console.print(
+                f"[red]Error: Directory '{target_dir}' already exists and is not empty.[/red]"
+            )
+            console.print("[dim]Use --force to overwrite.[/dim]")
+            raise ValueError("Target directory already exists")
+
+        # Validate module selection
+        is_valid, conflicts = self.registry.validate_selection(self.config.modules)
+        if not is_valid:
+            for msg in conflicts:
+                console.print(f"[red]Error: {msg}[/red]")
+            raise ValueError("Module selection has conflicts")
+
+        # Resolve modules and run pre-render hooks
+        resolved_modules = self.registry.resolve_dependencies(self.config.modules)
+        context = self.renderer._get_context()
+        for name in resolved_modules:
+            instance = self.registry.get_instance(name)
+            if instance is not None:
+                try:
+                    hook_result = instance.pre_render(context)
+                except Exception as exc:
+                    console.print(
+                        f"[red]Error: Module '{name}' pre_render hook failed: {exc}[/red]"
+                    )
+                    raise ValueError(f"Module '{name}' pre_render hook failed: {exc}") from exc
+                if hook_result is None:
+                    raise ValueError(f"Module '{name}' pre_render returned None")
+                context = hook_result
+
+        if dry_run:
+            # Dry-run: collect files without writing
+            entries = self.renderer.render(target_dir, dry_run=True)
+            self._print_dry_run_table(entries, target_dir)
+            return target_dir
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            # Step 1: Render templates
+            task = progress.add_task("Rendering project templates...", total=None)
+            self.renderer.render(target_dir)
+            progress.update(task, completed=True)
+
+            # Step 2: Validate generated Python syntax
+            progress.update(task, description="Validating generated code...")
+            self._validate_generated_code(target_dir)
+
+            # Step 3: Generate .env file with secure secrets
+            progress.update(task, description="Generating secure .env file...")
+            self._generate_env_file(target_dir)
+
+            # Step 4: Post-generation hooks
+            if not skip_post_generation:
+                if self.config.post_generation.get("uv_sync", False):
+                    progress.update(task, description="Running uv sync...")
+                    self._run_uv_sync(target_dir)
+
+                if self.config.post_generation.get("git_init", False):
+                    progress.update(task, description="Initializing git repository...")
+                    self._run_git_init(target_dir)
+
+                if self.config.post_generation.get("pre_commit_install", False):
+                    progress.update(task, description="Installing pre-commit hooks...")
+                    self._run_pre_commit_install(target_dir)
+
+            # Step 5: Module post-render hooks
+            for name in resolved_modules:
+                instance = self.registry.get_instance(name)
+                if instance is not None:
+                    try:
+                        instance.post_render(target_dir, context)
+                    except Exception as exc:
+                        console.print(
+                            f"[red]Error: Module '{name}' post_render hook failed: {exc}[/red]"
+                        )
+                        raise ValueError(f"Module '{name}' post_render hook failed: {exc}") from exc
+
+        # Summary
+        module_count = len(self.registry.resolve_dependencies(self.config.modules))
+        console.print()
+        console.print(
+            f"[green]✅[/green] Project [bold]{self.config.name}[/bold] created at {target_dir}"
+        )
+        console.print(f"   [dim]{module_count} modules included[/dim]")
+
+        # Operational assets summary
+        assets: list[str] = []
+        if "email" in self.config.modules:
+            assets.append("📧 Email: Responsive HTML templates generated in app/templates/email/")
+        if "observability" in self.config.modules and "docker" in self.config.modules:
+            assets.append(
+                "📊 Metrics: Grafana dashboard configured. Access at http://localhost:3000"
+                " (admin/admin)"
+            )
+        if "openapi" in self.config.modules:
+            client_var = self.config.module_variables.get("openapi", {}).get(
+                "generate_frontend_client", False
+            )
+            if client_var:
+                assets.append(
+                    "🔌 Frontend SDK: Run `make generate-client` to generate TypeScript client"
+                )
+        if "terraform" in self.config.modules:
+            assets.append("☁️  Terraform: Infrastructure configuration generated in terraform/")
+
+        if assets:
+            console.print()
+            console.print("[bold]Operational Assets Included:[/bold]")
+            for asset in assets:
+                console.print(f"   {asset}")
+
+        console.print()
+        console.print("[bold]Next steps:[/bold]")
+        console.print(f"   cd {self.config.name}")
+        if self.config.post_generation.get("uv_sync", False):
+            console.print("   make run-dev")
+        else:
+            console.print("   uv sync")
+            console.print("   make run-dev")
+
+        return target_dir
+
+    def _print_dry_run_table(self, entries: list[RenderedFile], target_dir: Path) -> None:
+        """Print a preview table of files that would be generated."""
+        from moltpy.renderer import RenderedFile
+
+        table = Table(title=f"[bold]Dry Run: {self.config.name}[/bold]")
+        table.add_column("File", style="cyan")
+        table.add_column("Size", justify="right", style="dim")
+        table.add_column("Source", style="green")
+
+        total_size = 0
+        for entry in entries:
+            if isinstance(entry, RenderedFile):
+                rel_path = (
+                    str(entry.path.relative_to(target_dir))
+                    if entry.path.is_relative_to(target_dir)
+                    else str(entry.path)
+                )
+                size_str = (
+                    f"{entry.size:,} B" if entry.size < 1024 else f"{entry.size / 1024:.1f} KB"
+                )
+                table.add_row(rel_path, size_str, entry.source)
+                total_size += entry.size
+
+        console.print()
+        console.print(table)
+        console.print()
+        console.print(f"[dim]{len(entries)} files, {total_size:,} bytes total[/dim]")
+        console.print("[yellow]⚠️  Dry run — no files were written.[/yellow]")
+
+    def _validate_generated_code(self, target_dir: Path) -> None:
+        """Validate syntax of all generated Python files using py_compile.
+
+        Raises:
+            ValueError: If any generated Python file has invalid syntax.
+        """
+        errors: list[str] = []
+        for py_file in target_dir.rglob("*.py"):
+            try:
+                py_compile.compile(str(py_file), doraise=True)
+            except py_compile.PyCompileError as exc:
+                rel = py_file.relative_to(target_dir)
+                errors.append(f"{rel}: {exc}")
+
+        if errors:
+            for msg in errors:
+                console.print(f"[red]Syntax error: {msg}[/red]")
+            raise ValueError(f"Generated code has syntax errors in {len(errors)} file(s)")
+
+    def _run_uv_sync(self, target_dir: Path) -> None:
+        """Run uv sync in the target directory."""
+        import os
+
+        env = os.environ.copy()
+        env.pop("VIRTUAL_ENV", None)
+        env.pop("PYTHONPATH", None)
+
+        try:
+            subprocess.run(
+                ["uv", "sync"],
+                cwd=target_dir,
+                check=True,
+                capture_output=True,
+                env=env,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            console.print("[yellow]Warning: uv sync failed. Run it manually.[/yellow]")
+
+    def _run_git_init(self, target_dir: Path) -> None:
+        """Initialize git repository in the target directory."""
+        try:
+            subprocess.run(
+                ["git", "init"],
+                cwd=target_dir,
+                check=True,
+                capture_output=True,
+            )
+            # Create initial commit
+            subprocess.run(
+                ["git", "add", "."],
+                cwd=target_dir,
+                check=True,
+                capture_output=True,
+            )
+            subprocess.run(
+                ["git", "commit", "-m", "Initial commit from MoltPy"],
+                cwd=target_dir,
+                check=True,
+                capture_output=True,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            console.print("[yellow]Warning: git init failed. Run it manually.[/yellow]")
+
+    def _run_pre_commit_install(self, target_dir: Path) -> None:
+        """Install pre-commit hooks in the target directory."""
+        import os
+
+        env = os.environ.copy()
+        env.pop("VIRTUAL_ENV", None)
+        env.pop("PYTHONPATH", None)
+
+        try:
+            subprocess.run(
+                ["uv", "run", "pre-commit", "install"],
+                cwd=target_dir,
+                check=True,
+                capture_output=True,
+                env=env,
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            console.print("[yellow]Warning: pre-commit install failed. Run it manually.[/yellow]")
+
+    def _generate_env_file(self, target_dir: Path) -> None:
+        """Generate .env file from .env.example with secure random values.
+
+        Reads the rendered .env.example file, replaces placeholder values with
+        cryptographically secure random strings, and writes the result to .env.
+        Never overwrites an existing .env file.
+        """
+        env_path = target_dir / ".env"
+        env_example_path = target_dir / ".env.example"
+
+        # Don't overwrite existing .env
+        if env_path.exists():
+            return
+
+        if not env_example_path.exists():
+            return
+
+        content = env_example_path.read_text()
+
+        # Generate secure values
+        secret_key = secrets.token_hex(64)  # 128 hex characters
+        db_password = secrets.token_urlsafe(24)  # ~32 characters, URL-safe
+
+        # Replace known placeholder patterns with generated values
+        # SECRET_KEY placeholder
+        content = re.sub(
+            r"SECRET_KEY=.*",
+            f"SECRET_KEY={secret_key}",
+            content,
+        )
+
+        # Database password in connection URLs (matches :password@ pattern)
+        content = re.sub(
+            r"(postgresql\+asyncpg://[^:]+:)[^@]+(@)",
+            rf"\g<1>{db_password}\g<2>",
+            content,
+        )
+
+        # Standalone POSTGRES_PASSWORD if present
+        content = re.sub(
+            r"POSTGRES_PASSWORD=.*",
+            f"POSTGRES_PASSWORD={db_password}",
+            content,
+        )
+
+        env_path.write_text(content)
+        console.print(f"[green]✓[/green] Generated .env with secure secrets ({env_path})")