scaffold-ca-python 0.1.1__py3-none-any.whl

scaffold_ca_python/commands/generate_pipeline.py

@@ -0,0 +1,158 @@
+"""generate_pipeline: scaffold a CI/CD pipeline configuration file (T069)."""
+
+from __future__ import annotations
+
+import importlib.resources
+import tomllib
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.tree import Tree
+
+from scaffold_ca_python.core.file_writer import FileWriter
+from scaffold_ca_python.core.name_utils import ScaffoldError
+from scaffold_ca_python.core.project_detector import find_project_root
+from scaffold_ca_python.core.template_renderer import TemplateRenderer
+from scaffold_ca_python.models.context import ProjectContext
+from scaffold_ca_python.models.file_operation import CreateFile, FileOperation, GeneratedFile
+
+console = Console()
+renderer = TemplateRenderer()
+writer = FileWriter()
+
+_ALLOWED_PROVIDERS = ("github", "azure")
+
+_GPIPE_HELP = "Scaffold a CI/CD pipeline configuration file. Alias: 'gpipe'"
+_GPIPE_EPILOG = (
+    "Providers:\n\n"
+    "  * github    GitHub Actions (.github/workflows/ci.yml)\n\n"
+    "  * azure     Azure Pipelines (azure-pipelines.yml)\n\n"
+    " ==================================================\n\n"
+    "Note: --provider is required.\n\n"
+    "Examples:\n\n"
+    "  * scaffold gpipe --provider github\n\n"
+    "  * scaffold generate-pipeline --provider azure"
+)
+
+# Module-level option default needed with from __future__ import annotations
+_PROVIDER_DEFAULT: str | None = None
+
+
+def _generate_pipeline_impl(provider: str | None, dry_run: bool) -> None:
+    # --- Validate provider presence ---
+    if not provider:
+        console.print(f"[red]Error:[/red] --provider is required. Choose from: {', '.join(_ALLOWED_PROVIDERS)}.")
+        raise typer.Exit(code=1) from None
+
+    # --- Validate provider value ---
+    if provider not in _ALLOWED_PROVIDERS:
+        console.print(f"[red]Error:[/red] Unknown provider '{provider}'. Allowed: {', '.join(_ALLOWED_PROVIDERS)}.")
+        raise typer.Exit(code=1) from None
+
+    # --- Locate project root ---
+    try:
+        project_root = find_project_root()
+    except ScaffoldError:
+        console.print("[red]Error:[/red] No scaffold-ca-python project found. Run 'scaffold ca' first.")
+        raise typer.Exit(code=1) from None
+
+    project_ctx = _load_project_context(project_root)
+    ctx_dict = project_ctx.model_dump()
+
+    # --- Resolve output path ---
+    if provider == "github":
+        out_path = project_root / ".github" / "workflows" / "ci.yml"
+        template = "pipeline/github/ci.yml.jinja2"
+        display_name = "ci.yml"
+    else:  # azure
+        out_path = project_root / "azure-pipelines.yml"
+        template = "pipeline/azure/azure_pipelines.yml.jinja2"
+        display_name = "azure-pipelines.yml"
+
+    # --- Duplicate guard ---
+    if out_path.exists():
+        console.print(
+            f"[red]Error:[/red] '{display_name}' already exists at "
+            f"'{out_path.relative_to(project_root)}'. Use --force to overwrite.\n"
+            "[dim]Hint:[/dim] Remove the existing file first or choose a different provider."
+        )
+        raise typer.Exit(code=1) from None
+
+    operations: list[FileOperation] = [
+        CreateFile(
+            file=GeneratedFile(
+                path=out_path,
+                content=renderer.render_string(_tmpl(template), ctx_dict),
+                template_name=template,
+            )
+        ),
+    ]
+
+    if dry_run:
+        preview = writer.execute(operations, dry_run=True)
+        tree = Tree(f"[bold]{display_name}[/bold] (dry run)")
+        for p in sorted(preview):
+            tree.add(str(p.relative_to(project_root)))
+        console.print(tree)
+        return
+
+    created = writer.execute(operations, dry_run=False)
+    console.print(f"[green]✓[/green] Pipeline [bold]{display_name}[/bold] created. Created {len(created)} file(s).")
+
+
+def register(app: typer.Typer) -> None:
+    """Register gpipe / generate-pipeline commands onto *app*."""
+
+    @app.command(
+        "generate-pipeline",
+        help=_GPIPE_HELP,
+        epilog=_GPIPE_EPILOG,
+    )
+    @app.command("gpipe", hidden=True, help=_GPIPE_HELP, epilog=_GPIPE_EPILOG)
+    def generate_pipeline(
+        ctx: typer.Context,
+        provider: Annotated[
+            str | None,
+            typer.Option(
+                "--provider",
+                help="Pipeline provider (github, azure).",
+                rich_help_panel="Required",
+            ),
+        ] = None,
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Preview without writing.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Scaffold a CI/CD pipeline file for the specified provider."""
+        if provider is None:
+            typer.echo(ctx.get_help())
+            raise typer.Exit(0)
+        _generate_pipeline_impl(provider, dry_run)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _load_project_context(root: Path) -> ProjectContext:
+    pyproject = root / "pyproject.toml"
+    with pyproject.open("rb") as fh:
+        data = tomllib.load(fh)
+    section = data.get("tool", {}).get("scaffold-ca-python", {})
+    return ProjectContext(
+        name=section.get("name", root.name),
+    )
+
+
+def _tmpl(name: str) -> str:
+    ref = importlib.resources.files("scaffold_ca_python.templates").joinpath(name)
+    return ref.read_text(encoding="utf-8")

scaffold_ca_python/commands/generate_project.py

@@ -0,0 +1,189 @@
+"""generate_project: scaffold a full Clean Architecture project skeleton (T032)."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.tree import Tree
+
+from scaffold_ca_python.core.file_writer import FileWriter
+from scaffold_ca_python.core.name_utils import ScaffoldError, to_snake_case, validate_name
+from scaffold_ca_python.core.template_renderer import TemplateRenderer
+from scaffold_ca_python.models.context import ProjectContext
+from scaffold_ca_python.models.file_operation import CreateFile, FileOperation, GeneratedFile
+
+console = Console()
+renderer = TemplateRenderer()
+writer = FileWriter()
+
+# Layers: (subpath-under-src/<pkg>, label for layer_init.jinja2)
+_LAYER_DIRS: list[tuple[str, str]] = [
+    ("application", "application"),
+    ("domain/model", "domain/model"),
+    ("domain/usecase", "domain/usecase"),
+    ("infrastructure/driven_adapters", "infrastructure/driven-adapters"),
+    ("infrastructure/entry_points", "infrastructure/entry-points"),
+    ("infrastructure/helpers", "infrastructure/helpers"),
+]
+_GCA = "Scaffold a new Clean Architecture project. Alias: 'ca'"
+_GCA_EPILOG = "Examples:\n\n    * scaffold ca --name my-project\n\n  * scaffold clean-architecture --name my_project"
+
+
+def _generate_project_impl(
+    name: str,
+    dry_run: bool,
+) -> None:
+    try:
+        validate_name(name)
+    except ScaffoldError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from None
+
+    python_pkg = to_snake_case(name)
+    target_dir = Path.cwd() / name
+
+    if target_dir.exists():
+        console.print(
+            f"[red]Error:[/red] Directory '{python_pkg}/' already exists. "
+            "Aborting to prevent data loss.\n"
+            "[dim]Hint:[/dim] Choose a different project name or remove the existing directory first."
+        )
+        raise typer.Exit(code=1)
+
+    ctx = ProjectContext(name=name)
+    ctx_dict = ctx.model_dump()
+    ctx_dict["created_at"] = datetime.now(tz=UTC).isoformat()
+
+    operations: list[FileOperation] = []
+
+    # --- Config files at project root ----------------------------------------
+    _add(
+        operations,
+        target_dir / "pyproject.toml",
+        renderer.render_string(_tmpl("project/pyproject_toml.jinja2"), ctx_dict),
+    )
+    _add(operations, target_dir / "README.md", renderer.render_string(_tmpl("project/README.jinja2"), ctx_dict))
+    _add(operations, target_dir / ".gitignore", renderer.render_string(_tmpl("project/gitignore.jinja2"), ctx_dict))
+    _add(operations, target_dir / "mypy.ini", renderer.render_string(_tmpl("project/mypy_ini.jinja2"), ctx_dict))
+    _add(operations, target_dir / "Dockerfile", renderer.render_string(_tmpl("project/dockerfile.jinja2"), ctx_dict))
+    _add(
+        operations, target_dir / ".dockerignore", renderer.render_string(_tmpl("project/dockerignore.jinja2"), ctx_dict)
+    )
+    _add(
+        operations,
+        target_dir / ".python-version",
+        renderer.render_string(_tmpl("project/python_version.jinja2"), ctx_dict),
+    )
+
+    # --- DI config files -----------------------------------------------------
+    _di_cfg = target_dir / "src" / python_pkg / "application" / "config"
+    for _fname in (
+        "__init__.py",
+        "config.py",
+        "resource_container.py",
+        "driven_adapters_container.py",
+        "usecases_container.py",
+        "container.py",
+    ):
+        _add(
+            operations,
+            _di_cfg / _fname,
+            renderer.render_string(_tmpl(f"project/application/config/{_fname}.jinja2"), ctx_dict),
+        )
+
+    # --- src/<pkg>/main.py ---------------------------------------------------
+    _add(
+        operations,
+        target_dir / "src" / python_pkg / "main.py",
+        renderer.render_string(_tmpl("project/main.py.jinja2"), ctx_dict),
+    )
+
+    # --- src/<pkg>/__init__.py ------------------------------------------------
+    _add(operations, target_dir / "src" / python_pkg / "__init__.py", f'"""{name} package."""\n')
+
+    # --- Layer __init__.py stubs ---------------------------------------------
+    for layer_path, layer_label in _LAYER_DIRS:
+        layer_ctx = {**ctx_dict, "layer": layer_label}
+        _add(
+            operations,
+            target_dir / "src" / python_pkg / layer_path / "__init__.py",
+            renderer.render_string(_tmpl("project/layer_init.jinja2"), layer_ctx),
+        )
+
+    # --- tests/__init__.py ---------------------------------------------------
+    _add(operations, target_dir / "src" / "tests" / "__init__.py", "")
+
+    if dry_run:
+        preview = writer.execute(operations, dry_run=True)
+        tree = Tree(f"[bold]{python_pkg}/[/bold] (dry run)")
+        for p in sorted(preview):
+            tree.add(str(p.relative_to(target_dir)))
+        console.print(tree)
+        return
+
+    created = writer.execute(operations, dry_run=False)
+    console.print(
+        f"[green]✓[/green] Project [bold]{python_pkg}/[/bold] created successfully. Created {len(created)} file(s)."
+    )
+
+
+def register(app: typer.Typer) -> None:
+    """Register clean-architecture / ca commands onto *app*."""
+
+    @app.command(
+        "clean-architecture",
+        help=_GCA,
+        epilog=_GCA_EPILOG,
+    )
+    @app.command(
+        "ca",
+        hidden=True,
+        help=_GCA,
+        epilog=_GCA_EPILOG,
+    )
+    def clean_architecture(
+        ctx: typer.Context,
+        name: Annotated[
+            str,
+            typer.Option(
+                "--name",
+                help="Project name (PascalCase or snake_case).",
+                rich_help_panel="Required",
+            ),
+        ] = None,  # type: ignore[assignment]
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Preview files without writing.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Scaffold a complete Clean Architecture Python project."""
+        if name is None:
+            typer.echo(ctx.get_help())
+            raise typer.Exit(0)
+        _generate_project_impl(name, dry_run)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _add(operations: list[FileOperation], path: Path, content: str) -> None:
+    operations.append(CreateFile(file=GeneratedFile(path=path, content=content, template_name="")))
+
+
+def _tmpl(name: str) -> str:
+    """Read a bundled template source string via the renderer's resource loader."""
+    import importlib.resources
+
+    ref = importlib.resources.files("scaffold_ca_python.templates").joinpath(name)
+    return ref.read_text(encoding="utf-8")

scaffold_ca_python/commands/generate_use_case.py

@@ -0,0 +1,136 @@
+"""generate_use_case: scaffold an async use case class and test stub (T035)."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.tree import Tree
+
+from scaffold_ca_python.core.module_builder import ModuleBuilder
+from scaffold_ca_python.core.name_utils import ScaffoldError, to_snake_case, validate_name
+from scaffold_ca_python.core.project_detector import find_project_root
+from scaffold_ca_python.factory import ModuleFactory
+from scaffold_ca_python.factory.simple.use_case_factory import UseCaseFactory
+from scaffold_ca_python.models.context import ModuleContext, ProjectContext
+from scaffold_ca_python.models.layer import Layer
+
+console = Console()
+
+_REGISTRY: dict[str, type[ModuleFactory]] = {
+    "use_case": UseCaseFactory,
+}
+_GUC_HELP = "Scaffold a use case in domain/usecase/. Alias 'guc'."
+_GUC_EPILOG = "Example:\n\n  * scaffold guc --name CreateOrder\n\n  * scaffold generate-use-case --name CreateOrder\n\n"
+
+
+def _generate_use_case_impl(name: str, dry_run: bool) -> None:
+    # --- Validate name ---
+    try:
+        validate_name(name)
+    except ScaffoldError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from None
+
+    # --- Locate project root ---
+    try:
+        project_root = find_project_root()
+    except ScaffoldError:
+        console.print("[red]Error:[/red] No scaffold-ca-python project found. Run 'scaffold ca' first.")
+        raise typer.Exit(code=1) from None
+
+    project_ctx = _load_project_context(project_root)
+    module_ctx = ModuleContext(name=name, layer=Layer.DOMAIN_USECASE, project=project_ctx)
+
+    pkg = project_ctx.python_package
+    snake = to_snake_case(name)
+    src_path = project_root / "src" / pkg / "domain" / "usecase" / f"{snake}.py"
+
+    # --- Duplicate guard ---
+    if src_path.exists():
+        console.print(
+            f"[red]Error:[/red] File '{src_path.relative_to(project_root)}' already exists.\n"
+            "[dim]Hint:[/dim] Choose a different name or remove the existing file first."
+        )
+        raise typer.Exit(code=1) from None
+
+    # --- Create builder and get factory from registry ---
+    builder = ModuleBuilder(
+        project_root=project_root,
+        project_ctx=project_ctx,
+        module_ctx=module_ctx,
+        dry_run=dry_run,
+    )
+
+    # Get factory class and instantiate
+    factory_class = _REGISTRY["use_case"]
+    factory = factory_class()
+
+    # Invoke factory to build via ModuleBuilder
+    factory.build(builder)
+
+    # Persist all operations
+    created = builder.persist()
+
+    # --- Display results ---
+    if dry_run:
+        tree = Tree(f"[bold]{snake}[/bold] (dry run)")
+        for p in sorted(created):
+            tree.add(str(p.relative_to(project_root)))
+        console.print(tree)
+        return
+
+    msg = (
+        f"[green]\u2713[/green] Use case [bold]{module_ctx.class_name}UseCase[/bold] "
+        f"created. Created {len(created)} file(s)."
+    )
+    console.print(msg)
+
+
+def register(app: typer.Typer) -> None:
+    """Register guc / generate-use-case commands onto *app*."""
+
+    @app.command(
+        "generate-use-case",
+        help=_GUC_HELP,
+        epilog=_GUC_EPILOG,
+    )
+    @app.command("guc", hidden=True, help=_GUC_HELP, epilog=_GUC_EPILOG)
+    def generate_use_case(
+        ctx: typer.Context,
+        name: Annotated[
+            str | None, typer.Option("--name", help="Use case name (PascalCase).", rich_help_panel="Required")
+        ] = None,
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Preview without writing.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Scaffold a use case in domain/usecase/."""
+        if name is None:
+            typer.echo(ctx.get_help())
+            raise typer.Exit(0)
+        _generate_use_case_impl(name, dry_run)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _load_project_context(root: Path) -> ProjectContext:
+    pyproject = root / "pyproject.toml"
+    with pyproject.open("rb") as fh:
+        data = tomllib.load(fh)
+    section = data.get("tool", {}).get("scaffold-ca-python", {})
+    return ProjectContext(
+        name=section.get("name", root.name),
+    )

scaffold_ca_python/commands/update_project.py

@@ -0,0 +1,84 @@
+"""update_project: upgrade dependencies via uv (T075)."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from scaffold_ca_python.core.name_utils import ScaffoldError
+from scaffold_ca_python.core.project_detector import find_project_root
+
+console = Console()
+
+_GUP = "Update project dependencies via uv lock --upgrade + uv sync. Alias: 'up'"
+_GUP_EPILOG = "Example:\n\n  * scaffold up --dry-run\n\n  * scaffold update-project --dry-run"
+
+
+def _update_project_impl(dry_run: bool) -> None:
+    # Locate project root
+    try:
+        project_root = find_project_root()
+    except ScaffoldError:
+        console.print("[red]Error:[/red] No scaffold-ca-python project found. Run 'scaffold ca' first.")
+        raise typer.Exit(code=1) from None
+
+    lock_cmd = ["uv", "lock", "--upgrade"]
+    sync_cmd = ["uv", "sync"]
+
+    if dry_run:
+        console.print("Would run:")
+        console.print(f"  {' '.join(lock_cmd)}   (cwd: {project_root})")
+        console.print(f"  {' '.join(sync_cmd)}             (cwd: {project_root})")
+        return
+
+    try:
+        subprocess.run(lock_cmd, check=True, cwd=project_root)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error:[/red] 'uv' is not installed or not on PATH. Install it from https://docs.astral.sh/uv/"
+        )
+        raise typer.Exit(code=1) from None
+    except subprocess.CalledProcessError:
+        console.print("[red]Error:[/red] Dependency lock failed. See output above.")
+        raise typer.Exit(code=2) from None
+
+    try:
+        subprocess.run(sync_cmd, check=True, cwd=project_root)
+    except FileNotFoundError:
+        console.print(
+            "[red]Error:[/red] 'uv' is not installed or not on PATH. Install it from https://docs.astral.sh/uv/"
+        )
+        raise typer.Exit(code=1) from None
+    except subprocess.CalledProcessError:
+        console.print("[red]Error:[/red] Sync failed. See output above.")
+        raise typer.Exit(code=2) from None
+
+    console.print("[green]✓[/green] Locked updated dependencies.")
+    console.print("[green]✓[/green] Synced virtual environment.")
+
+
+def register(app: typer.Typer) -> None:
+    """Register up / update-project commands onto *app*."""
+
+    @app.command(
+        "update-project",
+        help=_GUP,
+        epilog=_GUP_EPILOG,
+    )
+    @app.command("up", hidden=True, help=_GUP, epilog=_GUP_EPILOG)
+    def update_project(
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Preview commands without running.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Update dependencies using uv."""
+        _update_project_impl(dry_run)

scaffold_ca_python/commands/validate_structure.py

@@ -0,0 +1,90 @@
+"""validate_structure: AST-based CA layer import checker (T060)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from scaffold_ca_python.core.name_utils import ScaffoldError
+from scaffold_ca_python.core.project_detector import find_project_root
+from scaffold_ca_python.core.structure_validator import StructureValidator
+
+console = Console()
+_validator = StructureValidator()
+
+_GVS_HELP = "Scan src/ for Clean Architecture import violations. Alias: 'vs'."
+_GVS_EPILOG = "Example:\n\n  * scaffold vs\n\n  * scaffold validate-structure\n"
+
+
+def _validate_structure_impl(dry_run: bool) -> None:
+    try:
+        project_root = find_project_root()
+    except ScaffoldError:
+        console.print("[red]Error:[/red] No scaffold-ca-python project found. Run 'scaffold ca' first.")
+        raise typer.Exit(code=1) from None
+
+    try:
+        report = _validator.validate(project_root)
+    except ScaffoldError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=1) from None
+
+    if report.passed:
+        console.print(f"[green]✓[/green] Validated [bold]{report.files_scanned}[/bold] file(s) — no violations found.")
+        return
+
+    # --- Print violation table ---
+    table = Table(
+        title=f"[red]✗[/red] {len(report.violations)} violation(s) found",
+        show_header=True,
+        header_style="bold",
+    )
+    table.add_column("File", style="cyan", no_wrap=False)
+    table.add_column("Line", style="yellow", justify="right")
+    table.add_column("Import", style="white", no_wrap=False)
+    table.add_column("Hint", style="dim", no_wrap=False)
+
+    for v in report.violations:
+        try:
+            file_str = str(v.source_file.relative_to(project_root))
+        except ValueError:
+            file_str = str(v.source_file)
+
+        table.add_row(
+            file_str,
+            str(v.line_number),
+            v.import_statement,
+            v.resolution_hint,
+        )
+
+    console.print(table)
+
+    if not dry_run:
+        raise typer.Exit(code=1)
+
+
+def register(app: typer.Typer) -> None:
+    """Register vs / validate-structure commands onto *app*."""
+
+    @app.command(
+        "validate-structure",
+        help=_GVS_HELP,
+        epilog=_GVS_EPILOG,
+    )
+    @app.command("vs", hidden=True, help=_GVS_HELP, epilog=_GVS_EPILOG)
+    def validate_structure(
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Print results but always exit 0.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Validate Clean Architecture layer boundaries in the current project."""
+        _validate_structure_impl(dry_run)