pysfi 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

sfi/pypack/pypack.py

@@ -1,30 +1,32 @@
-"""Package Workflow - Advanced Python project packaging tool with workflow orchestration.
+"""Package Workflow - Advanced Python project packaging tool.
 
 This module provides a comprehensive packaging solution that integrates pyprojectparse,
-pysourcepack, pyembedinstall, and pyloadergen tools through a workflow engine to achieve
-mixed serial and parallel execution for optimal efficiency.
+pysourcepack, pyembedinstall, and pyloadergen tools with configurable serial and
+parallel execution for optimal efficiency.
+
+The module follows established design patterns:
+- Factory pattern for configuration creation
+- Strategy pattern for cleaning operations
+- Builder pattern for workflow construction
+- Singleton pattern for logging configuration
 """
 
 from __future__ import annotations
 
 import argparse
 import asyncio
-import json
 import logging
 import platform
 import shutil
-from dataclasses import dataclass
+import subprocess
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from functools import cached_property
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable, Protocol
 
 from sfi.pyprojectparse.pyprojectparse import Project, Solution
-from sfi.pysourcepack.pysourcepack import pack_project
-from sfi.workflowengine.workflowengine import (
-    CPUTask,
-    IOTask,
-    SerialTask,
-    WorkflowEngine,
-)
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -38,1104 +40,653 @@ __version__ = "1.0.0"
 __build__ = "20260120"
 
 
+# Enums for better type safety
+class LoaderType(Enum):
+    """Enumeration of supported loader types."""
+
+    CONSOLE = "console"
+    GUI = "gui"
+
+
+class ArchiveFormat(Enum):
+    """Enumeration of supported archive formats."""
+
+    ZIP = "zip"
+    SEVEN_ZIP = "7z"
+    NSIS = "nsis"
+
+
+class MirrorSource(Enum):
+    """Enumeration of supported PyPI mirror sources."""
+
+    PYPI = "pypi"
+    TSINGHUA = "tsinghua"
+    ALIYUN = "aliyun"
+    USTC = "ustc"
+    DOUBAN = "douban"
+    TENCENT = "tencent"
+
+
+# Protocol for cleaning strategies
+class CleaningStrategy(Protocol):
+    """Protocol for cleaning strategies."""
+
+    def should_clean(self, entry: Path) -> bool:
+        """Determine if an entry should be cleaned."""
+        ...
+
+    def clean_entry(self, entry: Path) -> tuple[bool, str]:
+        """Clean an entry and return success status and message."""
+        ...
+
+
+# Constants
+LOG_SEPARATOR = "=" * 50
+PROTECTED_DIRS = {
+    ".git",
+    ".venv",
+    ".virtualenv",
+    ".vscode",
+    ".idea",
+    ".codebuddy",
+    ".qoder",
+}
+CLEANABLE_DIRS = {"build", "dist", "pysfi_build", "cbuild", "benchmarks"}
+
+
+# Configuration Factory Pattern
+class ConfigFactory:
+    """Factory for creating workflow configurations with validation."""
+
+    @staticmethod
+    def create_from_args(args: argparse.Namespace, cwd: Path) -> WorkflowConfig:
+        """Create configuration from command line arguments."""
+        # For commands that don't need project-specific config, use defaults
+        project_name = getattr(args, "project", None)
+
+        return WorkflowConfig(
+            directory=cwd,
+            project_name=project_name,
+            python_version=getattr(args, "python_version", "3.8.10"),
+            loader_type=LoaderType(getattr(args, "loader_type", "console")),
+            entry_suffix=getattr(args, "entry_suffix", ".ent"),
+            generate_loader=not getattr(args, "no_loader", False),
+            offline=getattr(args, "offline", False),
+            max_concurrent=getattr(args, "jobs", 4),
+            debug=getattr(args, "debug", False),
+            cache_dir=Path(args.cache_dir)
+            if getattr(args, "cache_dir", None)
+            else None,
+            archive_format=ArchiveFormat(getattr(args, "archive_format", "zip")),
+            mirror=MirrorSource(getattr(args, "mirror", "aliyun")),
+            archive_type=getattr(args, "archive", None),
+        )
+
+    @staticmethod
+    def create_default(directory: Path) -> WorkflowConfig:
+        """Create default configuration."""
+        return WorkflowConfig(directory=directory)
+
+
 @dataclass
 class WorkflowConfig:
-    """Configuration for package workflow."""
+    """Configuration for package workflow with type-safe enums."""
 
     directory: Path
     project_name: str | None = None
     python_version: str = "3.8.10"
-    loader_type: str = "console"
+    loader_type: LoaderType = LoaderType.CONSOLE
     entry_suffix: str = ".ent"
     generate_loader: bool = True
-    recursive: bool = False
     offline: bool = False
     max_concurrent: int = 4
     debug: bool = False
     cache_dir: Path | None = None
-    archive_format: str = "zip"
-    mirror: str = "aliyun"
-
-
-@dataclass
-class ParseProjectResult:
-    """Result from project parsing task."""
-
-    projects: dict[str, Any]
-    projects_file: str
-
-
-@dataclass
-class PackSourceResult:
-    """Result from source packing task."""
-
-    packed_projects: list[str]
-    output_dir: str
-
-
-@dataclass
-class InstallPythonResult:
-    """Result from Python installation task."""
-
-    version: str
-    target_dir: str
-    install_result: Any
-
-
-@dataclass
-class PackLibrariesResult:
-    """Result from library packing task."""
-
-    pack_result: Any
-    packages_dir: str
-
-
-class ParseProjectTask(IOTask):
-    """Task to parse project configuration using pyprojectparse."""
-
-    def __init__(self, directory: Path, recursive: bool = False, timeout: float = 60.0):
-        super().__init__("parse_project", 2.0, [], timeout)
-        self.directory = directory
-        self.recursive = recursive
-
-    async def execute(self, context: dict[str, Any]) -> Any:
-        """Execute project parsing."""
-        logger.info(f"Starting project parsing: {self.directory}")
-
-        try:
-            projects = Solution.from_directory(
-                root_dir=self.directory, recursive=self.recursive
-            )
-
-            logger.info(f"Found {len(projects)} project(s)")
-            for project in projects.values():
-                logger.info(project)
-
-            return {
-                "projects": projects,
-                "projects_file": str(self.directory / "projects.json"),
-            }
-
-        except Exception as e:
-            logger.error(f"Failed to parse projects: {e}")
-            raise
-
-
-class PackSourceTask(IOTask):
-    """Task to pack source code using pysourcepack."""
-
-    def __init__(
-        self,
-        directory: Path,
-        projects_file: Path,
-        project_name: str | None = None,
-        timeout: float = 120.0,
-    ):
-        super().__init__("pack_source", 5.0, ["parse_project"], timeout)
-        self.base_dir = directory
-        self.projects_file = projects_file
-        self.projects: dict[str, Project] = {}
-        self.project_name = project_name
-
-    def _pack_projects(self, projects: dict) -> list[str]:
-        """Pack specified projects.
-
-        Args:
-            projects: Projects data dict
-
-        Returns:
-            List of packed project names
-        """
-        project_names = (
-            [self.project_name] if self.project_name else list(projects.keys())
+    archive_format: ArchiveFormat = ArchiveFormat.ZIP
+    mirror: MirrorSource = MirrorSource.ALIYUN
+    archive_type: str | None = None
+
+    @cached_property
+    def normalized_directory(self) -> Path:
+        """Get normalized and resolved directory path."""
+        return self.directory.resolve()
+
+    @cached_property
+    def dist_dir(self) -> Path:
+        """Get distribution directory path."""
+        return self.normalized_directory / "dist"
+
+    @cached_property
+    def build_dir(self) -> Path:
+        """Get build directory path."""
+        return self.normalized_directory / "build"
+
+
+# Strategy Pattern Implementation for Cleaning
+class StandardCleaningStrategy:
+    """Standard cleaning strategy implementation."""
+
+    def should_clean(self, entry: Path) -> bool:
+        """Determine if entry should be cleaned using standard rules."""
+        # Special case: projects.json file should always be cleaned
+        if entry.is_file():
+            return entry.name == "projects.json"
+
+        # Protected directories starting with dot
+        if entry.name.startswith(".") and entry.name in PROTECTED_DIRS:
+            return False
+
+        # Clean temporary and build directories
+        return (
+            entry.name.startswith(".")
+            or entry.name.startswith("__")
+            or entry.name in CLEANABLE_DIRS
         )
-        packed_projects = []
-
-        for name in project_names:
-            logger.info(f"Packing project: {name}")
-            pack_project(base_dir=self.base_dir, project_name=name, projects=projects)
-            packed_projects.append(name)
-
-        return packed_projects
 
-    async def execute(self, context: dict[str, Any]) -> Any:
-        """Execute source packing."""
-        logger.info(f"Starting source packing: {self.base_dir}")
+    def clean_entry(self, entry: Path) -> tuple[bool, str]:
+        """Clean entry and return success status with message."""
+        if not entry.exists():
+            return True, "Entry does not exist"
 
         try:
-            projects = Solution.from_directory(
-                root_dir=self.base_dir, recursive=True, update=False
-            ).projects
-
-            packed_projects = self._pack_projects(projects)
-            logger.info(f"Packed {len(packed_projects)} project(s)")
-            return {"packed_projects": packed_projects, "output_dir": "dist/src"}
-
+            if entry.is_dir():
+                shutil.rmtree(entry)
+                return True, f"Removed directory: {entry}"
+            elif entry.is_file():
+                entry.unlink()
+                return True, f"Removed file: {entry}"
+            else:
+                return False, f"Unknown entry type: {entry}"
         except Exception as e:
-            logger.error(f"Failed to pack source: {e}")
-            raise
+            return False, f"Failed to remove {entry}: {e}"
 
 
-class InstallPythonTask(IOTask):
-    """Task to install embedded Python using pyembedinstall."""
+@dataclass(frozen=True)
+class PackageWorkflow:
+    """Package workflow orchestrator using strategy pattern for cleaning."""
 
-    def __init__(
-        self,
-        version: str,
-        target_dir: Path,
-        offline: bool = False,
-        timeout: float = 300.0,
-    ):
-        super().__init__("install_python", 10.0, ["parse_project"], timeout)
-        self.version = version
-        self.target_dir = target_dir
-        self.offline = offline
+    root_dir: Path
+    config: WorkflowConfig
+    cleaning_strategy: CleaningStrategy = field(
+        default_factory=StandardCleaningStrategy
+    )
 
-    def _get_architecture(self) -> str:
-        """Determine system architecture.
+    @cached_property
+    def solution(self) -> Solution:
+        """Get the solution for the root directory.
 
         Returns:
-            Architecture string (amd64 or arm64)
+            Solution: The solution for the root directory.
         """
