py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/initenv/components/project_structure/readme_handler.py

@@ -0,0 +1,56 @@
+"""README template handler."""
+
+from .....utils.logging import log_debug_pair, log_info_pair
+from ..config_manager import ConfigManager
+
+
+class ReadmeHandler:
+    """Handle README template processing."""
+
+    def __init__(self):
+        self.config_manager = ConfigManager()
+
+    def create_readme(self, project_name: str) -> None:
+        """Copy README template and customize it for the project."""
+        try:
+            # Calculate path to vendors/readme/README.md relative to this file
+            template_path = self.config_manager.get_vendor_config_path(
+                "readme/README.md"
+            )
+
+            if template_path.exists():
+                # Read the template
+                with open(template_path, encoding="utf-8") as f:
+                    template_content = f.read()
+
+                # Customize the template
+                customized_content = template_content.format(
+                    project_name=project_name,
+                    project_description=f"{project_name} - A Python project",
+                    cli_command="wl",  # Default CLI command
+                )
+
+                # Write to project README.md
+                with open("README.md", "w", encoding="utf-8") as f:
+                    f.write(customized_content)
+
+                log_debug_pair(
+                    f"✓ README.md template copied and customized for: {project_name}",
+                    f"✓ README.md 模板复制并定制化完成: {project_name}",
+                )
+            else:
+                # Fallback to simple README if template doesn't exist
+                with open("README.md", "w", encoding="utf-8") as f:
+                    f.write(f"# {project_name}\n")
+                log_debug_pair(
+                    f"✓ Created simple README.md with project name: {project_name}",
+                    f"✓ 创建简单 README.md，项目名: {project_name}",
+                )
+        except Exception as e:
+            # Fallback to simple README if customization fails
+            with open("README.md", "w", encoding="utf-8") as f:
+                f.write(f"# {project_name}\n")
+            log_info_pair(
+                f"Warning: Failed to customize README.md, created simple one: {e}",
+                f"警告: 定制 README.md 失败，创建简单版本: {e}",
+            )

wl_cli/commands/initenv/components/project_structure/rust_files_handler.py

@@ -0,0 +1,30 @@
+"""Rust example files handler."""
+
+from pathlib import Path
+
+from .template_copier import TemplateCopier
+
+
+class RustFilesHandler(TemplateCopier):
+    """Copy Rust example files from vendors to project using config-driven approach."""
+
+    CONFIG_SECTION = "rust_templates"
+
+    def copy_rust_files(self, project_name: str, dest_base: Path | None = None) -> None:
+        """Copy Rust example files from vendors to project.
+
+        Args:
+            project_name: Normalized project/package name used in dest templates.
+            dest_base: Optional base directory (``packages/<normalized>`` in
+                workspace mode) prefixed to every configured destination.
+        """
+        self._copy_from_section(
+            project_name,
+            action_name_en="copy Rust example files",
+            action_name_zh="复制 Rust 示例文件",
+            success_msg_en="✓ Copied {name} to {dest.parent}",
+            success_msg_zh="✓ 复制 {name} 到 {dest.parent}",
+            fail_msg="Warning: Failed to copy {name}: {message}",
+            fail_msg_zh="警告: 复制 {name} 失败: {message}",
+            dest_base=dest_base,
+        )

wl_cli/commands/initenv/components/project_structure/setup_handler.py

