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

scaffold_ca_python/factory/entry_points/ep_mcp.py

@@ -0,0 +1,138 @@
+"""EntryPointMcp factory implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class EntryPointMcp(ModuleFactory):
+    """Factory for MCP entry-point type."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build MCP entry-point files and dependencies.
+
+        Always queues:
+        - src/infrastructure/entry_points/mcp_server/__init__.py
+        - src/infrastructure/entry_points/mcp_server/tools.py
+        - tests/infrastructure/entry_points/mcp_server/test_tools.py
+
+        Conditionally queues (when builder params are True):
+        - resources.py + test_resources.py  (with_resources=True)
+        - prompts.py   + test_prompts.py    (with_prompts=True)
+
+        Injects: mcp>=1.0, uvicorn[standard]>=0.20, starlette>=0.40,
+                 dependency-injector>=4.49.0, pydantic-settings>=2.13.1
+
+        Sets builder params: scripts_entry_fn="main"
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        with_resources: bool = bool(builder.get_param("with_resources", False))
+        with_prompts: bool = bool(builder.get_param("with_prompts", False))
+
+        src_dir = project_root / "src" / pkg / "infrastructure" / "entry_points" / "mcp_server"
+        test_dir = resolve_tests_root(project_root) / "infrastructure" / "entry_points" / "mcp_server"
+
+        base = "entry_point/mcp"
+
+        ctx_dict: dict[str, object] = {}
+        if builder.module_ctx:
+            ctx_dict.update(builder.module_ctx.model_dump())
+
+        # Always-generated files
+        builder.add_file(
+            src_dir / "__init__.py",
+            builder.render(f"{base}/__init__.py.jinja2", ctx_dict),
+            template_name=f"{base}/__init__.py.jinja2",
+        )
+        builder.add_file(
+            src_dir / "tools.py",
+            builder.render(f"{base}/tools.py.jinja2", ctx_dict),
+            template_name=f"{base}/tools.py.jinja2",
+        )
+        builder.add_file(
+            test_dir / "test_tools.py",
+            builder.render(f"{base}/test_tools.py.jinja2", ctx_dict),
+            template_name=f"{base}/test_tools.py.jinja2",
+            is_test=True,
+        )
+
+        # Optional: resources
+        if with_resources:
+            builder.add_file(
+                src_dir / "resources.py",
+                builder.render(f"{base}/resources.py.jinja2", ctx_dict),
+                template_name=f"{base}/resources.py.jinja2",
+            )
+            builder.add_file(
+                test_dir / "test_resources.py",
+                builder.render(f"{base}/test_resources.py.jinja2", ctx_dict),
+                template_name=f"{base}/test_resources.py.jinja2",
+                is_test=True,
+            )
+
+        # Optional: prompts
+        if with_prompts:
+            builder.add_file(
+                src_dir / "prompts.py",
+                builder.render(f"{base}/prompts.py.jinja2", ctx_dict),
+                template_name=f"{base}/prompts.py.jinja2",
+            )
+            builder.add_file(
+                test_dir / "test_prompts.py",
+                builder.render(f"{base}/test_prompts.py.jinja2", ctx_dict),
+                template_name=f"{base}/test_prompts.py.jinja2",
+                is_test=True,
+            )
+
+        # server.py at package root — replaces main.py (Phase 4 / T025)
+        server_path = project_root / "src" / pkg / "server.py"
+        main_py = project_root / "src" / pkg / "main.py"
+        builder.add_file(
+            server_path,
+            builder.render(f"{base}/server.py.jinja2", ctx_dict),
+            template_name=f"{base}/server.py.jinja2",
+            overwrite=True,
+        )
+        builder.delete_file(main_py)
+
+        # config.py — add HOST / PORT for uvicorn via insert_after
+        config_py_path = project_root / "src" / pkg / "application" / "config" / "config.py"
+        builder.insert_after(
+            config_py_path,
+            anchor="LOG_LEVEL",
+            content='    HOST: str = "0.0.0.0"\n    PORT: int = 8000',
+        )
+
+        # app.py composition root (Phase 5 / T031) — no overwrite guard
+        app_py_path = project_root / "src" / pkg / "application" / "app.py"
+        app_ctx: dict[str, object] = {**ctx_dict, "with_resources": with_resources, "with_prompts": with_prompts}
+        builder.add_file(
+            app_py_path,
+            builder.render(f"{base}/app.py.jinja2", app_ctx),
+            template_name=f"{base}/app.py.jinja2",
+        )
+        builder.add_file(
+            test_dir / "test_app.py",
+            builder.render(f"{base}/test_app.py.jinja2", app_ctx),
+            template_name=f"{base}/test_app.py.jinja2",
+            is_test=True,
+        )
+
+        # Dependencies
+        builder.add_dependency("mcp>=1.0")
+        builder.add_dependency("uvicorn[standard]>=0.20")
+        builder.add_dependency("starlette>=0.40")
+        builder.add_dependency("dependency-injector>=4.49.0")
+        builder.add_dependency("pydantic-settings>=2.13.1")
+
+        # Signal to module_builder.persist() to update pyproject.toml scripts
+        builder.add_param("scripts_entry", True)
+        builder.add_param("scripts_entry_fn", "main")