-        arch = platform.machine().lower()
-        if arch in ("amd64", "x86_64"):
-            return "amd64"
-        elif arch in ("arm64", "aarch64"):
-            return "arm64"
-        return "amd64"
+        return Solution.from_directory(root_dir=self.root_dir)
 
-    def _prepare_cache_dir(self) -> Path:
-        """Prepare cache directory for Python installation.
+    @cached_property
+    def projects(self) -> dict[str, Project]:
+        """Get the projects for the solution.
 
         Returns:
-            Cache directory path
+            dict[str, Project]: The projects for the solution.
         """
-        from sfi.pyembedinstall.pyembedinstall import _DEFAULT_CACHE_DIR
-
-        cache_dir = _DEFAULT_CACHE_DIR
-        cache_dir.mkdir(parents=True, exist_ok=True)
-        return cache_dir
-
-    def _install_python(self, cache_dir: Path, arch: str) -> Any:
-        """Install embedded Python.
-
-        Args:
-            cache_dir: Cache directory path
-            arch: System architecture
+        return self.solution.projects
+
+    @property
+    def dist_dir(self) -> Path:
+        """Get distribution directory path."""
+        return self.config.dist_dir
+
+    @property
+    def build_dir(self) -> Path:
+        """Get build directory path."""
+        return self.config.build_dir
+
+    def clean_project(self) -> None:
+        """Clean build artifacts and package files using strategy pattern."""
+        logger.info("Cleaning build artifacts using strategy pattern...")
+
+        entries_to_clean = [
+            entry
+            for entry in self.root_dir.iterdir()
+            if self.cleaning_strategy.should_clean(entry)
+        ]
+
+        if not entries_to_clean:
+            logger.info("No build artifacts found to clean")
+            return
 