@@ -0,0 +1,103 @@
+"""Project structure setup handler.
+
+This module serves as the entry point for the modularized project structure setup functionality.
+主要功能委托给专门的模块以获得更好的组织结构。
+"""
+
+from pathlib import Path
+
+from .....utils.root_fallback import current_context
+from ..config_manager import ConfigManager
+from .config_generator import ConfigGenerator
+from .directory_creator import DirectoryCreator, normalize_project_name
+from .hooks_manager import sync_hooks
+from .readme_handler import ReadmeHandler
+from .rust_files_handler import RustFilesHandler
+from .sop_generator import SopGenerator
+from .template_manager import TemplateManager
+
+
+class ProjectStructureSetup:
+    """Project structure setup handler - now a coordinator for specialized modules."""
+
+    def __init__(self) -> None:
+        self.config_manager = ConfigManager()
+        self.directory_creator = DirectoryCreator()
+        self.readme_handler = ReadmeHandler()
+        self.config_generator = ConfigGenerator()
+        self.sop_generator = SopGenerator()
+        self.template_manager = TemplateManager()
+        self.rust_files_handler = RustFilesHandler()
+
+    def setup(
+        self,
+        project_name: str,
+        use_workspace: bool = True,
+        copy_pyproject: bool = True,
+        workspace_mode: bool = False,
+    ) -> None:
+        """Setup project structure by coordinating specialized modules.
+
+        Args:
+            project_name: Name of the project
+            use_workspace: If True, use pyproject.toml with workspace config.
+                          If False, use pyproject.toml without workspace config.
+            copy_pyproject: If True, copy pyproject.toml from template.
+                           If False, skip pyproject.toml (will be generated by PyProjectGenerator).
+            workspace_mode: If True, create packages/{name}/ layout instead of src/{name}/.
+        """
+        # The `wl init` entry resolves the roots **once** here and hands the
+        # deploy root to the two `.wl` steps below (#160/F5). Each of them is a
+        # public entry that can also be called directly (and then resolves the
+        # one root it needs itself), but on this path they must not each walk
+        # the CWD again -- that would resolve the same value twice. Resolving at
+        # entry rather than after the file creation below is safe: both roots
+        # are "git top, else marker, else start", and none of the steps can move
+        # the git top.
+        context = current_context()
+
+        # Normalize the project name exactly once (#175): the same value feeds
+        # directory creation, template rendering and both config-driven
+        # copiers, so a hyphenated name can never create a parallel
+        # ``src/my-project/`` tree next to ``src/my_project/``.
+        normalized_name = normalize_project_name(project_name)
+        package_base = Path("packages") / normalized_name if workspace_mode else None
+
+        # Create main project structure
+        self.directory_creator.create_structure(
+            normalized_name, workspace_mode=workspace_mode
+        )
+
+        # Copy project template files including .coveragerc
+        self.template_manager.copy_template_files(
+            use_workspace=use_workspace,
+            copy_pyproject=copy_pyproject,
+            workspace_mode=workspace_mode,
+            project_name=normalized_name,
+        )
+
+        # Create README.md if it doesn't exist or is empty
+        readme_file = Path("README.md")
+        should_create_readme = (
+            not readme_file.exists()
+            or readme_file.read_text(encoding="utf-8").strip() == ""
+        )
+        if should_create_readme:
+            self.readme_handler.create_readme(project_name)
+
+        # Generate SOP files for Rust-Python integration. In workspace mode the
+        # package-scoped templates share the single ``packages/<norm>`` base.
+        self.sop_generator.generate_sop_files(normalized_name, dest_base=package_base)
+
+        # Copy Rust example files
+        self.rust_files_handler.copy_rust_files(normalized_name, dest_base=package_base)
+
+        # Generate configuration files in .wl directory
+        self.config_generator.generate_configs(context.deploy)
+
+        # Sync git hooks explicitly (generate_configs is pure template migration)
+        sync_hooks(context.deploy)
+
+        from .....utils.logging import log_info_pair
+
+        log_info_pair("✓ Project structure created successfully", "✓ 项目结构创建成功")

wl_cli/commands/initenv/components/project_structure/sop_generator.py

