forgepy-cli 1.0.0__py3-none-any.whl

cli/commands/create_command.py

@@ -0,0 +1,161 @@
+"""
+==================================================
+ForgePy
+Module  : Create Command
+==================================================
+"""
+
+import subprocess
+from argparse import ArgumentParser, Namespace
+
+from cli.command import Command
+from config.user_config import ConfigStore, ForgePyConfigError
+from core.project_generator import (
+    ProjectGenerator,
+    ProjectPreflightError,
+    UnknownProjectTemplateError,
+)
+
+
+class CreateCommand(Command):
+    """
+    Membuat project baru melalui ProjectGenerator.
+    """
+
+    name = "create"
+    summary = "Create a new Python project."
+    description = (
+        "Create a Python project from a registered ForgePy template. "
+        "ForgePy prompts for an omitted project name and resolves omitted "
+        "location or template values from user configuration before using "
+        "the existing interactive or basic fallback."
+    )
+
+    def __init__(
+        self,
+        store: ConfigStore | None = None,
+    ) -> None:
+        self._store = store
+
+    def configure_parser(
+        self,
+        parser: ArgumentParser,
+    ) -> None:
+        parser.add_argument(
+            "project_name",
+            nargs="?",
+            metavar="PROJECT_NAME",
+            help=(
+                "Name of the project to create. "
+                "ForgePy prompts for it when omitted."
+            ),
+        )
+
+        parser.add_argument(
+            "--location",
+            "-l",
+            metavar="PATH",
+            help=(
+                "Existing parent directory for the new project. "
+                "When omitted, ForgePy uses configured default_location "
+                "before prompting."
+            ),
+        )
+
+        parser.add_argument(
+            "--template",
+            "-t",
+            metavar="NAME",
+            help=(
+                "Registered project template to use. When omitted, "
+                "ForgePy uses configured default_template, then basic."
+            ),
+        )
+
+    def execute(self, args: Namespace) -> int:
+        location = getattr(
+            args,
+            "location",
+            None,
+        )
+        template_name = getattr(
+            args,
+            "template",
+            None,
+        )
+
+        user_config: dict[str, str] = {}
+
+        if location is None or template_name is None:
+            try:
+                user_config = self._get_store().load()
+            except ForgePyConfigError as error:
+                print(f"[ERROR] {error}")
+                print(
+                    "[INFO] Run 'python main.py config reset' or supply "
+                    "both --location and --template explicitly."
+                )
+                return 1
+
+        project_name = getattr(
+            args,
+            "project_name",
+            None,
+        )
+
+        if not project_name:
+            project_name = input(
+                "Project Name : "
+            ).strip()
+
+        if location is None:
+            location = user_config[
+                "default_location"
+            ]
+
+        if not location:
+            location = input(
+                "Location : "
+            ).strip()
+
+        if template_name is None:
+            template_name = user_config[
+                "default_template"
+            ]
+
+        template_name = template_name or "basic"
+
+        if not project_name:
+            print("[ERROR] Nama project tidak boleh kosong.")
+            return 1
+
+        if not location:
+            print("[ERROR] Lokasi project tidak boleh kosong.")
+            return 1
+
+        generator = ProjectGenerator()
+
+        try:
+            generator.create(
+                project_name=project_name,
+                location=location,
+                template_name=template_name,
+            )
+        except UnknownProjectTemplateError:
+            print(f"[ERROR] Unknown project template: '{template_name}'.")
+            return 1
+        except (
+            ProjectPreflightError,
+            OSError,
+            subprocess.SubprocessError,
+        ) as error:
+            print(f"[ERROR] Project creation failed: {error}")
+            return 1
+
+        return 0
+
+    def _get_store(self) -> ConfigStore:
+        if self._store is None:
+            self._store = ConfigStore()
+
+        return self._store

cli/commands/list_command.py