-        Returns:
-            Installation result
-        """
-        from sfi.pyembedinstall.pyembedinstall import (
-            EmbedInstallConfig,
-            install_embed_python,
-        )
+        # Track cleaning results
+        cleaned_dirs: list[str] = []
+        cleaned_files: list[str] = []
+        failed_operations: list[str] = []
+
+        for entry in entries_to_clean:
+            success, message = self.cleaning_strategy.clean_entry(entry)
+            if success:
+                if entry.is_dir():
+                    cleaned_dirs.append(str(entry))
+                else:
+                    cleaned_files.append(str(entry))
+                logger.debug(message)
+            else:
+                failed_operations.append(message)
+                logger.warning(message)
 
-        config = EmbedInstallConfig(
-            target_dir=self.target_dir,
-            version=self.version,
-            cache_dir=cache_dir,
-            offline=self.offline,
-            keep_cache=True,
-            skip_speed_test=False,
-            arch=arch,
+        # Summary logging
+        logger.info(
+            f"Cleaned {len(cleaned_dirs)} directories and {len(cleaned_files)} file(s)"
         )
 
-        return install_embed_python(config)
-
-    async def execute(self, context: dict[str, Any]) -> Any:
-        """Execute Python installation."""
-        logger.info(f"Starting Python installation: {self.version}")
-
-        try:
-            cache_dir = self._prepare_cache_dir()
-            arch = self._get_architecture()
-            install_result = self._install_python(cache_dir, arch)
-
-            logger.info(f"Python {self.version} installed to {self.target_dir}")
-
-            return {
-                "version": self.version,
-                "target_dir": str(self.target_dir),
-                "install_result": install_result,
-            }
-
-        except Exception as e:
-            logger.error(f"Failed to install Python: {e}")
-            raise
-
+        if failed_operations:
+            logger.error(f"Failed operations: {len(failed_operations)}")
 
-class PackLibrariesTask(IOTask):
-    """Task to pack dependencies using pylibpack."""
-
-    def __init__(
-        self,
-        project_dir: Path,
-        output_dir: Path,
-        cache_dir: Path | None = None,
-        python_version: str | None = None,
-        max_workers: int = 4,
-        archive_format: str = "zip",
-        mirror: str = "aliyun",
-        timeout: float = 300.0,
-    ):
-        super().__init__("pack_libraries", 10.0, ["parse_project"], timeout)
-        self.project_dir = project_dir
-        self.output_dir = output_dir
-        self.cache_dir = cache_dir
-        self.python_version = python_version
-        self.max_workers = max_workers
-        self.archive_format = archive_format
-        self.mirror = mirror
-
-    def _create_packer(self) -> Any:
-        """Create PyLibPack instance.
+    async def _run_sync_task(self, name: str, setup_func: Callable[[], None]) -> None:
+        """Run a synchronous task in thread pool executor.
 
-        Returns:
-            PyLibPack instance
+        Args:
+            name: Name of the task for logging
+            setup_func: Function that returns the task to execute
         """
-        from sfi.pylibpack.pylibpack import PyLibPack
-
-        return PyLibPack(
-            cache_dir=self.cache_dir,
-            python_version=self.python_version,
-            mirror=self.mirror,
-        )
-
-    async def execute(self, context: dict[str, Any]) -> Any:
-        """Execute library packing."""
-        logger.info(f"Starting library packing: {self.project_dir}")
-
-        try:
-            packer = self._create_packer()
-            pack_result = packer.pack(
-                base_dir=self.project_dir,
-                output_dir=self.output_dir,
-                max_workers=self.max_workers,
+        logger.info(LOG_SEPARATOR)
+        logger.info(f"Packing {name}...")
+
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, setup_func)
+        logger.info(f"{name.capitalize()} packed.")
+
+    async def pack_embed_python(self) -> None:
+        """Pack embed python."""
+        from sfi.pyembedinstall.pyembedinstall import EmbedInstaller
+
+        def _run():
+            installer = EmbedInstaller(
+                root_dir=self.root_dir,
+                cache_dir=self.config.cache_dir,
+                offline=self.config.offline,
             )
+            installer.run()
 
-            logger.info(
-                f"Library packing completed: {pack_result.successful}/{pack_result.total}"
-            )
+        await self._run_sync_task("embed python", _run)
 
-            return {
-                "pack_result": pack_result,
-                "packages_dir": pack_result.output_dir,
-            }
+    async def pack_loaders(self) -> None:
+        """Pack loaders for all projects concurrently."""
+        from sfi.pyloadergen.pyloadergen import PyLoaderGenerator
 
-        except Exception as e:
-            logger.error(f"Failed to pack libraries: {e}")
-            raise
+        def _run():
+            generator = PyLoaderGenerator(root_dir=self.root_dir)
+            generator.run()
 
+        await self._run_sync_task("loaders", _run)
 
-class GenerateLoaderTask(CPUTask):
-    """Task to generate loader using pyloadergen."""
+    async def pack_libraries(self) -> None:
+        """Pack libraries for all projects concurrently."""
+        from sfi.pylibpack.pylibpack import PyLibPacker, PyLibPackerConfig
 
-    def __init__(
-        self,
-        base_dir: Path,
-        debug: bool = False,
-        timeout: float = 60.0,
-    ):
-        super().__init__(
-            "generate_loader", 100000, ["parse_project", "pack_source"], timeout
-        )
-        self.base_dir = base_dir
-        self.debug = debug
+        def _run():
+            libpacker = PyLibPacker(
+                working_dir=self.root_dir,
+                config=PyLibPackerConfig(self.config.cache_dir),
+            )
+            libpacker.run()
 
-    async def execute(self, inputs: dict[str, Any]) -> Any:
-        """Execute loader generation."""
-        try:
-            from sfi.pyloadergen.pyloadergen import generate_loader
+        await self._run_sync_task("libraries", _run)
 
-            generate_loader(self.base_dir, self.debug)
-        except Exception as e:
-            logger.error(f"Failed to generate loader: {e}")
-            raise
+    async def pack_source(self) -> None:
+        """Pack source code for all projects concurrently."""
+        from sfi.pysourcepack.pysourcepack import PySourcePacker
 
+        def _run():
+            source_packer = PySourcePacker(root_dir=self.root_dir)
+            source_packer.run()
 
-class AssemblePackageTask(SerialTask):
-    """Task to assemble final package."""
+        await self._run_sync_task("source code", _run)
 