scaffold_ca_python/factory/entry_points/ep_restapi.py

@@ -0,0 +1,133 @@
+"""EntryPointRestApi factory implementation (T015)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class EntryPointRestApi(ModuleFactory):
+    """Factory for REST API entry-point type."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build REST API entry-point files and dependencies.
+
+        Queues files:
+        - src/application/app.py (application factory)
+        - src/infrastructure/entry_points/api/v1/__init__.py
+        - src/infrastructure/entry_points/api/v1/rest_controller.py
+        - src/infrastructure/entry_points/api/v1/exception_handler.py
+        - src/server.py (entrypoint)
+        - tests/application/test_app.py
+        - tests/infrastructure/entry_points/api/v1/test_rest_controller.py
+        - tests/infrastructure/entry_points/api/v1/test_server.py
+        - tests/infrastructure/entry_points/api/v1/test_exception_handler.py
+
+        Deletes:
+        - src/main.py
+
+        Injects:
+        - fastapi[standard]>=0.135.2
+        - uvicorn[standard]>=0.20
+        - dependency-injector>=4.49.0
+        - pydantic-settings>=2.13.1
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        # Setup directory paths
+        src_dir = project_root / "src" / pkg / "infrastructure" / "entry_points" / "api" / "v1"
+        test_dir = resolve_tests_root(project_root) / "infrastructure" / "entry_points" / "api" / "v1"
+        app_py_path = project_root / "src" / pkg / "application" / "app.py"
+        server_path = project_root / "src" / pkg / "server.py"
+        test_app_path = resolve_tests_root(project_root) / "application" / "test_app.py"
+        main_py = project_root / "src" / pkg / "main.py"
+
+        # Template base path for entry_point/restapi
+        base = "entry_point/restapi"
+
+        # Build context dict from module context
+        ctx_dict = (
+            {
+                **builder.module_ctx.model_dump(),
+            }
+            if builder.module_ctx
+            else {}
+        )
+
+        # Add source files
+        def tpl(f: str) -> str:
+            return f"{base}/{f}"
+
+        builder.add_file(
+            app_py_path,
+            builder.render(f"{base}/app.py.jinja2", ctx_dict),
+            template_name=tpl("app.py.jinja2"),
+        )
+        builder.add_file(
+            src_dir / "__init__.py",
+            builder.render(f"{base}/__init__.py.jinja2", ctx_dict),
+            template_name=tpl("__init__.py.jinja2"),
+        )
+        builder.add_file(
+            src_dir / "rest_controller.py",
+            builder.render(f"{base}/rest_controller.py.jinja2", ctx_dict),
+            template_name=tpl("rest_controller.py.jinja2"),
+        )
+        builder.add_file(
+            src_dir / "exception_handler.py",
+            builder.render(f"{base}/exception_handler.py.jinja2", ctx_dict),
+            template_name=tpl("exception_handler.py.jinja2"),
+        )
+        builder.add_file(
+            server_path,
+            builder.render(f"{base}/server.py.jinja2", ctx_dict),
+            template_name=tpl("server.py.jinja2"),
+        )
+
+        # Add test files
+        builder.add_file(
+            test_dir / "test_rest_controller.py",
+            builder.render(f"{base}/test_rest_controller.py.jinja2", ctx_dict),
+            template_name=tpl("test_rest_controller.py.jinja2"),
+            is_test=True,
+        )
+        builder.add_file(
+            test_dir / "test_server.py",
+            builder.render(f"{base}/test_server.py.jinja2", ctx_dict),
+            template_name=tpl("test_server.py.jinja2"),
+            is_test=True,
+        )
+        builder.add_file(
+            test_dir / "test_exception_handler.py",
+            builder.render(f"{base}/test_exception_handler.py.jinja2", ctx_dict),
+            template_name=tpl("test_exception_handler.py.jinja2"),
+            is_test=True,
+        )
+        builder.add_file(
+            test_app_path,
+            builder.render(f"{base}/test_app.py.jinja2", ctx_dict),
+            template_name=tpl("test_app.py.jinja2"),
+            is_test=True,
+        )
+
+        # Delete main.py
+        builder.delete_file(main_py)
+
+        # Add dependencies
+        deps = [
+            "fastapi[standard]>=0.135.2",
+            "uvicorn[standard]>=0.20",
+            "dependency-injector>=4.49.0",
+            "pydantic-settings>=2.13.1",
+        ]
+        for dep in deps:
+            builder.add_dependency(dep)
+
+        # Set scripts param to indicate main.py was removed and scripts need updating
+        builder.add_param("scripts_entry", True)