@@ -0,0 +1,40 @@
+"""
+==================================================
+ForgePy
+Module  : List Command
+==================================================
+"""
+
+from argparse import Namespace
+
+from cli.command import Command
+from templates.template_engine.template_registry import TemplateRegistry
+
+
+class ListCommand(Command):
+    """
+    Menampilkan seluruh template yang tersedia.
+    """
+
+    name = "list"
+    summary = "List registered project templates."
+    description = "List every project template currently registered in ForgePy."
+
+    def execute(self, args: Namespace) -> int:
+        del args
+
+        registry = TemplateRegistry()
+        template_metadata = registry.list_metadata()
+
+        print("=" * 40)
+        print(" ForgePy Templates ")
+        print("=" * 40)
+
+        if not template_metadata:
+            print("Belum ada template yang terdaftar.")
+            return 0
+
+        for metadata in template_metadata:
+            print(f"- {metadata.name}: {metadata.description}")
+
+        return 0

cli/commands/version_command.py

@@ -0,0 +1,29 @@
+"""
+==================================================
+ForgePy
+Module  : Version Command
+==================================================
+"""
+
+import platform
+from argparse import Namespace
+
+from cli.command import Command
+from config.version import APP_NAME, VERSION
+
+
+class VersionCommand(Command):
+    """
+    Menampilkan informasi versi ForgePy.
+    """
+
+    name = "version"
+    summary = "Show ForgePy and Python version information."
+    description = "Show the configured ForgePy version and active Python version."
+
+    def execute(self, args: Namespace) -> int:
+        del args
+
+        print(f"{APP_NAME} v{VERSION}")
+        print(f"Python {platform.python_version()}")
+        return 0

cli/dispatcher.py

@@ -0,0 +1,61 @@
+"""
+==================================================
+ForgePy
+Module  : CLI Dispatcher
+==================================================
+"""
+
+from argparse import Namespace
+from collections.abc import Iterable
+
+from cli.command import Command
+from cli.commands import DEFAULT_COMMAND, create_commands
+
+
+class Dispatcher:
+    """
+    Meneruskan argumen CLI ke command yang sesuai.
+    """
+
+    def __init__(
+        self,
+        commands: Iterable[Command] | None = None,
+    ) -> None:
+        registered_commands = tuple(
+            create_commands()
+            if commands is None
+            else commands
+        )
+
+        for command in registered_commands:
+            command.validate_registration()
+
+        self.commands: dict[str, Command] = {
+            command.name: command
+            for command in registered_commands
+        }
+
+        if len(self.commands) != len(registered_commands):
+            raise ValueError("Nama command harus unik.")
+
+        if DEFAULT_COMMAND not in self.commands:
+            raise ValueError(
+                f"Default command '{DEFAULT_COMMAND}' belum terdaftar."
+            )
+
+    def dispatch(self, args: Namespace) -> int:
+        # Menjaga kompatibilitas:
+        # `python main.py` langsung membuka wizard create.
+        command_name = getattr(
+            args,
+            "command",
+            None,
+        ) or DEFAULT_COMMAND
+
+        command = self.commands.get(command_name)
+
+        if command is None:
+            print(f"[ERROR] Command tidak dikenal: {command_name}")
+            return 1
+
+        return command.execute(args)

cli/parser.py