-    def __init__(
-        self, output_dir: Path, dependencies: list[str], timeout: float = 60.0
-    ):
-        self.output_dir = output_dir
-        super().__init__("assemble_package", self._assemble, dependencies, timeout)
+    async def pack_archive(self, archive_format: str) -> None:
+        """Create archive for all projects.
 
-    def _get_project_dir(self, inputs: dict[str, Any]) -> Path:
-        """Get project directory from parse result or current directory."""
-        if "parse_project" in inputs and hasattr(inputs["parse_project"], "data"):
-            parse_result = inputs["parse_project"].data
-            if isinstance(parse_result, dict) and "projects_file" in parse_result:
-                return Path(parse_result["projects_file"]).parent
-        return Path.cwd()
+        Args:
+            archive_format: Archive format (zip, tar, gztar, bztar, xztar, 7z, nsis)
+        """
+        from sfi.pyarchive.pyarchive import PyArchiveConfig, PyArchiver
 
-    def _prepare_dist_dir(self) -> Path:
-        """Prepare and return distribution directory."""
-        dist_dir = (
-            self.output_dir.parent if self.output_dir.is_file() else self.output_dir
-        )
-        dist_dir = dist_dir if dist_dir.name == "dist" else dist_dir.parent / "dist"
-        dist_dir.mkdir(parents=True, exist_ok=True)
-        return dist_dir
-
-    def _copy_loaders(self, project_dir: Path, dist_dir: Path) -> int:
-        """Copy loaders and entry files to dist directory."""
-        loader_dir = project_dir / "dist"
-        if not loader_dir.exists():
-            return 0
-
-        loaders_count = 0
-        for loader in loader_dir.glob("*.ent"):
-            logger.info(f"Entry file: {loader.name}")
-            loaders_count += 1
-
-        # Support both Linux (no extension) and Windows (.exe) executables
-        for loader in loader_dir.glob("*.exe"):
-            logger.info(f"Executable: {loader.name}")
-            shutil.copy2(loader, dist_dir / loader.name)
-            loaders_count += 1
-
-        # Also copy Linux executables (files without extension)
-        for loader in loader_dir.glob("*"):
-            if loader.is_file() and not loader.name.endswith((".ent", ".exe")):
-                logger.info(f"Executable: {loader.name}")
-                shutil.copy2(loader, dist_dir / loader.name)
-                loaders_count += 1
-
-        logger.info(f"Found and copied {loaders_count} loader(s) and entry file(s)")
-        return loaders_count
-
-    def _copy_libraries(self, project_dir: Path, dist_dir: Path) -> None:
-        """Copy libraries to dist/site-packages directory."""
-        libs_dir = project_dir / "dist" / "libs"
-        if not libs_dir.exists():
-            return
+        def _run():
+            config = PyArchiveConfig(verbose=self.config.debug)
+            archiver = PyArchiver(root_dir=self.root_dir, config=config)
+            archiver.archive_projects(format=archive_format)
 
-        dest_libs_dir = dist_dir / "site-packages"
-        if dest_libs_dir.exists():
-            shutil.rmtree(dest_libs_dir)
-        shutil.copytree(libs_dir, dest_libs_dir)
-        logger.info(f"Libraries copied to {dest_libs_dir}")
+        await self._run_sync_task(f"{archive_format} archives", _run)
 
-    def _create_metadata(self, dist_dir: Path) -> dict[str, Any]:
-        """Create package metadata file."""
-        metadata = {
-            "version": __version__,
-            "build": __build__,
-            "assembled_at": asyncio.get_event_loop().time(),
-        }
+    async def build(self) -> dict[str, Any]:
+        """Execute the packaging workflow with concurrent optimization.
 
-        metadata_file = dist_dir / "metadata.json"
-        with open(metadata_file, "w", encoding="utf-8") as f:
-            json.dump(metadata, f, indent=2)
+        Workflow stages:
+        1. Pack embed python (must be first)
+        2. Pack loaders, libraries, and source in parallel
+        3. Create archive (optional, if archive_type is set)
 
-        return metadata
+        Returns:
+            Dict with results and summary including output_dir and metadata
 
-    def _assemble(
-        self, inputs: dict[str, Any], state: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Assemble final package."""
-        logger.info("Starting package assembly")
+        Raises:
+            FileNotFoundError: If required directories don't exist
+            RuntimeError: If any packaging step fails
+        """
+        logger.info("Starting packaging workflow execution")
+        start_time = time.perf_counter()
 
         try:
-            project_dir = self._get_project_dir(inputs)
-            dist_dir = self._prepare_dist_dir()
-
-            self._copy_loaders(project_dir, dist_dir)
-            self._copy_libraries(project_dir, dist_dir)
-            metadata = self._create_metadata(dist_dir)
+            # Stage 1: Pack embed python (prerequisite for other tasks)
+            await self.pack_embed_python()
+
+            # Stage 2: Pack loaders, libraries, and source concurrently
+            logger.info(LOG_SEPARATOR)
+            logger.info("Running parallel tasks: loaders, libraries, source...")
+            await asyncio.gather(
+                self.pack_loaders(),
+                self.pack_libraries(),
+                self.pack_source(),
+            )
 
-            logger.info(f"Package assembled: {dist_dir}")
-            return {"output_dir": str(dist_dir), "metadata": metadata}
+            # Stage 3: Create archive (optional)
+            if self.config.archive_type:
+                await self.pack_archive(self.config.archive_type)
 
-        except Exception as e:
-            logger.error(f"Failed to assemble package: {e}")
+        except (FileNotFoundError, RuntimeError):
             raise
+        except Exception as e:
+            logger.error(f"Workflow execution failed: {e}")
+            raise RuntimeError(f"Packaging workflow failed: {e}") from e
 
+        elapsed = time.perf_counter() - start_time
+        logger.info(LOG_SEPARATOR)
+        logger.info(f"Packaging workflow completed in {elapsed:.2f}s")
+        return {"output_dir": str(self.dist_dir), "metadata": {}}
 
-class PackageWorkflow:
-    """Package workflow orchestrator."""
-
-    def __init__(self, directory: Path, config: WorkflowConfig):
-        self.directory = directory
-        self.config = config
-        self.engine = WorkflowEngine(max_concurrent=config.max_concurrent)
-
-    def _add_parse_task(self) -> None:
-        """Add project parsing task to workflow."""
-        parse_task = ParseProjectTask(
-            directory=self.directory,
-            recursive=self.config.recursive,
-        )
-        self.engine.add_task(parse_task)
-
-    def _add_pack_and_install_tasks(self) -> None:
-        """Add pack source and install Python tasks to workflow."""
-        pack_task = PackSourceTask(
-            directory=self.directory,
-            projects_file=self.directory / "projects.json",
-            project_name=self.config.project_name,
-        )
-        self.engine.add_task(pack_task)
-
-        install_task = InstallPythonTask(
-            version=self.config.python_version,
-            target_dir=self.directory / "dist" / "runtime",
-            offline=self.config.offline,
-        )
-        self.engine.add_task(install_task)
-
-    def _add_pack_libraries_task(self) -> None:
-        """Add library packing task to workflow."""
-        lib_pack_task = PackLibrariesTask(
-            project_dir=self.directory,
-            output_dir=self.directory / "dist/site-packages",
-            cache_dir=self.config.cache_dir,
-            python_version=self.config.python_version,
-            max_workers=self.config.max_concurrent,
-            archive_format=self.config.archive_format,
-            mirror=self.config.mirror,
-        )
-        self.engine.add_task(lib_pack_task)
+    def list_projects(self) -> None:
+        """List all available projects."""
+        logger.info(f"Listing projects in {self.root_dir}")
+        for project in self.projects.values():
+            logger.info(f"  - {project}")
 
-    def _add_loader_task(self) -> list[str]:
-        """Add loader generation task to workflow.
+    def _scan_executables(self) -> list[Path]:
+        """Scan dist directory for executable files.
 
         Returns:
-            List of task dependencies for assembly phase
+            List of executable file paths found in dist directory.
         """