@@ -0,0 +1,73 @@
+"""SOP file generator."""
+
+from pathlib import Path
+
+from .template_copier import TemplateCopier
+
+
+class SopGenerator(TemplateCopier):
+    """Generate SOP files for Rust-Python integration using config-driven approach."""
+
+    CONFIG_SECTION = "sop_templates"
+
+    def generate_sop_files(
+        self, project_name: str, dest_base: Path | None = None
+    ) -> None:
+        """Generate SOP files for Rust-Python integration.
+
+        Args:
+            project_name: Normalized project/package name used in dest templates.
+            dest_base: Optional base directory (``packages/<normalized>`` in
+                workspace mode) prefixed to every configured destination.
+        """
+        existed = self._existing_sop_dests(project_name, dest_base)
+        self._copy_from_section(
+            project_name,
+            action_name_en="generate SOP files",
+            action_name_zh="生成 SOP 文件",
+            success_msg_en="✓ Generated SOP file: {dest}",
+            success_msg_zh="✓ 生成 SOP 文件: {dest}",
+            fail_msg="Warning: Failed to generate SOP {name}: {message}",
+            fail_msg_zh="警告: 生成 SOP {name} 失败: {message}",
+            dest_base=dest_base,
+        )
+        self._rewrite_self_references(project_name, existed, dest_base)
+
+    def _sop_destinations(
+        self, project_name: str, dest_base: Path | None = None
+    ) -> list[Path]:
+        """Resolve the configured SOP destinations for this project name."""
+        base = dest_base if dest_base is not None else Path()
+        dests: list[Path] = []
+        for template in self.config.get(self.CONFIG_SECTION, {}).values():
+            dests.append(base / template["dest"].format(project_name=project_name))
+        return dests
+
+    def _existing_sop_dests(
+        self, project_name: str, dest_base: Path | None = None
+    ) -> set[Path]:
+        return {
+            d for d in self._sop_destinations(project_name, dest_base) if d.exists()
+        }
+
+    def _rewrite_self_references(
+        self, project_name: str, existed: set[Path], dest_base: Path | None = None
+    ) -> None:
+        """Rewrite freshly generated SOP copies so they no longer self-reference
+        wl_cli (industrial-SOP D1 / map #49 #52).
+
+        The vendored SOP templates are repo-agnostic prose, but keep the
+        ``wl_cli`` tokens as runnable examples. We copy them verbatim
+        (template=false, since the markdown's code fences contain literal
+        braces that ``.format`` would break on) and then replace the token with
+        the generated project's own name, so the SOP a new project receives
+        matches its real package/module (``{project_name}_native`` etc.).
+        """
+        for dest in self._sop_destinations(project_name, dest_base):
+            if dest.exists() and dest not in existed:
+                text = dest.read_text(encoding="utf-8")
+                if "wl_cli" in text:
+                    dest.write_text(
+                        text.replace("wl_cli", project_name),
+                        encoding="utf-8",
+                    )

wl_cli/commands/initenv/components/project_structure/template_copier.py

