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

scaffold_ca_python/__init__.py

@@ -0,0 +1 @@
+

scaffold_ca_python/cli.py

@@ -0,0 +1,39 @@
+import typer
+
+from scaffold_ca_python.commands import (
+    delete_module,
+    generate_driven_adapter,
+    generate_entry_point,
+    generate_helper,
+    generate_model,
+    generate_pipeline,
+    generate_project,
+    generate_use_case,
+    update_project,
+    validate_structure,
+)
+
+app = typer.Typer(
+    name="scaffold-ca-python",
+    help="Scaffold production-ready Clean Architecture Python projects.",
+    add_completion=False,
+    rich_markup_mode="rich",
+)
+
+generate_project.register(app)
+generate_model.register(app)
+generate_use_case.register(app)
+generate_driven_adapter.register(app)
+generate_entry_point.register(app)
+generate_helper.register(app)
+generate_pipeline.register(app)
+delete_module.register(app)
+update_project.register(app)
+validate_structure.register(app)
+
+
+@app.callback(invoke_without_command=True)
+def _main(ctx: typer.Context) -> None:
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)

scaffold_ca_python/commands/delete_module.py

@@ -0,0 +1,216 @@
+"""delete_module: safely remove a previously generated module and its test mirror (T039)."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+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, resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+from scaffold_ca_python.factory.simple.delete_module_factory import DeleteModuleFactory
+from scaffold_ca_python.models.context import ModuleContext, ProjectContext
+from scaffold_ca_python.models.layer import Layer
+
+console = Console()
+
+_REGISTRY: dict[str, type[ModuleFactory]] = {
+    "delete": DeleteModuleFactory,
+}
+
+_DM_HELP = "Delete a previously generated module and its test mirror. Alias 'dm'."
+_DM_EPILOG = "Examples:\n\n  * scaffold dm --name Order\n\n  * scaffold delete-module --name MyAdapter\n\n"
+
+
+# ---------------------------------------------------------------------------
+# Module discovery helpers
+# ---------------------------------------------------------------------------
+
+
+def _find_module_targets(project_root: Path, snake: str) -> list[tuple[Path, Path | None]]:
+    """Return a list of (target_path, test_path_or_None) for all matches of *snake*.
+
+    Searches across:
+      1. domain/model/<snake>.py
+      2. domain/usecase/<snake>.py
+      3. infrastructure/driven_adapters/<snake>/
+      4. infrastructure/entry_points/<snake>/
+      5. infrastructure/helpers/<snake>/
+    """
+    pkg = _get_python_package(project_root)
+    src_root = project_root / "src" / pkg
+    tests_root = resolve_tests_root(project_root)
+
+    candidates: list[tuple[Path, Path | None]] = []
+
+    # Single-file layers (domain/model, domain/usecase)
+    for src_rel, test_rel in [
+        (src_root / "domain" / "model" / f"{snake}.py", tests_root / "domain" / "model" / f"test_{snake}.py"),
+        (src_root / "domain" / "usecase" / f"{snake}.py", tests_root / "domain" / "usecase" / f"test_{snake}.py"),
+    ]:
+        if src_rel.exists():
+            candidates.append((src_rel, test_rel if test_rel.exists() else None))
+
+    # Directory-based layers (infrastructure sub-dirs)
+    for src_rel, test_rel in [
+        (
+            src_root / "infrastructure" / "driven_adapters" / snake,
+            tests_root / "infrastructure" / "driven_adapters" / snake,
+        ),
+        (
+            src_root / "infrastructure" / "entry_points" / snake,
+            tests_root / "infrastructure" / "entry_points" / snake,
+        ),
+        (
+            src_root / "infrastructure" / "helpers" / snake,
+            tests_root / "infrastructure" / "helpers" / snake,
+        ),
+    ]:
+        if src_rel.exists():
+            candidates.append((src_rel, test_rel if test_rel.exists() else None))
+
+    return candidates
+
+
+def _get_python_package(root: Path) -> str:
+    pyproject = root / "pyproject.toml"
+    with pyproject.open("rb") as fh:
+        data = tomllib.load(fh)
+    section = data.get("tool", {}).get("scaffold-ca-python", {})
+    name = section.get("name", root.name)
+    import re
+
+    s = name.replace("-", "_")
+    s = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s)
+    s = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s)
+    return s.lower()
+
+
+# ---------------------------------------------------------------------------
+# Implementation
+# ---------------------------------------------------------------------------
+
+
+def _delete_module_impl(name: str, confirm: bool, 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)
+
+    # Create a placeholder ModuleContext for the factory (layer doesn't matter for delete)
+    module_ctx = ModuleContext(name=name, layer=Layer.HELPERS, project=project_ctx)
+
+    # Find targets
+    snake = to_snake_case(name)
+    targets = _find_module_targets(project_root, snake)
+
+    if not targets:
+        console.print(
+            f"[red]Error:[/red] No module named '{snake}' found in project.\n"
+            "[dim]Hint:[/dim] Check spelling with 'scaffold vs' to list modules."
+        )
+        raise typer.Exit(code=1) from None
+
+    # dry_run OR no --confirm → preview mode only
+    if dry_run or not confirm:
+        console.print("The following files would be deleted:\n")
+        for src_path, test_path in targets:
+            try:
+                display = src_path.relative_to(project_root)
+            except ValueError:
+                display = src_path
+            console.print(f"  {display}")
+            if test_path:
+                try:
+                    display = test_path.relative_to(project_root)
+                except ValueError:
+                    display = test_path
+                console.print(f"  {display}")
+        console.print("\nRun with --confirm to proceed.")
+        return
+
+    # Use factory for deletion (only when confirm=True and not dry_run)
+    builder = ModuleBuilder(
+        project_root=project_root,
+        project_ctx=project_ctx,
+        module_ctx=module_ctx,
+        dry_run=False,
+    )
+
+    factory_class = _REGISTRY["delete"]
+    factory = factory_class()
+    factory.build(builder)
+
+    # Persist deletion
+    builder.persist()
+    console.print(f"[green]✓[/green] Deleted module(s) for [bold]{name}[/bold].")
+
+
+def register(app: typer.Typer) -> None:
+    """Register dm / delete-module command onto *app*."""
+
+    @app.command(
+        "delete-module",
+        help=_DM_HELP,
+        epilog=_DM_EPILOG,
+    )
+    @app.command("dm", hidden=True, help=_DM_HELP, epilog=_DM_EPILOG)
+    def delete_module(
+        ctx: typer.Context,
+        name: Annotated[
+            str | None, typer.Option("--name", help="Module name (PascalCase).", rich_help_panel="Required")
+        ] = None,
+        confirm: Annotated[
+            bool,
+            typer.Option(
+                "--confirm/--no-confirm",
+                help="Skip confirmation dialog and delete immediately.",
+                rich_help_panel="Options",
+            ),
+        ] = False,
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run/--no-dry-run",
+                help="Preview deletion without removing files.",
+                rich_help_panel="Options",
+                show_default=True,
+            ),
+        ] = False,
+    ) -> None:
+        """Delete a module and its test mirror."""
+        if name is None:
+            typer.echo(ctx.get_help())
+            raise typer.Exit(0)
+        _delete_module_impl(name, confirm, 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/generate_driven_adapter.py

@@ -0,0 +1,182 @@
+"""generate_driven_adapter: scaffold a driven adapter and test stub (T030)."""
+
+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.driven_adapters.da_generic import DrivenAdapterGeneric
+from scaffold_ca_python.factory.driven_adapters.da_rest_consumer import DrivenAdapterRestConsumer
+from scaffold_ca_python.factory.driven_adapters.da_secrets import DrivenAdapterSecrets
+from scaffold_ca_python.models.context import ModuleContext, ProjectContext
+from scaffold_ca_python.models.layer import Layer
+
+console = Console()
+
+_REGISTRY: dict[str, type[ModuleFactory]] = {
+    "rest-consumer": DrivenAdapterRestConsumer,
+    "secrets": DrivenAdapterSecrets,
+    "generic": DrivenAdapterGeneric,
+}
+
+_GDA_HELP = "Scaffold a driven adapter and test stub. Alias 'gda'."
+_GDA_EPILOG = (
+    "Types:\n\n"
+    "  * rest-consumer    HTTP outbound client (httpx)\n\n"
+    "  * secrets          AWS Secrets Manager (boto3)\n\n"
+    "  * generic          Custom adapter (--name required)\n\n"
+    " ==================================================\n\n"
+    "Examples:\n\n"
+    "  * scaffold gda --type rest-consumer\n\n"
+    "  * scaffold generate-driven-adapter --type generic --name MyAdapter\n\n"
+)
+
+
+def _generate_driven_adapter_impl(type_: str, name: str | None, dry_run: bool) -> None:  # noqa: ANN001
+    # --- Validate type ---
+    if type_ not in _REGISTRY:
+        console.print(f"[red]Error:[/red] Unknown type '{type_}'. Allowed: {', '.join(_REGISTRY.keys())}.")
+        raise typer.Exit(code=1) from None
+
+    # --- Validate name requirement for generic ---
+    if type_ == "generic" and not name:
+        console.print("[red]Error:[/red] --name is required when --type is generic.")
+        raise typer.Exit(code=1) from None
+
+    # --- Validate name if provided ---
+    if 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)
+
+    # --- Determine module context and subdir from type/name ---
+    if type_ == "rest-consumer":
+        subdir = "rest_consumer"
+        module_ctx = ModuleContext(name="rest_consumer", layer=Layer.DRIVEN_ADAPTERS, project=project_ctx)
+    elif type_ == "secrets":
+        subdir = "secrets"
+        module_ctx = ModuleContext(name="secrets", layer=Layer.DRIVEN_ADAPTERS, project=project_ctx)
+    else:  # generic
+        assert name is not None  # validated above
+        subdir = to_snake_case(name)
+        module_ctx = ModuleContext(name=name, layer=Layer.DRIVEN_ADAPTERS, project=project_ctx)
+
+    pkg = project_ctx.python_package
+    src_dir = project_root / "src" / pkg / "infrastructure" / "driven_adapters" / subdir
+
+    # --- Duplicate guard ---
+    if src_dir.exists():
+        console.print(
+            f"[red]Error:[/red] Directory '{src_dir.relative_to(project_root)}/' already exists.\n"
+            "[dim]Hint:[/dim] Choose a different name or remove the existing directory 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[type_]
+    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]{subdir}[/bold] (dry run)")
+        for p in sorted(created):
+            tree.add(str(p.relative_to(project_root)))
+        console.print(tree)
+        if builder._dependencies:
+            console.print(f"[dim]Would add to [project.dependencies]: {', '.join(builder._dependencies)}[/dim]")
+        return
+
+    console.print(f"[green]✓[/green] Driven adapter [bold]{subdir}[/bold] created. Created {len(created)} file(s).")
+
+
+def register(app: typer.Typer) -> None:
+    """Register gda / generate-driven-adapter commands onto *app*."""
+
+    @app.command(
+        "generate-driven-adapter",
+        help=_GDA_HELP,
+        epilog=_GDA_EPILOG,
+    )
+    @app.command("gda", hidden=True, help=_GDA_HELP, epilog=_GDA_EPILOG)
+    def generate_driven_adapter(
+        ctx: typer.Context,
+        type_: Annotated[
+            str | None,
+            typer.Option(
+                "--type",
+                help="Adapter type: rest-consumer, secrets, generic.",
+                rich_help_panel="Required",
+            ),
+        ] = None,
+        name: Annotated[
+            str | None,
+            typer.Option(
+                "--name",
+                help="Adapter name (required for --type generic).",
+                rich_help_panel="Options",
+            ),
+        ] = 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 driven adapter inside infrastructure/driven_adapters/."""
+        if type_ is None:
+            typer.echo(ctx.get_help())
+            raise typer.Exit(0)
+        _generate_driven_adapter_impl(type_, 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),
+    )