-        if not self.config.generate_loader:
-            return ["pack_source", "install_python"]
+        dist_dir = self.dist_dir
+        if not dist_dir.exists():
+            return []
+        return [f for f in dist_dir.glob(f"*{ext}") if f.is_file()]
 
-        loader_task = GenerateLoaderTask(self.directory, self.config.debug)
-        self.engine.add_task(loader_task)
+    def _resolve_executable(self, match_name: str | None) -> Path | None:
+        """Resolve executable by scanning dist directory and matching name.
 
-        assembly_deps = ["pack_source", "install_python", "generate_loader"]
-        assembly_deps.append("pack_libraries")
+        Args:
+            match_name: Executable name or partial name to match
 
-        return assembly_deps
+        Returns:
+            Path to matched executable, or None if not found/ambiguous.
+        """
+        executables = self._scan_executables()
+        if not executables:
+            return None
 
-    def _add_assemble_task(self, dependencies: list[str]) -> None:
-        """Add package assembly task to workflow.
+        # Auto-select if only one executable and no name specified
+        if not match_name:
+            return executables[0] if len(executables) == 1 else None
 
-        Args:
-            dependencies: List of task dependencies
-        """
-        assemble_task = AssemblePackageTask(
-            output_dir=self.directory / "dist",
-            dependencies=dependencies,
-        )
-        self.engine.add_task(assemble_task)
+        lower_name = match_name.lower()
 
-    def build_workflow(self) -> WorkflowEngine:
-        """Build the packaging workflow."""
-        logger.info("Building packaging workflow")
+        # Try exact match (without extension)
+        for exe in executables:
+            if exe.stem.lower() == lower_name:
+                return exe
 
-        self._add_parse_task()
-        self._add_pack_and_install_tasks()
-        self._add_pack_libraries_task()
-        dependencies = self._add_loader_task()
-        self._add_assemble_task(dependencies)
+        # Try fuzzy match (case-insensitive substring)
+        matches = [exe for exe in executables if lower_name in exe.stem.lower()]
+        return matches[0] if len(matches) == 1 else None
 
-        return self.engine
+    def list_executables(self) -> None:
+        """List all executables in dist directory."""
+        executables = self._scan_executables()
+        if not executables:
+            logger.info("No executables found in dist directory")
+            return
+        logger.info(f"Available executables in {self.dist_dir}:")
+        for exe in executables:
+            logger.info(f"  - {exe.stem}")
 
-    def _log_execution_summary(self, summary: dict[str, Any]) -> None:
-        """Log workflow execution summary.
+    def run_project(
+        self, match_name: str | None, project_args: list[str] | None = None
+    ) -> None:
+        """Run an executable with fuzzy name matching support.
 
         Args:
-            summary: Execution summary dict
+            match_name: Executable name or partial name to match
+            project_args: Additional arguments to pass to the executable
         """
-        logger.info("=" * 50)
-        logger.info("Workflow execution summary:")
-        logger.info(f"  Total tasks: {summary['total_tasks']}")
-        logger.info(f"  Completed: {summary['completed']}")
-        logger.info(f"  Failed: {summary['failed']}")
-        logger.info(f"  Success rate: {summary['success_rate'] * 100:.1f}%")
-        logger.info(f"  Total time: {summary['total_execution_time']:.2f}s")
-        logger.info("=" * 50)
-
-    async def execute(self) -> dict[str, Any]:
-        """Execute the packaging workflow.
+        exe_path = self._resolve_executable(match_name)
 
-        Returns:
-            Dict with results and summary
-        """
-        logger.info("Starting packaging workflow execution")
+        # Handle executable not found cases
+        if not exe_path:
+            self._handle_executable_not_found(match_name)
+            return
 
-        self.build_workflow()
+        # Build and execute command
+        cmd = self._build_executable_command(exe_path, project_args)
 
         try:
-            results = await self.engine.execute_workflow()
-            summary = self.engine.get_execution_summary()
-            self._log_execution_summary(summary)
-
-            return {"results": results, "summary": summary}
-
+            subprocess.run(cmd, check=True, cwd=self.root_dir)
+            logger.info(f"{exe_path.stem} ran successfully")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"{exe_path.stem} failed with exit code {e.returncode}")
+        except FileNotFoundError:
+            logger.error(f"Executable not found: {exe_path}")
         except Exception as e:
-            logger.error(f"Workflow execution failed: {e}")
-            raise
-
+            logger.error(f"Failed to run {exe_path}: {e}")
 
-def _load_projects_data(directory: Path, silent: bool = False) -> dict[str, Any] | None:
-    """Load projects data from projects.json.
+    def _handle_executable_not_found(self, match_name: str | None) -> None:
+        """Handle cases where executable cannot be found.
 
-    Args:
-        directory: Project directory containing projects.json
-        silent: If True, use warning instead of error messages
-
-    Returns:
-        Projects data dict or None if not found/error
-    """
-    projects_file = directory / "projects.json"
+        Args:
+            match_name: Executable name that was being searched for
+        """
+        executables = self._scan_executables()
+
+        if not match_name:
+            if len(executables) == 0:
+                logger.error("No executables found in dist directory")
+            elif len(executables) > 1:
+                logger.error(
+                    "Multiple executables found. Please specify which one to run:"
+                )
+                self.list_executables()
+            else:
+                logger.error("Unable to auto-select executable")
+        else:
+            logger.error(f"Executable '{match_name}' not found")
 
-    if not projects_file.exists():
-        level = logger.warning if silent else logger.error
-        level(f"No projects.json found in {directory}")
-        logger.info("Run 'pypack build' first to create projects.json")
-        return None
+        if len(executables) > 0:
+            self.list_executables()
 
-    try:
-        with open(projects_file, encoding="utf-8") as f:
-            projects_data = json.load(f)
+    def _build_executable_command(
+        self, exe_path: Path, project_args: list[str] | None
+    ) -> list[str]:
+        """Build command list for executable execution.
 