scaffold_ca_python/factory/simple/delete_module_factory.py

@@ -0,0 +1,85 @@
+"""DeleteModuleFactory implementation (T039)."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.name_utils import to_snake_case
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class DeleteModuleFactory(ModuleFactory):
+    """Factory for module deletion."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build deletion operations for a module.
+
+        Finds and deletes modules across:
+        - domain/model/<snake>.py
+        - domain/usecase/<snake>.py
+        - infrastructure/driven_adapters/<snake>/
+        - infrastructure/entry_points/<snake>/
+        - infrastructure/helpers/<snake>/
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        # Get module name and convert to snake_case
+        module_name = builder.module_ctx.name if builder.module_ctx else "Module"
+        snake_name = to_snake_case(module_name)
+
+        src_root = project_root / "src" / pkg
+        tests_root = resolve_tests_root(project_root)
+
+        # Build list of possible module locations
+        candidates: list[tuple[Path, Path | None]] = []
+
+        # Single-file layers (domain/model, domain/usecase)
+        model_src = src_root / "domain" / "model" / f"{snake_name}.py"
+        model_test = tests_root / "domain" / "model" / f"test_{snake_name}.py"
+        usecase_src = src_root / "domain" / "usecase" / f"{snake_name}.py"
+        usecase_test = tests_root / "domain" / "usecase" / f"test_{snake_name}.py"
+        for src_rel, test_rel in [
+            (model_src, model_test),
+            (usecase_src, usecase_test),
+        ]:
+            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_name,
+                tests_root / "infrastructure" / "driven_adapters" / snake_name,
+            ),
+            (
+                src_root / "infrastructure" / "entry_points" / snake_name,
+                tests_root / "infrastructure" / "entry_points" / snake_name,
+            ),
+            (
+                src_root / "infrastructure" / "helpers" / snake_name,
+                tests_root / "infrastructure" / "helpers" / snake_name,
+            ),
+        ]:
+            if src_rel.exists():
+                candidates.append((src_rel, test_rel if test_rel.exists() else None))
+
+        # Delete all found modules
+        if not builder.dry_run:
+            for src_path, test_path in candidates:
+                if src_path.is_file():
+                    src_path.unlink()
+                elif src_path.is_dir():
+                    shutil.rmtree(src_path)
+
+                if test_path:
+                    if test_path.is_file():
+                        test_path.unlink()
+                    elif test_path.is_dir():
+                        shutil.rmtree(test_path)

scaffold_ca_python/factory/simple/helper_factory.py