@@ -0,0 +1,104 @@
+"""Shared template copying implementation for config-driven project generators.
+
+Both SopGenerator and RustFilesHandler copy vendored template files into the
+project based on sections in template_config.toml. This base class factors out
+their identical initialization, config loading, and copy loop so changes to
+copying behaviour (error handling, template placeholder support, logging) are
+made in one place.
+"""
+
+from pathlib import Path
+
+import tomllib
+
+from .....utils.file_copier import FileCopier
+from .....utils.logging import log_debug_pair, log_info_pair
+from ..config_manager import ConfigManager
+
+
+class TemplateCopier:
+    """Copy vendored template files based on a template_config.toml section."""
+
+    # Subclasses set the config section key, e.g. "sop_templates".
+    CONFIG_SECTION = ""
+
+    def __init__(self) -> None:
+        """Initialize with a config manager, file copier, and loaded config."""
+        self.config_manager = ConfigManager()
+        self.file_copier = FileCopier()
+        self.config: dict = {}
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load template_config.toml, falling back to an empty dict on failure."""
+        config_path = self.config_manager.get_vendor_config_path(
+            "config/template_config.toml"
+        )
+        if config_path.exists():
+            try:
+                with open(config_path, "rb") as f:
+                    self.config = tomllib.load(f)
+            except Exception as e:
+                log_info_pair(
+                    f"Warning: Failed to load template config: {e}",
+                    f"警告: 加载模板配置失败: {e}",
+                )
+                self.config = {}
+        else:
+            self.config = {}
+
+    def _copy_from_section(
+        self,
+        project_name: str,
+        *,
+        action_name_en: str,
+        action_name_zh: str,
+        success_msg_en: str,
+        success_msg_zh: str,
+        fail_msg: str,
+        fail_msg_zh: str,
+        dest_base: Path | None = None,
+    ) -> None:
+        """Copy files described by CONFIG_SECTION, skipping existing targets.
+
+        Args:
+            project_name: Name of the project, used for {project_name} placeholders.
+            action_name_en: English action label used in the top-level failure message.
+            action_name_zh: Chinese action label used in the top-level failure message.
+            success_msg_en: English success message template with {dest} or {name}.
+            success_msg_zh: Chinese success message template with {dest} or {name}.
+            fail_msg: English failure message template with {name} and {message}.
+            fail_msg_zh: Chinese failure message template with {name} and {message}.
+            dest_base: Optional base directory prefixed to every configured dest.
+                In workspace mode the caller passes ``packages/<normalized>`` so
+                package-scoped templates land inside the sub-package (#175).
+        """
+        try:
+            section_config = self.config.get(self.CONFIG_SECTION, {})
+            context = {"project_name": project_name}
+            base = dest_base if dest_base is not None else Path()
+
+            for name, template in section_config.items():
+                src = self.config_manager.get_vendor_config_path(template["src"])
+                dest = base / template["dest"].format(**context)
+                is_template = template.get("template", False)
+
+                if not dest.exists():
+                    result = self.file_copier.copy_file(
+                        src, dest, template=is_template, context=context
+                    )
+                    if result.success:
+                        log_debug_pair(
+                            success_msg_en.format(dest=dest, name=name),
+                            success_msg_zh.format(dest=dest, name=name),
+                        )
+                    else:
+                        log_info_pair(
+                            fail_msg.format(name=name, message=result.message),
+                            fail_msg_zh.format(name=name, message=result.message),
+                        )
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to {action_name_en}: {e}",
+                f"警告: {action_name_zh}失败: {e}",
+            )

wl_cli/commands/initenv/components/project_structure/template_manager.py

@@ -0,0 +1,195 @@
+"""Project template manager."""
+
+from pathlib import Path
+
+import tomllib
+
+from .....utils.file_copier import FileCopier
+from .....utils.logging import log_debug, log_debug_pair, log_info, log_info_pair
+from .....utils.root import RootKind
+from .....utils.root_fallback import current_root
+from ..config_manager import ConfigManager
+from .directory_creator import normalize_project_name
+
+
+class TemplateManager:
+    """Copy project template files using config-driven approach."""
+
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        self.file_copier = FileCopier()
+        self.config = {}
+        self._load_config()
+
+    def _load_config(self):
+        config_path = self.config_manager.get_vendor_config_path(
+            "config/template_config.toml"
+        )
+        if config_path.exists():
+            try:
+                with open(config_path, "rb") as f:
+                    self.config = tomllib.load(f)
+            except Exception as e:
+                log_info_pair(
+                    f"Warning: Failed to load template config: {e}",
+                    f"警告: 加载模板配置失败: {e}",
+                )
+                self.config = {}
+        else:
+            self.config = {}
+
+    def _validate_template_files(self) -> list[str]:
+        missing_files = []
+        all_templates = {}
+        all_templates.update(self.config.get("core_templates", {}))
+        all_templates.update(self.config.get("rust_templates", {}))
+        all_templates.update(self.config.get("sop_templates", {}))
+        all_templates.update(self.config.get("config_templates", {}))
+
+        for name, template in all_templates.items():
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            if not src.exists():
+                missing_files.append(f"{name}: {template['src']}")
+
+        return missing_files
+
+    def copy_template_files(
+        self,
+        use_workspace: bool = True,
+        copy_pyproject: bool = True,
+        workspace_mode: bool = False,
+        project_name: str | None = None,
+    ) -> None:
+        """Copy project template files (core + config templates).
+
+        Args:
+            use_workspace: If True, use pyproject.toml with workspace config.
+                          If False, use pyproject.toml without workspace config.
+            copy_pyproject: If True, copy pyproject.toml from template.
+                           If False, skip pyproject.toml (will be generated by PyProjectGenerator).
+            workspace_mode: If True, copy workspace layout templates.
+            project_name: Normalized project name resolved once by the caller
+                          (#175). Falls back to the CWD basename for direct calls.
+        """
+        missing = self._validate_template_files()
+        if missing:
+            log_info_pair(
+                f"Warning: Missing template files: {missing}",
+                f"警告: 缺失模板文件: {missing}",
+            )
+
+        try:
+            self._copy_core_templates()
+            self._copy_config_templates()
+
+            if copy_pyproject:
+                if workspace_mode:
+                    self._copy_workspace_templates(project_name)
+                else:
+                    self._copy_pyproject(use_workspace)
+
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to copy project template files: {e}",
+                f"警告: 复制项目模板文件失败: {e}",
+            )
+
+    def _copy_core_templates(self):
+        core_config = self.config.get("core_templates", {})
+        for name, template in core_config.items():
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            dest = Path(template["dest"])
+
+            if not dest.exists():
+                result = self.file_copier.copy_file(src, dest)
+                if result.success:
+                    log_debug_pair(
+                        f"✓ Copied {name} from template", f"✓ 从模板复制 {name}"
+                    )
+                else:
+                    log_info(f"Warning: Failed to copy {name}: {result.message}")
+
+    def _copy_config_templates(self):
+        """Copy the ``.wl`` config templates, anchored at the deploy root.
+
+        These destinations all live under ``.wl`` (``.wl/mypy.ini`` and friends),
+        which since #95 / #96 belongs inside the git work tree -- the same base
+        :class:`ConfigGenerator` uses. Resolving them against the CWD instead
+        dropped a second, partial ``.wl`` into an ``wl init project`` run from a
+        subdirectory (issue #95 / #96 fix-up, F1).
+        """
+        # The same deploy root :class:`ConfigGenerator` uses (#160): the one
+        # fallback policy, taken as a bare Path to join the template paths onto.
+        deploy_root = current_root(RootKind.DEPLOY).path
+        config_config = self.config.get("config_templates", {})
+        for name, template in config_config.items():
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            dest = deploy_root / template["dest"]
+
+            if not dest.exists():
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                result = self.file_copier.copy_file(src, dest)
+                if result.success:
+                    log_debug_pair(
+                        f"✓ Copied {name} from template", f"✓ 从模板复制 {name}"
+                    )
+                else:
+                    log_info(f"Warning: Failed to copy {name}: {result.message}")
+
+    def _copy_workspace_templates(self, project_name: str | None = None) -> None:
+        """Copy workspace layout templates (root pyproject + package pyproject)."""
+        pyproject_config = self.config.get("pyproject_templates", {})
+        normalized_name = normalize_project_name(project_name or Path.cwd().name)
+
+        # Copy workspace root pyproject.toml
+        root_key = "workspace_root"
+        if root_key in pyproject_config:
+            template = pyproject_config[root_key]
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            dest = Path(template["dest"])
+            if not dest.exists() and src.exists():
+                result = self.file_copier.copy_file(src, dest)
+                if result.success:
+                    log_debug("✓ Copied workspace root pyproject.toml")
+                else:
+                    log_info(
+                        f"Warning: Failed to copy workspace pyproject.toml: {result.message}"
+                    )
+
+        # Copy package pyproject.toml
+        pkg_key = "workspace_package"
+        if pkg_key in pyproject_config:
+            template = pyproject_config[pkg_key]
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            dest_str = template["dest"].replace("{project_name}", normalized_name)
+            dest = Path(dest_str)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            if not dest.exists() and src.exists():
+                result = self.file_copier.copy_file(src, dest)
+                if result.success:
+                    log_debug(f"✓ Copied package pyproject.toml to {dest}")
+                else:
+                    log_info(
+                        f"Warning: Failed to copy package pyproject.toml: {result.message}"
+                    )
+
+    def _copy_pyproject(self, use_workspace: bool):
+        pyproject_config = self.config.get("pyproject_templates", {})
+        key = "workspace" if use_workspace else "no_workspace"
+
+        if key in pyproject_config:
+            template = pyproject_config[key]
+            src = self.config_manager.get_vendor_config_path(template["src"])
+            dest = Path(template["dest"])
+
+            if not dest.exists() and src.exists():
+                result = self.file_copier.copy_file(src, dest)
+                if result.success:
+                    log_debug_pair(
+                        "✓ Copied pyproject.toml from template",
+                        "✓ 从模板复制 pyproject.toml",
+                    )
+                else:
+                    log_info(
+                        f"Warning: Failed to copy pyproject.toml: {result.message}"
+                    )