-        if not projects_data:
-            level = logger.info if silent else logger.error
-            level("No projects found in projects.json")
-            return None
-
-        return projects_data
-    except Exception as e:
-        logger.error(f"Failed to load projects.json: {e}")
-        return None
+        Args:
+            exe_path: Path to executable
+            project_args: Additional arguments to pass
 
+        Returns:
+            List of command arguments
+        """
+        cmd = [str(exe_path.resolve())]
+        if project_args:
+            cmd.extend(project_args)
+            logger.info(f"Arguments: {' '.join(project_args)}")
+        logger.info(f"Running: {' '.join(cmd)}")
+        return cmd
 
-def _get_project_info(project_info: Any) -> tuple[str, str, str]:
-    """Extract project info from project data.
 
-    Args:
-        project_info: Project info dict or string
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments using subcommand structure.
 
     Returns:
-        Tuple of (version, entry, description)
+        Parsed arguments namespace
     """
-    if isinstance(project_info, str):
-        return "N/A", "N/A", ""
-
-    version = (
-        project_info.get("version", "N/A") if isinstance(project_info, dict) else "N/A"
-    )
-    entry = "main.py"
-    description = (
-        project_info.get("description", "") if isinstance(project_info, dict) else ""
+    parser = argparse.ArgumentParser(
+        prog="pypack", description="Python packaging tool with workflow orchestration"
     )
-    return version, entry, description
-
-
-def _print_project(project_name: str, project_info: Any, index: int) -> None:
-    """Print project information.
 
-    Args:
-        project_name: Name of the project
-        project_info: Project info dict or string
-        index: Index number for listing
-    """
-    version, entry, description = _get_project_info(project_info)
-
-    logger.info(f"\n[{index}] {project_name}")
-    logger.info(f"    Version: {version}")
-    logger.info(f"    Entry: {entry}")
-    if description:
-        logger.info(f"    Description: {description}")
-
-
-def list_projects(directory: Path) -> None:
-    """List projects from projects.json.
-
-    Args:
-        directory: Project directory containing projects.json
-    """
-    projects_data = _load_projects_data(directory, silent=True)
-
-    if not projects_data:
-        return
-
-    logger.info(f"Found {len(projects_data)} project(s):")
-    logger.info("=" * 60)
-
-    for i, (project_name, project_info) in enumerate(projects_data.items(), 1):
-        _print_project(project_name, project_info, i)
-
-    logger.info("=" * 60)
-
-
-def _get_available_executables(directory: Path) -> list[str]:
-    """Get list of available executables in dist directory.
-
-    Args:
-        directory: Project directory
-
-    Returns:
-        List of executable names (without .exe extension)
-    """
-    dist_dir = directory / "dist"
-    if not dist_dir.exists():
-        logger.error(f"Dist directory not found: {dist_dir}")
-        logger.info("Run 'pypack build' first to build the project")
-        return []
-
-    # Support both Windows (.exe) and Linux (no extension) executables
-    exe_names = set()
-    for exe in dist_dir.glob("*.exe"):
-        if exe.is_file():
-            exe_names.add(exe.stem)
-
-    for exe in dist_dir.glob("*"):
-        if exe.is_file() and not exe.name.endswith((".ent", ".exe", ".json")):
-            exe_names.add(exe.name)
-
-    available_exes = list(exe_names)
-    if not available_exes:
-        logger.error("No executables found in dist directory")
-        logger.info("Run 'pypack build' first to build the project")
-
-    return available_exes
-
-
-def _find_matching_executables(
-    project_name: str, available_exes: list[str]
-) -> list[str]:
-    """Find executables matching project name.
-
-    Args:
-        project_name: Project name to match
-        available_exes: List of available executable names
-
-    Returns:
-        List of matching executable names
-    """
-    return [
-        exe
-        for exe in available_exes
-        if exe == project_name or exe.startswith(f"{project_name}-")
-    ]
-
-
-def _log_available_executables(available_exes: list[str]) -> None:
-    """Log available executable names.
-
-    Args:
-        available_exes: List of available executable names
-    """
-    logger.info("Available executables:")
-    for exe in available_exes:
-        logger.info(f"** {exe} **")
-
-
-def _resolve_exact_project_name(
-    project_name: str, available_exes: list[str]
-) -> str | None:
-    """Resolve executable when project name is specified.
-
-    Args:
-        project_name: Project name to resolve
-        available_exes: List of available executable names
-
-    Returns:
-        Target executable name or None
-    """
-    if project_name in available_exes:
-        return project_name
-    return None
-
-
-def _resolve_project_by_name(
-    project_name: str, available_exes: list[str]
-) -> str | None:
-    """Resolve executable by matching project name.
-
-    Args:
-        project_name: Project name to resolve
-        available_exes: List of available executable names
-
-    Returns:
-        Target executable name or None
-    """
-    matching_exes = _find_matching_executables(project_name, available_exes)
-
-    if len(matching_exes) == 1:
-        return matching_exes[0]
-    elif len(matching_exes) > 1:
-        logger.error(f"Multiple executables found for project '{project_name}':")
-        for exe in matching_exes:
-            logger.info(f"  - {exe}")
-        logger.info("Please specify the full executable name (e.g., 'docscan-gui')")
-        return None
-
-    logger.error(f"No executable found for project '{project_name}'")
-    return None
+    # Add common arguments to parent parser
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    parent_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
 
-
-def _resolve_no_project_name(available_exes: list[str]) -> str | None:
-    """Resolve executable when no project name is specified.
-
-    Args:
-        available_exes: List of available executable names
-
-    Returns:
-        Target executable name or None
-    """
-    if len(available_exes) == 1:
-        logger.info(f"Running single executable: {available_exes[0]}")
-        return available_exes[0]
-
-    logger.error(
-        "Multiple executables found. Please specify executable name with --project"
+    # Create subparsers
+    subparsers = parser.add_subparsers(
+        dest="command", required=True, help="Available commands"
     )
-    _log_available_executables(available_exes)
-    return None
-
-
-def _resolve_target_executable(
-    project_name: str | None,
-    available_exes: list[str],
-    projects_data: dict[str, Any],
-) -> str | None:
-    """Resolve which executable to run based on project name.
-
-    Args:
-        project_name: Project or executable name to run
-        available_exes: List of available executable names
-        projects_data: Projects data dict
 