@@ -0,0 +1,84 @@
+"""
+==================================================
+ForgePy
+Module  : CLI Parser
+==================================================
+"""
+
+import argparse
+from argparse import Namespace
+from collections.abc import Iterable
+
+from cli.command import Command
+from cli.commands import create_commands
+
+
+class Parser:
+    """
+    Membaca command dan argumen dari terminal.
+    """
+
+    def __init__(
+        self,
+        commands: Iterable[Command] | None = None,
+    ) -> None:
+        self.commands = tuple(
+            create_commands()
+            if commands is None
+            else commands
+        )
+
+        self.parser = argparse.ArgumentParser(
+            prog="forgepy",
+            description=(
+                "Create structured Python projects and prepare their "
+                "development tooling with ForgePy."
+            ),
+            epilog=(
+                "Run 'python main.py COMMAND --help' for command-specific "
+                "usage from this repository."
+            ),
+        )
+
+        # Default untuk mode interaktif:
+        # python main.py
+        self.parser.set_defaults(
+            project_name=None,
+            location=None,
+            template=None,
+        )
+
+        self._register_commands()
+
+    def _register_commands(self) -> None:
+        subparsers = self.parser.add_subparsers(
+            dest="command",
+            title="commands",
+            description="Available ForgePy commands",
+            metavar="COMMAND",
+        )
+
+        for command in self.commands:
+            command.validate_registration()
+
+            command_parser = subparsers.add_parser(
+                command.name,
+                help=command.summary,
+                description=command.description,
+            )
+
+            command.configure_parser(command_parser)
+
+    def parse(self) -> Namespace:
+        """
+        Membaca argumen dari terminal.
+        """
+
+        return self.parser.parse_args()
+
+    def show_help(self) -> None:
+        """
+        Menampilkan halaman bantuan.
+        """
+
+        self.parser.print_help()

components/__init__.py

@@ -0,0 +1 @@
+"""Independent component contracts, registry, and built-in definitions."""

components/base_component.py

@@ -0,0 +1,30 @@
+"""Minimal contract for component definitions and installation."""
+
+from abc import ABC, abstractmethod
+
+from components.component_context import ComponentContext
+from components.component_manifest import ComponentManifest
+from components.component_metadata import ComponentMetadata
+
+
+class BaseComponent(ABC):
+    """Expose component identity, metadata, and installation behavior."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the stable component registration name."""
+
+    @property
+    @abstractmethod
+    def metadata(self) -> ComponentMetadata:
+        """Return descriptive metadata for this component."""
+
+    @property
+    @abstractmethod
+    def manifest(self) -> ComponentManifest:
+        """Return declarative installation properties for this component."""
+
+    @abstractmethod
+    def install(self, context: ComponentContext) -> None:
+        """Install the component into the context's existing project."""

components/component_context.py