@@ -0,0 +1,67 @@
+"""HelperFactory implementation (T037)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.name_utils import to_snake_case
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class HelperFactory(ModuleFactory):
+    """Factory for helper utility generation."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build helper utility files.
+
+        Queues files:
+        - src/infrastructure/helpers/{snake_name}/__init__.py
+        - src/infrastructure/helpers/{snake_name}/{snake_name}.py
+        - tests/infrastructure/helpers/{snake_name}/test_{snake_name}.py
+
+        No dependencies injected.
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        # Get helper name from module context and convert to snake_case
+        helper_name = builder.module_ctx.name if builder.module_ctx else "Helper"
+        snake_name = to_snake_case(helper_name)
+
+        # Setup directory paths
+        src_dir = project_root / "src" / pkg / "infrastructure" / "helpers" / snake_name
+        test_dir = resolve_tests_root(project_root) / "infrastructure" / "helpers" / snake_name
+
+        # Template base path
+        base = "helper"
+
+        # Build context dict from module context
+        ctx_dict = {}
+        if builder.module_ctx:
+            ctx_dict.update(builder.module_ctx.model_dump())
+
+        # Add __init__ file
+        builder.add_file(
+            src_dir / "__init__.py",
+            builder.render(f"{base}/__init__.py.jinja2", ctx_dict),
+            template_name=f"{base}/__init__.py.jinja2",
+        )
+
+        # Add helper implementation file
+        builder.add_file(
+            src_dir / f"{snake_name}.py",
+            builder.render(f"{base}/helper.py.jinja2", ctx_dict),
+            template_name=f"{base}/helper.py.jinja2",
+        )
+
+        # Add test file
+        builder.add_file(
+            test_dir / f"test_{snake_name}.py",
+            builder.render(f"{base}/test_helper.py.jinja2", ctx_dict),
+            template_name=f"{base}/test_helper.py.jinja2",
+            is_test=True,
+        )

scaffold_ca_python/factory/simple/model_factory.py

@@ -0,0 +1,57 @@
+"""ModelFactory implementation (T033)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class ModelFactory(ModuleFactory):
+    """Factory for domain model generation."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build domain model files.
+
+        Queues files:
+        - src/domain/model/{module_name}.py
+        - tests/domain/model/test_{module_name}.py
+
+        No dependencies injected (pydantic is already a project dependency).
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        # Get module name from module context
+        module_name = builder.module_ctx.module_name if builder.module_ctx else "model"
+
+        # Setup directory paths
+        src_dir = project_root / "src" / pkg / "domain" / "model"
+        test_dir = resolve_tests_root(project_root) / "domain" / "model"
+
+        # Template base path
+        base = "model"
+
+        # Build context dict from module context
+        ctx_dict = {}
+        if builder.module_ctx:
+            ctx_dict.update(builder.module_ctx.model_dump())
+
+        # Add source file
+        builder.add_file(
+            src_dir / f"{module_name}.py",
+            builder.render(f"{base}/model.py.jinja2", ctx_dict),
+            template_name=f"{base}/model.py.jinja2",
+        )
+
+        # Add test file
+        builder.add_file(
+            test_dir / f"test_{module_name}.py",
+            builder.render(f"{base}/test_model.py.jinja2", ctx_dict),
+            template_name=f"{base}/test_model.py.jinja2",
+            is_test=True,
+        )

scaffold_ca_python/factory/simple/use_case_factory.py