-    Returns:
-        Target executable name or None if not found/ambiguous
-    """
-    if not project_name:
-        return _resolve_no_project_name(available_exes)
-
-    exact_match = _resolve_exact_project_name(project_name, available_exes)
-    if exact_match:
-        return exact_match
-
-    if project_name in projects_data:
-        return _resolve_project_by_name(project_name, available_exes)
-
-    logger.error(f"Project or executable '{project_name}' not found")
-    _log_available_executables(available_exes)
-    return None
-
-
-def _execute_project(exe_path: Path, dist_dir: Path) -> None:
-    """Execute the project executable.
-
-    Args:
-        exe_path: Path to the executable
-        dist_dir: Working directory for execution
-    """
-    import subprocess
-
-    try:
-        subprocess.run([str(exe_path)], cwd=str(dist_dir), check=True)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Project execution failed with exit code {e.returncode}")
-    except KeyboardInterrupt:
-        logger.info("Project execution interrupted")
-    except FileNotFoundError:
-        logger.error(f"Failed to execute {exe_path}")
-
-
-def run_project(project_name: str | None, directory: Path) -> None:
-    """Run a built project.
-
-    Args:
-        project_name: Project name or executable name to run (e.g., 'docscan' or 'docscan-gui')
-        directory: Project directory
-    """
-    projects_data = _load_projects_data(directory)
-    if not projects_data:
-        return
-
-    available_exes = _get_available_executables(directory)
-    if not available_exes:
-        return
-
-    target_exe_name = _resolve_target_executable(
-        project_name, available_exes, projects_data
+    # Version subcommand
+    subparsers.add_parser(
+        "version",
+        aliases=["v"],
+        help="Show version information",
+        parents=[parent_parser],
     )
-    if not target_exe_name:
-        return
-
-    # Try both Windows (.exe) and Linux (no extension) executables
-    exe_path_with_ext = directory / "dist" / f"{target_exe_name}.exe"
-    exe_path_no_ext = directory / "dist" / target_exe_name
 
-    exe_path = None
-    if exe_path_with_ext.exists():
-        exe_path = exe_path_with_ext
-    elif exe_path_no_ext.exists():
-        exe_path = exe_path_no_ext
-
-    if not exe_path:
-        logger.error(f"Executable not found for '{target_exe_name}'")
-        logger.info("Run 'pypack build' first to build the project")
-        return
-
-    logger.info(f"Starting: {target_exe_name}")
-    logger.info(f"Executable: {exe_path}")
-    _execute_project(exe_path, directory / "dist")
-
-
-def clean_project(directory: Path) -> None:
-    """Clean build artifacts and package files.
-
-    Args:
-        directory: Project directory to clean
-    """
-    logger.info("Cleaning build artifacts...")
-
-    cleaned_dirs, cleaned_files = _clean_build_artifacts(directory)
-
-    if not cleaned_dirs and not cleaned_files:
-        logger.info("No build artifacts found")
-    else:
-        logger.info(
-            f"Cleaned {len(cleaned_dirs)} directories and {len(cleaned_files)} file(s)"
-        )
-
-
-def _should_clean(entry: Path) -> bool:
-    """Check if a directory or file should be cleaned.
-
-    Args:
-        entry: Path to check
-
-    Returns:
-        True if the entry should be cleaned
-    """
-    protected_dirs = {
-        ".git",
-        ".venv",
-        ".virtualenv",
-        ".vscode",
-        ".idea",
-        ".codebuddy",
-        ".qoder",
-    }
-
-    if entry.is_file() and entry.name == "projects.json":
-        return True
-
-    if not entry.is_dir():
-        return False
-
-    if entry.name.startswith(".") and entry.name in protected_dirs:
-        return False
-
-    return (
-        entry.name.startswith(".")
-        or entry.name.startswith("__")
-        or entry.name in ("build", "dist", "pysfi_build", "cbuild", "benchmarks")
+    # List subcommand
+    subparsers.add_parser(
+        "list",
+        aliases=["l", "ls"],
+        help="List available projects",
+        parents=[parent_parser],
     )
 
-
-def _clean_build_artifacts(directory: Path) -> tuple[list[str], list[str]]:
-    """Clean all build artifacts from directory.
-
-    Args:
-        directory: Project directory to clean
-
-    Returns:
-        Tuple of (cleaned directories, cleaned files)
-    """
-    cleaned_dirs = []
-    cleaned_files = []
-
-    entries_to_clean = [f for f in directory.iterdir() if _should_clean(f)]
-
-    for entry in entries_to_clean:
-        if not entry.exists():
-            continue
-
-        if entry.is_dir():
-            logger.info(f"Removing directory: {entry}")
-            if _remove_directory(entry):
-                cleaned_dirs.append(str(entry))
-                logger.info(f"  Removed directory: {entry}")
-            else:
-                logger.warning(f"  Failed to remove {entry}")
-        elif entry.is_file():
-            logger.info(f"Removing file: {entry}")
-            if _remove_file(entry):
-                cleaned_files.append(str(entry))
-                logger.info(f"  Removed file: {entry}")
-            else:
-                logger.warning(f"  Failed to remove {entry}")
-
-    return cleaned_dirs, cleaned_files
-
-
-def _remove_directory(dir_path: Path) -> bool:
-    """Remove a directory safely.
-
-    Args:
-        dir_path: Directory path to remove
-
-    Returns:
-        True if removal succeeded
-    """
-    try:
-        shutil.rmtree(dir_path)
-        return True
-    except Exception:
-        return False
-
-
-def _remove_file(file_path: Path) -> bool:
-    """Remove a file safely.
-
-    Args:
-        file_path: File path to remove
-
-    Returns:
-        True if removal succeeded
-    """
-    try:
-        file_path.unlink()
-        return True
-    except Exception:
-        return False
-
-
-def parse_args() -> argparse.Namespace:
-    """Parse command line arguments.
-
-    Returns:
-        Parsed arguments namespace
-    """
-    parser = argparse.ArgumentParser(
-        prog="pypack", description="Python packaging tool with workflow orchestration"
+    # Clean subcommand
+    subparsers.add_parser(
+        "clean", aliases=["c"], help="Clean build artifacts", parents=[parent_parser]
     )
 
-    parser.add_argument(
-        "action",
-        choices=("build", "b", "list", "l", "run", "r", "clean", "c", "version", "v"),
-        help="Action to perform",
+    # Run subcommand
+    run_parser = subparsers.add_parser(
+        "run", aliases=["r"], help="Run a project", parents=[parent_parser]
     )
-    parser.add_argument(
+    run_parser.add_argument(
         "project",
         type=str,
         nargs="?",
-        default=None,
         help="Project or executable name (e.g., 'docscan' or 'docscan-gui')",
     )
-    parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
-    parser.add_argument(
+    run_parser.add_argument(
+        "args",
+        type=str,
+        nargs="*",
+        help="Additional arguments to pass to the project",
+    )
+
+    # Build subcommand
+    build_parser = subparsers.add_parser(
+        "build", aliases=["b"], help="Build project packages", parents=[parent_parser]
+    )
+    build_parser.add_argument(
         "--python-version", type=str, default="3.8.10", help="Python version to install"
     )
-    parser.add_argument(
+    build_parser.add_argument(
         "--loader-type",
         type=str,
-        choices=("console", "gui"),
-        default="console",
+        choices=[lt.value for lt in LoaderType],
+        default=LoaderType.CONSOLE.value,
         help="Loader type",
     )
-    parser.add_argument(
+    build_parser.add_argument(
         "--entry-suffix",
         type=str,
         default=".ent",
         help="Entry file suffix (default: .ent, alternatives: .py)",
     )
-    parser.add_argument(
+    build_parser.add_argument(
         "--no-loader", action="store_true", help="Skip loader generation"
     )
-    parser.add_argument(
-        "-r", "--recursive", action="store_true", help="Parse projects recursively"
+    build_parser.add_argument(
+        "-o", "--offline", action="store_true", help="Offline mode"
     )
-    parser.add_argument("-o", "--offline", action="store_true", help="Offline mode")
-    parser.add_argument(
+    build_parser.add_argument(
         "-j", "--jobs", type=int, default=4, help="Maximum concurrent tasks"
     )
 
-    # Library packing arguments
-    parser.add_argument(
+    # Library packing arguments (build-specific)
+    build_parser.add_argument(
         "--cache-dir",
         type=str,
         default=None,
         help="Custom cache directory for dependencies",
     )
-    parser.add_argument(
+    build_parser.add_argument(
         "--archive-format",
         type=str,
-        choices=("zip", "7z", "nsis"),
-        default="zip",
+        choices=[af.value for af in ArchiveFormat],
+        default=ArchiveFormat.ZIP.value,
         help="Archive format for dependencies",
     )
-    parser.add_argument(
+    build_parser.add_argument(
         "--mirror",
         type=str,
-        default="aliyun",
-        choices=("pypi", "tsinghua", "aliyun", "ustc", "douban", "tencent"),
+        default=MirrorSource.ALIYUN.value,
+        choices=[ms.value for ms in MirrorSource],
         help="PyPI mirror source for faster downloads",
     )
 
-    return parser.parse_args()
-
-
-async def _execute_build_workflow(config: WorkflowConfig) -> None:
-    """Execute the build workflow."""
-    workflow = PackageWorkflow(directory=config.directory, config=config)
+    # Archive options (optional post-build step)
+    build_parser.add_argument(
+        "--archive",
+        "-a",
+        type=str,
+        nargs="?",
+        const="zip",
+        default=None,
+        choices=["zip", "tar", "gztar", "bztar", "xztar", "7z", "nsis"],
+        help="Create archive after build (default format: zip if flag used)",
+    )
 
-    try:
-        await workflow.execute()
-        logger.info("Packaging completed successfully!")
-    except Exception as e:
-        logger.error(f"Packaging failed: {e}")
-        raise
+    return parser.parse_args()
 
 
 def main() -> None:
-    """Main entry point for package workflow tool."""
+    """Main entry point for package workflow tool using factory pattern."""
     args = parse_args()
 
+    # Configure logging level
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
 
-    if args.action in {"version", "v"}:
-        logger.info(f"pypack {__version__} (build {__build__})")
-        return
-
-    if args.action in {"list", "l"}:
-        list_projects(cwd)
-        return
-
-    if args.action in {"run", "r"}:
-        run_project(args.project, cwd)
-        return
-
-    if args.action in {"clean", "c"}:
-        clean_project(cwd)
-        return
-
-    cache_dir = Path(args.cache_dir) if args.cache_dir else None
-    config = WorkflowConfig(
-        directory=cwd,
-        project_name=args.project,
-        python_version=args.python_version,
-        loader_type=args.loader_type,
-        entry_suffix=args.entry_suffix,
-        generate_loader=not args.no_loader,
-        recursive=args.recursive,
-        offline=args.offline,
-        max_concurrent=args.jobs,
-        debug=args.debug,
-        cache_dir=cache_dir,
-        archive_format=args.archive_format,
-        mirror=args.mirror,
+    # Build workflow configuration using factory pattern
+    config = ConfigFactory.create_from_args(args, cwd)
+
+    workflow = PackageWorkflow(
+        root_dir=config.directory,
+        config=config,
+        cleaning_strategy=StandardCleaningStrategy(),
     )
 
-    asyncio.run(_execute_build_workflow(config))
+    # Command dispatch using pattern matching
+    command = args.command
+
+    if command in ("version", "v"):
+        logger.info(f"pypack {__version__} (build {__build__})")
+    elif command in ("list", "l", "ls"):
+        workflow.list_projects()
+    elif command in ("run", "r"):
+        workflow.run_project(args.project, args.args)
+    elif command in ("clean", "c"):
+        workflow.clean_project()
+    elif command in ("build", "b"):
+        try:
+            asyncio.run(workflow.build())
+            logger.info("Packaging completed successfully!")
+        except Exception as e:
+            logger.error(f"Packaging failed: {e}")
+            raise
 
 
 if __name__ == "__main__":