@@ -0,0 +1,21 @@
+"""Validated project information supplied to component installations."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class ComponentContext:
+    """Identify the existing project directory a component may modify."""
+
+    project_path: Path
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.project_path, Path):
+            raise TypeError("Component project path must be a Path.")
+
+        if not self.project_path.exists():
+            raise ValueError("Component project path must exist.")
+
+        if not self.project_path.is_dir():
+            raise ValueError("Component project path must be a directory.")

components/component_installer.py

@@ -0,0 +1,44 @@
+"""Minimal orchestration for installing one registered component."""
+
+from pathlib import Path
+
+from components.component_context import ComponentContext
+from components.component_registry import ComponentRegistry
+from components.component_state import ComponentStateStore
+from components.component_validation import validate_component
+
+
+class ComponentInstallationError(Exception):
+    """Base error for component installation orchestration."""
+
+
+class ComponentAlreadyInstalledError(ComponentInstallationError):
+    """Raised when project-local state already records a component."""
+
+
+class ComponentInstaller:
+    """Coordinate one explicit component installation in fixed order."""
+
+    def __init__(self, registry: ComponentRegistry | None = None) -> None:
+        self._registry = (
+            ComponentRegistry()
+            if registry is None
+            else registry
+        )
+
+    def install(self, name: str, project_path: Path) -> None:
+        """Install and then record one component for an existing project."""
+
+        component = self._registry.get(name)
+        context = ComponentContext(project_path=project_path)
+        state_store = ComponentStateStore(project_path)
+        installed_components = state_store.load()
+
+        if component.name in installed_components:
+            raise ComponentAlreadyInstalledError(
+                f"Component '{component.name}' is already installed."
+            )
+
+        validate_component(component, installed_components)
+        component.install(context)
+        state_store.add(component.name)

components/component_manifest.py

@@ -0,0 +1,102 @@
+"""Declarative installation properties for ForgePy components."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+@dataclass(frozen=True, slots=True)
+class ComponentManifest:
+    """Describe files and component relationships without resolving them."""
+
+    files: tuple[Path, ...] = ()
+    dependencies: tuple[str, ...] = ()
+    conflicts: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        files = self._normalize_files(self.files)
+        dependencies = self._normalize_names(
+            self.dependencies,
+            "dependencies",
+        )
+        conflicts = self._normalize_names(self.conflicts, "conflicts")
+
+        object.__setattr__(self, "files", files)
+        object.__setattr__(self, "dependencies", dependencies)
+        object.__setattr__(self, "conflicts", conflicts)
+
+    @staticmethod
+    def _normalize_files(files: Iterable[Path]) -> tuple[Path, ...]:
+        if isinstance(files, (str, bytes)):
+            raise TypeError(
+                "Component manifest files must be an iterable of Paths."
+            )
+
+        try:
+            normalized = tuple(files)
+        except TypeError as error:
+            raise TypeError(
+                "Component manifest files must be an iterable of Paths."
+            ) from error
+
+        for path in normalized:
+            if not isinstance(path, Path):
+                raise TypeError(
+                    "Component manifest files must contain only Paths."
+                )
+            if path == Path() or not str(path).strip():
+                raise ValueError(
+                    "Component manifest file paths must not be empty."
+                )
+            if path.is_absolute():
+                raise ValueError(
+                    "Component manifest file paths must be project-relative."
+                )
+            if ".." in path.parts:
+                raise ValueError(
+                    "Component manifest file paths must not contain '..'."
+                )
+
+        ComponentManifest._reject_duplicates(normalized, "files")
+        return normalized
+
+    @staticmethod
+    def _normalize_names(
+        names: Iterable[str],
+        field_name: str,
+    ) -> tuple[str, ...]:
+        if isinstance(names, (str, bytes)):
+            raise TypeError(
+                f"Component manifest {field_name} must be an iterable "
+                "of strings."
+            )
+
+        try:
+            normalized = tuple(names)
+        except TypeError as error:
+            raise TypeError(
+                f"Component manifest {field_name} must be an iterable "
+                "of strings."
+            ) from error
+
+        for name in normalized:
+            if not isinstance(name, str):
+                raise TypeError(
+                    f"Component manifest {field_name} must contain only "
+                    "strings."
+                )
+            if not name.strip():
+                raise ValueError(
+                    f"Component manifest {field_name} entries must not be "
+                    "empty."
+                )
+
+        ComponentManifest._reject_duplicates(normalized, field_name)
+        return normalized
+
+    @staticmethod
+    def _reject_duplicates(values: tuple[object, ...], field_name: str) -> None:
+        if len(values) != len(set(values)):
+            raise ValueError(
+                f"Component manifest {field_name} must not contain duplicates."
+            )

components/component_metadata.py

@@ -0,0 +1,50 @@
+"""Descriptive metadata for ForgePy components."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ComponentMetadata:
+    """Describe a component without defining installation behavior."""
+
+    name: str
+    description: str
+    version: str
+    author: str
+    tags: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        for field_name in (
+            "name",
+            "description",
+            "version",
+            "author",
+        ):
+            if not isinstance(getattr(self, field_name), str):
+                raise TypeError(
+                    f"Component metadata {field_name} must be a string."
+                )
+
+        if not self.name.strip():
+            raise ValueError(
+                "Component metadata name must not be empty."
+            )
+
+        if isinstance(self.tags, (str, bytes)):
+            raise TypeError(
+                "Component metadata tags must be an iterable of strings."
+            )
+
+        try:
+            normalized_tags = tuple(self.tags)
+        except TypeError as error:
+            raise TypeError(
+                "Component metadata tags must be an iterable of strings."
+            ) from error
+
+        if not all(isinstance(tag, str) for tag in normalized_tags):
+            raise TypeError(
+                "Component metadata tags must contain only strings."
+            )
+
+        object.__setattr__(self, "tags", normalized_tags)