@@ -0,0 +1,59 @@
+"""UseCaseFactory implementation (T035)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from scaffold_ca_python.core.name_utils import to_snake_case
+from scaffold_ca_python.core.project_detector import resolve_tests_root
+from scaffold_ca_python.factory import ModuleFactory
+
+if TYPE_CHECKING:
+    from scaffold_ca_python.core.module_builder import ModuleBuilder
+
+
+class UseCaseFactory(ModuleFactory):
+    """Factory for domain use case generation."""
+
+    def build(self, builder: ModuleBuilder) -> None:
+        """Build domain use case files.
+
+        Queues files:
+        - src/domain/usecase/{snake_name}.py
+        - tests/domain/usecase/test_{snake_name}.py
+
+        No dependencies injected (async/await are built-in).
+        """
+        project_root = builder.project_root
+        pkg = builder.project_ctx.python_package
+
+        # Get use case name from module context and convert to snake_case
+        usecase_name = builder.module_ctx.name if builder.module_ctx else "UseCase"
+        snake_name = to_snake_case(usecase_name)
+
+        # Setup directory paths
+        src_dir = project_root / "src" / pkg / "domain" / "usecase"
+        test_dir = resolve_tests_root(project_root) / "domain" / "usecase"
+
+        # Template base path
+        base = "use_case"
+
+        # Build context dict from module context
+        ctx_dict = {}
+        if builder.module_ctx:
+            ctx_dict.update(builder.module_ctx.model_dump())
+
+        # Add source file
+        builder.add_file(
+            src_dir / f"{snake_name}.py",
+            builder.render(f"{base}/use_case.py.jinja2", ctx_dict),
+            template_name=f"{base}/use_case.py.jinja2",
+        )
+
+        # Add test file
+        builder.add_file(
+            test_dir / f"test_{snake_name}.py",
+            builder.render(f"{base}/test_use_case.py.jinja2", ctx_dict),
+            template_name=f"{base}/test_use_case.py.jinja2",
+            is_test=True,
+        )

scaffold_ca_python/models/context.py

@@ -0,0 +1,60 @@
+"""ProjectContext and ModuleContext Pydantic v2 models (T014)."""
+
+from pydantic import BaseModel, computed_field, field_validator
+
+from scaffold_ca_python.core.name_utils import NAME_RE, to_kebab_case, to_pascal_case, to_snake_case
+from scaffold_ca_python.models.layer import Layer
+
+
+class ProjectContext(BaseModel):
+    name: str
+
+    @field_validator("name")
+    @classmethod
+    def _validate_name(cls, v: str) -> str:
+        if not NAME_RE.match(v):
+            raise ValueError(
+                f"Project name '{v}' is invalid. "
+                "Use kebab-case (e.g., 'my-project') or snake_case (e.g., 'my_project')."
+            )
+        return v
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def python_package(self) -> str:
+        """Derive the Python import root: snake_case of name."""
+        return to_snake_case(self.name)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def python_package_script(self) -> str:
+        """Derive the Python import root: kebab-case of name."""
+        return to_kebab_case(self.name)
+
+
+class ModuleContext(BaseModel):
+    name: str
+    layer: Layer
+    project: ProjectContext
+    subtype: str | None = None
+
+    @field_validator("name")
+    @classmethod
+    def _validate_name(cls, v: str) -> str:
+        if not NAME_RE.match(v):
+            raise ValueError(
+                f"Module name '{v}' is invalid. Use kebab-case (e.g., 'my-module') or snake_case (e.g., 'my_module')."
+            )
+        return v
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def class_name(self) -> str:
+        """PascalCase class name derived from name."""
+        return to_pascal_case(self.name)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def module_name(self) -> str:
+        """snake_case file name (without .py) derived from name."""
+        return to_snake_case(self.name)

scaffold_ca_python/models/file_operation.py

@@ -0,0 +1,47 @@
+"""GeneratedFile, CreateFile, DeleteFile, InsertAfter, and FileOperation union."""
+
+from pathlib import Path
+from typing import Annotated, Literal
+
+from pydantic import BaseModel
+
+
+class GeneratedFile(BaseModel):
+    path: Path
+    content: str
+    template_name: str
+    is_test: bool = False
+    overwrite: bool = False
+
+
+class CreateFile(BaseModel):
+    kind: Literal["create"] = "create"
+    file: GeneratedFile
+
+
+class DeleteFile(BaseModel):
+    kind: Literal["delete"] = "delete"
+    path: Path
+
+
+class InsertAfter(BaseModel):
+    """Insert *content* into an existing file immediately after *anchor*.
+
+    The *anchor* string is searched literally (first occurrence).  The content
+    is inserted on a new line directly after the line that contains the anchor.
+
+    Raises
+    ------
+    FileNotFoundError
+        When *path* does not exist on disk (real mode only).
+    ValueError
+        When *anchor* is not found in the file (real mode only).
+    """
+
+    kind: Literal["insert_after"] = "insert_after"
+    path: Path
+    anchor: str
+    content: str
+
+
+FileOperation = Annotated[CreateFile | DeleteFile | InsertAfter, "FileOperation"]