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

sfi/pylibpack/pylibpack.py

@@ -1,7 +1,7 @@
 """Python Library Packager - Download and pack Python dependencies with caching support.
 
 This module provides functionality to:
-1. Read project information from projects.json or run projectparse if needed
+1. Read project information from projects.json or run pyprojectparse if needed
 2. Download dependencies to local .cache directory
 3. Pack dependencies into a distributable format
 4. Support batch processing multiple projects recursively
@@ -13,17 +13,24 @@ import argparse
 import json
 import logging
 import platform
+import re
 import shutil
 import subprocess
 import sys
+import tarfile
 import tempfile
 import time
+import zipfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Pattern
 
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+from sfi.pyprojectparse.pyprojectparse import Project, Solution
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 __version__ = "1.0.0"
@@ -31,6 +38,8 @@ __build__ = "20260120"
 
 DEFAULT_CACHE_DIR = Path.home() / ".pysfi" / ".cache" / "python-libs"
 
+MAX_DEPTH = 50  # Maximum recursion depth to prevent infinite loops
+
 PYPI_MIRRORS = {
     "pypi": "https://pypi.org/simple",
     "tsinghua": "https://pypi.tuna.tsinghua.edu.cn/simple",
@@ -109,15 +118,6 @@ class CacheMetadata:
     timestamp: float
 
 
-@dataclass
-class ProjectInfo:
-    """Project information for packing dependencies."""
-
-    name: str
-    dir: Path
-    info: dict
-
-
 DEV_TOOLS = frozenset({
     "sphinx",
     "sphinx_rtd_theme",
@@ -139,164 +139,242 @@ DEV_PATTERNS = frozenset({"dev", "test", "docs", "lint", "example"})
 TYPING_PATTERNS = frozenset({"stubs", "typing", "types"})
 
 
-def normalize_package_name(name: str) -> str:
-    """Normalize package name to lowercase with underscores.
+@dataclass
+class OptimizationRule:
+    """Defines an optimization rule for a specific library.
 
-    Args:
-        name: Package name to normalize
+    Attributes:
+        library_name: The name of the library to apply the rule to.
+        exclude_patterns: A list of patterns to exclude from the library.
+        include_patterns: A list of patterns to include in the library.
 
-    Returns:
-        Normalized package name
     """
-    return name.lower().replace("-", "_")
-
 
-def should_skip_dependency(req_name: str, has_extras: bool = False) -> bool:
-    """Check if a dependency should be skipped based on common patterns.
-
-    Args:
-        req_name: Package name
-        has_extras: Whether the requirement has extras
+    library_name: str = field(default_factory=str)
+    exclude_patterns: list[str] = field(default_factory=list)
+    include_patterns: list[str] = field(default_factory=list)
 
-    Returns:
-        True if should skip, False otherwise
+    def __post_init__(self):
+        """Compile regex patterns after initialization."""
+        self.exclude_compiled: list[Pattern] = [
+            re.compile(p) for p in self.exclude_patterns
+        ]
+        self.include_compiled: list[Pattern] = [
+            re.compile(p) for p in self.include_patterns
+        ]
+
+
+class SelectiveExtractionStrategy:
+    """Optimization strategy that applies inclusion/exclusion rules to specific libraries.
+
+    This strategy works as follows:
+    1. First, apply universal exclusion rules (doc, test, example, demo, etc.)
+    2. Then, apply library-specific exclusion rules
+    3. Finally, apply inclusion rules (only files matching include patterns are kept)
     """
-    req_lower = req_name.lower()
 
-    # Skip extras
-    if has_extras:
-        return True
+    # Universal exclusion patterns - applied to all libraries
+    UNIVERSAL_EXCLUDE_PATTERNS = frozenset({
+        "doc",
+        "docs",
+        "test",
+        "tests",
+        "example",
+        "examples",
+        "demo",
+        "demos",
+        "sample",
+        "samples",
+        "benchmark",
+        "benchmarks",
+        "tutorial",
+        "tutorials",
+        "notebook",
+        "notebooks",
+        "license",
+        "licenses",
+    })
 
-    # Skip dev/test/docs/lint/example patterns
-    if any(keyword in req_lower for keyword in DEV_PATTERNS):
-        return True
+    def __init__(
+        self,
+        rules: list[OptimizationRule] | None = None,
+        apply_universal_rules: bool = True,
+    ):
+        """Initialize the strategy with optimization rules.
 
-    # Skip typing/stubs dependencies
-    if any(keyword in req_lower for keyword in TYPING_PATTERNS):
-        return True
+        Args:
+            rules: List of optimization rules to apply
+            apply_universal_rules: Whether to apply universal exclusion rules (default: True)
+        """
+        self.rules: dict[str, OptimizationRule] = {}
+        self.apply_universal_rules = apply_universal_rules
+
+        if rules:
+            for rule in rules:
+                self.rules[rule.library_name.lower()] = rule
+
+        # Default rules for common libraries
+        if not rules:
+            self._setup_default_rules()
+
+        # Compile universal exclusion patterns for faster matching
+        self._universal_exclude_compiled = [
+            re.compile(f"(^|/)({pattern})(/|$)", re.IGNORECASE)
+            for pattern in self.UNIVERSAL_EXCLUDE_PATTERNS
+        ]
+
+    def _setup_default_rules(self):
+        """Setup default optimization rules for common libraries."""
+        # Get the rules directory
+        rules_dir = Path(__file__).parent / "rules"
+
+        if not rules_dir.exists() or not rules_dir.is_dir():
+            logger.warning(f"Rules directory not found: {rules_dir}")
+            return
+
+        # Load all JSON rule files
+        for rule_file in rules_dir.glob("*.json"):
+            try:
+                with open(rule_file, encoding="utf-8") as f:
+                    rule_data = json.load(f)
 
-    # Skip common dev tools
-    return req_lower.replace("-", "_") in DEV_TOOLS
+                # Convert JSON data to OptimizationRule
+                rule = OptimizationRule(
+                    library_name=rule_data["library_name"],
+                    exclude_patterns=rule_data["exclude_patterns"],
+                    include_patterns=rule_data["include_patterns"],
+                )
 
+                self.rules[rule.library_name.lower()] = rule
+                logger.debug(
+                    f"Loaded optimization rule for {rule.library_name} from {rule_file.name}"
+                )
 
-class ProjectParser:
-    """Parse project information from projects.json or run projectparse."""
+            except Exception as e:
+                logger.warning(f"Failed to load rule from {rule_file.name}: {e}")
 
-    @staticmethod
-    def ensure_projects_json(directory: Path) -> Path | None:
-        """Ensure projects.json exists by running projectparse if needed.
+    def _matches_universal_exclude_pattern(self, relative_path: str) -> bool:
+        """Check if file path matches any universal exclusion pattern.
 
         Args:
-            directory: Directory to check for projects.json
+            relative_path: Relative path to the file
 
         Returns:
-            Path to projects.json if successful, None otherwise
+            True if path should be excluded, False otherwise
         """
-        projects_json = directory / "projects.json"
-        if projects_json.exists():
-            logger.debug(f"Found existing projects.json at {projects_json}")
-            return projects_json
+        return any(
+            pattern.search(relative_path)
+            for pattern in self._universal_exclude_compiled
+        )
 
-        logger.info("projects.json not found, running projectparse...")
-        try:
-            from sfi.projectparse import projectparse as pp
+    def should_extract_file(self, library_name: str, file_path: Path) -> bool:
+        """Determine if a file should be extracted based on library-specific rules.
 
-            # Save and restore original argv
-            original_argv = sys.argv.copy()
-            sys.argv = ["projectparse", "--directory", str(directory), "--output", "projects.json", "--recursive"]
-            try:
-                pp.main()
-            finally:
-                sys.argv = original_argv
+        Args:
+            library_name: Name of the library
+            file_path: Path to the file to check
 
-            if projects_json.exists():
-                logger.info("projectparse completed successfully")
-                return projects_json
-            else:
-                logger.error("projectparse failed to generate projects.json")
-                return None
-        except ImportError:
-            # Fallback: run projectparse as script
-            sfi_dir = Path(__file__).parent.parent.parent
-            projectparse_script = sfi_dir / "projectparse" / "projectparse.py"
+        Returns:
+            True if the file should be extracted, False otherwise
+        """
+        lib_name_lower = library_name.lower()
+        relative_path = file_path.as_posix().lower()
+
+        # First, apply universal exclusion rules (applied to all libraries)
+        if self.apply_universal_rules and self._matches_universal_exclude_pattern(
+            relative_path
+        ):
+            logger.debug(
+                f"Excluding {file_path} from {library_name} (matches universal exclusion pattern)"
+            )
+            return False
 
-            if not projectparse_script.exists():
-                logger.error(f"Cannot find projectparse script at {projectparse_script}")
-                return None
+        # If no specific rule exists for this library, extract everything
+        if lib_name_lower not in self.rules:
+            logger.debug(f"No specific rules for {library_name}, including {file_path}")
+            return True
 
-            result = subprocess.run(
-                [
-                    sys.executable,
-                    str(projectparse_script),
-                    "--directory",
-                    str(directory),
-                    "--output",
-                    "projects.json",
-                    "--recursive",
-                ],
-                capture_output=True,
-                text=True,
-                cwd=directory,
-            )
+        rule = self.rules[lib_name_lower]
 
-            if result.returncode == 0 and projects_json.exists():
-                logger.info("projectparse completed successfully")
-                return projects_json
+        logger.debug(
+            f"Checking {file_path} for {library_name} with {len(rule.exclude_compiled)} exclude and {len(rule.include_compiled)} include patterns"
+        )
 
-            logger.error(f"projectparse failed: {result.stderr}")
-            return None
-        except Exception as e:
-            logger.error(f"Failed to run projectparse: {e}")
-            return None
+        # Then, apply library-specific exclusion rules - if file matches any exclude pattern, skip it
+        for exclude_pattern in rule.exclude_compiled:
+            if exclude_pattern.search(relative_path):
+                logger.debug(
+                    f"Excluding {file_path} from {library_name} (matches exclude pattern: {exclude_pattern.pattern})"
+                )
+                return False
+
+        # If inclusion patterns are defined, only include files that match at least one
+        if rule.include_compiled:
+            for include_pattern in rule.include_compiled:
+                if include_pattern.search(relative_path):
+                    logger.debug(
+                        f"Including {file_path} from {library_name} (matches include pattern: {include_pattern.pattern})"
+                    )
+                    return True
+            # If we have inclusion rules but the file doesn't match any, exclude it
+            logger.debug(
+                f"Excluding {file_path} from {library_name} (doesn't match any include patterns)"
+            )
+            return False
 
-    @staticmethod
-    def load_projects_json(projects_json: Path) -> dict | None:
-        """Load project information from projects.json.
+        # If no inclusion rules are defined, include the file (after exclusion check)
+        logger.debug(
+            f"Including {file_path} from {library_name} (passed exclusion filters)"
+        )
+        return True
 
-        Args:
-            projects_json: Path to projects.json file
+    def get_library_names_with_rules(self) -> set[str]:
+        """Get the names of libraries that have optimization rules defined.
 
         Returns:
-            Dictionary of project information, None if failed
+            Set of library names with optimization rules
         """
-        try:
-            with open(projects_json, encoding="utf-8") as f:
-                return json.load(f)
-        except Exception as e:
-            logger.error(f"Failed to load projects.json: {e}")
-            return None
+        return set(self.rules.keys())
 
-    @staticmethod
-    def parse_requirements_from_project(project_info: dict) -> list[Dependency]:
-        """Parse dependencies from project info.
 
-        Args:
-            project_info: Project information dictionary from projects.json
+def normalize_package_name(name: str) -> str:
+    """Normalize package name to lowercase with underscores.
 
-        Returns:
-            List of Dependency objects
-        """
-        from packaging.requirements import Requirement
+    Args:
+        name: Package name to normalize
 
-        dependencies = []
-        dep_list = project_info.get("dependencies", [])
+    Returns:
+        Normalized package name
+    """
+    return name.lower().replace("-", "_")
 
-        for dep_str in dep_list:
-            try:
-                req = Requirement(dep_str)
 
-                if should_skip_dependency(req.name, bool(req.extras)):
-                    logger.info(f"Skipping: {dep_str}")
-                    continue
+def should_skip_dependency(req_name: str, has_extras: bool = False) -> bool:
+    """Check if a dependency should be skipped based on common patterns.
 
-                dep = Dependency(name=req.name, version=str(req.specifier) if req.specifier else None)
-                dependencies.append(dep)
-                logger.debug(f"Parsed dependency: {dep}")
-            except Exception as e:
-                logger.warning(f"Failed to parse requirement '{dep_str}': {e}")
+    Args:
+        req_name: Package name
+        has_extras: Whether the requirement has extras
 
-        logger.info(f"Parsed {len(dependencies)} dependencies for project")
-        return dependencies
+    Returns:
+        True if should skip, False otherwise
+    """
+    req_lower = req_name.lower()
+
+    # Skip extras
+    if has_extras:
+        return True
+
+    # Skip dev/test/docs/lint/example patterns
+    if any(keyword in req_lower for keyword in DEV_PATTERNS):
+        return True
+
+    # Skip typing/stubs dependencies
+    if any(keyword in req_lower for keyword in TYPING_PATTERNS):
+        return True
+
+    # Skip common dev tools
+    return req_lower.replace("-", "_") in DEV_TOOLS
 
 
 class LibraryCache:
@@ -311,8 +389,12 @@ class LibraryCache:
         self.cache_dir = cache_dir or DEFAULT_CACHE_DIR
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.metadata_file = self.cache_dir / "metadata.json"
+        # In-memory cache for extracted dependencies to avoid repeated IO
+        self._dependencies_cache: dict[Path, set[str]] = {}
 
-    def get_package_path(self, package_name: str, version: str | None = None) -> Path | None:
+    def get_package_path(
+        self, package_name: str, version: str | None = None
+    ) -> Path | None:
         """Get cached package path if available.
 
         Args:
@@ -322,17 +404,31 @@ class LibraryCache:
         Returns:
             Path to cached package or None
         """
-        # First try filesystem lookup (works even if metadata is missing)
+        # First try filesystem lookup for wheel files (works even if metadata is missing)
         for whl_file in self.cache_dir.glob("*.whl"):
             parsed_name = self._extract_package_name_from_wheel(whl_file)
             if parsed_name == package_name:
-                logger.debug(f"Cache hit (filesystem): {package_name}")
+                logger.debug(f"Cache hit (filesystem wheel): {package_name}")
                 return whl_file
 
+        # Try filesystem lookup for sdist files (.tar.gz, .zip)
+        for sdist_file in self.cache_dir.glob("*.tar.gz"):
+            parsed_name = self._extract_package_name_from_sdist(sdist_file)
+            if parsed_name == package_name:
+                logger.debug(f"Cache hit (filesystem sdist): {package_name}")
+                return sdist_file
+        for sdist_file in self.cache_dir.glob("*.zip"):
+            parsed_name = self._extract_package_name_from_sdist(sdist_file)
+            if parsed_name == package_name:
+                logger.debug(f"Cache hit (filesystem sdist): {package_name}")
+                return sdist_file
+
         # Fallback to metadata lookup
         metadata = self._load_metadata()
         for info in metadata.values():
-            if info["name"] == package_name and (version is None or info.get("version") == version):
+            if info["name"] == package_name and (
+                version is None or info.get("version") == version
+            ):
                 path = self.cache_dir / info["path"]
                 if path.exists():
                     logger.debug(f"Cache hit (metadata): {package_name}")
@@ -361,8 +457,46 @@ class LibraryCache:
         return None
 
     @staticmethod
-    def _extract_dependencies_from_wheel(wheel_file: Path) -> set[str]:
-        """Extract dependencies from wheel METADATA file.
+    def _extract_package_name_from_sdist(sdist_file: Path) -> str | None:
+        """Extract package name from source distribution file (.tar.gz or .zip).
+
+        Args:
+            sdist_file: Path to sdist file
+
+        Returns:
+            Package name or None
+        """
+        try:
+            # Handle .tar.gz files (e.g., package_name-1.0.0.tar.gz)
+            if (
+                sdist_file.suffixes
+                and ".tar" in sdist_file.suffixes
+                and ".gz" in sdist_file.suffixes
+            ):
+                # Remove both .tar.gz extensions by removing the last 7 characters (.tar.gz)
+                stem_without_ext = (
+                    sdist_file.stem
+                )  # This removes .gz, leaving package-1.0.0.tar
+                # Now remove the remaining .tar
+                if stem_without_ext.endswith(".tar"):
+                    stem_without_ext = stem_without_ext[:-4]  # Remove .tar
+                parts = stem_without_ext.rsplit(
+                    "-", 1
+                )  # Split from right: ["package_name", "1.0.0"]
+                if len(parts) >= 1 and parts[0]:
+                    return normalize_package_name(parts[0])
+            # Handle .zip files
+            elif sdist_file.suffix == ".zip":
+                filename = sdist_file.stem  # Remove .zip extension
+                parts = filename.rsplit("-", 1)
+                if len(parts) >= 1 and parts[0]:
+                    return normalize_package_name(parts[0])
+        except Exception as e:
+            logger.debug(f"Failed to extract package name from {sdist_file}: {e}")
+        return None
+
+    def _extract_dependencies_from_wheel(self, wheel_file: Path) -> set[str]:
+        """Extract dependencies from wheel METADATA file with caching.
 
         Args:
             wheel_file: Path to wheel file
@@ -370,17 +504,32 @@ class LibraryCache:
         Returns:
             Set of package names (normalized)
         """
+        # Check cache first
+        if wheel_file in self._dependencies_cache:
+            return self._dependencies_cache[wheel_file]
+
+        # Check if it's an sdist file (.tar.gz or .zip)
+        if wheel_file.suffix in (".gz", ".zip"):
+            dependencies = self._extract_dependencies_from_sdist(wheel_file)
+            self._dependencies_cache[wheel_file] = dependencies
+            return dependencies
+
         try:
             import re
             import zipfile
 
             dependencies: set[str] = set()
             with zipfile.ZipFile(wheel_file, "r") as zf:
-                metadata_files = [name for name in zf.namelist() if name.endswith("METADATA")]
+                metadata_files = [
+                    name for name in zf.namelist() if name.endswith("METADATA")
+                ]
                 if not metadata_files:
+                    self._dependencies_cache[wheel_file] = dependencies
                     return dependencies
 
-                metadata_content = zf.read(metadata_files[0]).decode("utf-8", errors="ignore")
+                metadata_content = zf.read(metadata_files[0]).decode(
+                    "utf-8", errors="ignore"
+                )
 
                 # Parse dependencies from METADATA
                 for line in metadata_content.splitlines():
@@ -388,7 +537,11 @@ class LibraryCache:
                         dep_str = line.split(":", 1)[1].strip()
 
                         # Skip extras dependencies
-                        if re.search(r'extra\s*==\s*["\']?([^"\';\s]+)["\']?', dep_str, re.IGNORECASE):
+                        if re.search(
+                            r'extra\s*==\s*["\']?([^"\';\s]+)["\']?',
+                            dep_str,
+                            re.IGNORECASE,
+                        ):
                             logger.debug(f"Skipping extra dependency: {dep_str}")
                             continue
 
@@ -403,12 +556,155 @@ class LibraryCache:
                         except Exception:
                             pass
 
+            # Cache the result
+            self._dependencies_cache[wheel_file] = dependencies
             return dependencies
         except Exception as e:
-            logger.warning(f"Failed to extract dependencies from {wheel_file.name}: {e}")
+            logger.warning(
+                f"Failed to extract dependencies from {wheel_file.name}: {e}"
+            )
             return set()
 
-    def add_package(self, package_name: str, package_path: Path, version: str | None = None) -> None:
+    def _extract_dependencies_from_sdist(self, sdist_file: Path) -> set[str]:
+        """Extract dependencies from source distribution file with caching.
+
+        Args:
+            sdist_file: Path to sdist file (.tar.gz or .zip)
+
+        Returns:
+            Set of package names (normalized)
+        """
+
+        dependencies: set[str] = set()
+
+        try:
+            # Handle .tar.gz files
+            if sdist_file.suffix == ".gz":
+                with tarfile.open(sdist_file, "r:gz") as tf:
+                    for member in tf.getmembers():
+                        # Look for PKG-INFO or METADATA file in the root of the package
+                        if member.name.endswith("PKG-INFO") or member.name.endswith(
+                            "METADATA"
+                        ):
+                            # Only use PKG-INFO/METADATA files in the root directory
+                            # Count the number of slashes in the path
+                            path_parts = member.name.split("/")
+                            if len(path_parts) == 2 or (
+                                len(path_parts) == 3
+                                and path_parts[2] in ("PKG-INFO", "METADATA")
+                            ):
+                                content = tf.extractfile(member)
+                                if content:
+                                    metadata_content = content.read().decode(
+                                        "utf-8", errors="ignore"
+                                    )
+                                    dependencies = self._parse_metadata_content(
+                                        metadata_content
+                                    )
+                                    logger.debug(
+                                        f"Extracted dependencies from {member.name} in {sdist_file.name}"
+                                    )
+                                    break
+            # Handle .zip files
+            elif sdist_file.suffix == ".zip":
+                with zipfile.ZipFile(sdist_file, "r") as zf:
+                    for name in zf.namelist():
+                        # Look for PKG-INFO or METADATA file in the root of the package
+                        if name.endswith("PKG-INFO") or name.endswith("METADATA"):
+                            path_parts = name.split("/")
+                            if len(path_parts) == 2 or (
+                                len(path_parts) == 3
+                                and path_parts[2] in ("PKG-INFO", "METADATA")
+                            ):
+                                metadata_content = zf.read(name).decode(
+                                    "utf-8", errors="ignore"
+                                )
+                                dependencies = self._parse_metadata_content(
+                                    metadata_content
+                                )
+                                logger.debug(
+                                    f"Extracted dependencies from {name} in {sdist_file.name}"
+                                )
+                                break
+        except Exception as e:
+            logger.warning(
+                f"Failed to extract dependencies from sdist {sdist_file.name}: {e}"
+            )
+
+        return dependencies
+
+    @staticmethod
+    def _parse_metadata_content(metadata_content: str) -> set[str]:
+        """Parse metadata content (PKG-INFO or METADATA) to extract dependencies.
+
+        Args:
+            metadata_content: Content of PKG-INFO or METADATA file
+
+        Returns:
+            Set of package names (normalized)
+        """
+        import re
+
+        dependencies: set[str] = set()
+        try:
+            for line in metadata_content.splitlines():
+                # Look for Requires-Dist or Requires field
+                if line.startswith("Requires-Dist:") or line.startswith("Requires:"):
+                    if line.startswith("Requires:"):
+                        # Requires field contains comma-separated list
+                        dep_str = line.split(":", 1)[1].strip()
+                        for req_str in re.split(r",\s*", dep_str):
+                            req_str = req_str.strip()
+                            if req_str:
+                                dependencies.update(
+                                    LibraryCache._parse_single_requirement(req_str)
+                                )
+                    else:
+                        # Requires-Dist field
+                        dep_str = line.split(":", 1)[1].strip()
+                        dependencies.update(
+                            LibraryCache._parse_single_requirement(dep_str)
+                        )
+        except Exception as e:
+            logger.debug(f"Failed to parse metadata content: {e}")
+
+        return dependencies
+
+    @staticmethod
+    def _parse_single_requirement(req_str: str) -> set[str]:
+        """Parse a single requirement string and extract package name.
+
+        Args:
+            req_str: Requirement string (e.g., "numpy>=1.20.0", "package[extra]>=1.0")
+
+        Returns:
+            Set containing the normalized package name, or empty set if should skip
+        """
+        import re
+
+        try:
+            # Skip extras dependencies
+            if re.search(
+                r'extra\s*==\s*["\']?([^"\';\s]+)["\']?', req_str, re.IGNORECASE
+            ):
+                logger.debug(f"Skipping extra dependency: {req_str}")
+                return set()
+
+            from packaging.requirements import Requirement
+
+            req = Requirement(req_str)
+            if not should_skip_dependency(req.name, bool(req.extras)):
+                dep_name = normalize_package_name(req.name)
+                logger.debug(f"Found core dependency: {dep_name}")
+                return {dep_name}
+        except Exception:
+            pass
+
+        return set()
+
+    def add_package(
+        self, package_name: str, package_path: Path, version: str | None = None
+    ) -> None:
         """Add package to cache.
 
         Args:
@@ -416,13 +712,16 @@ class LibraryCache:
             package_path: Path to package files
             version: Package version
         """
+        # Normalize package name to ensure consistency
+        normalized_name = normalize_package_name(package_name)
+
         # Copy package files to cache (flat structure for wheels, nested for dirs)
         if package_path.is_dir():
-            dest_dir = self.cache_dir / package_name
+            dest_dir = self.cache_dir / normalized_name
             if dest_dir.exists():
                 shutil.rmtree(dest_dir)
             shutil.copytree(package_path, dest_dir)
-            relative_path = package_name
+            relative_path = normalized_name
         else:
             dest_file = self.cache_dir / package_path.name
             shutil.copy2(package_path, dest_file)
@@ -431,14 +730,14 @@ class LibraryCache:
         # Update metadata using CacheMetadata dataclass
         metadata = self._load_metadata()
         metadata[str(package_path)] = CacheMetadata(
-            name=package_name,
+            name=normalized_name,
             version=version,
             path=relative_path,
             timestamp=time.time(),
         ).__dict__
         self._save_metadata(metadata)
 
-        logger.info(f"Cached package: {package_name}")
+        logger.info(f"Cached package: {normalized_name}")
 
     def _load_metadata(self) -> dict[str, Any]:
         """Load cache metadata.
@@ -469,13 +768,19 @@ class LibraryCache:
         if self.cache_dir.exists():
             shutil.rmtree(self.cache_dir)
             self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._dependencies_cache.clear()  # Clear in-memory dependencies cache
         logger.info("Cache cleared")
 
 
 class LibraryDownloader:
     """Download Python packages from PyPI."""
 
-    def __init__(self, cache: LibraryCache, python_version: str | None = None, mirror: str = "pypi"):
+    def __init__(
+        self,
+        cache: LibraryCache,
+        python_version: str | None = None,
+        mirror: str = "pypi",
+    ):
         """Initialize downloader.
 
         Args:
@@ -484,19 +789,19 @@ class LibraryDownloader:
             mirror: PyPI mirror source (pypi, tsinghua, aliyun, ustc, douban, tencent)
         """
         self.cache = cache
-        self.python_version = python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
-        self.platform_name = platform.system().lower() + "_" + platform.machine().lower()
+        self.python_version = (
+            python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
+        )
+        self.platform_name = (
+            platform.system().lower() + "_" + platform.machine().lower()
+        )
         self.mirror_url = PYPI_MIRRORS.get(mirror, PYPI_MIRRORS["pypi"])
         self.pip_executable = self._find_pip_executable()
 
     @staticmethod
     def _find_pip_executable() -> str | None:
-        """Find pip executable in the system.
-
-        Returns:
-            Path to pip executable or None
-        """
-        return next((shutil.which(cmd) for cmd in ("pip", "pip3")), None)
+        """Find pip executable in the system."""
+        return shutil.which("pip") or shutil.which("pip3")
 
     def _download_package(self, dep: Dependency, dest_dir: Path) -> Path | None:
         """Download a single package without dependencies.
@@ -506,10 +811,12 @@ class LibraryDownloader:
             dest_dir: Destination directory
 
         Returns:
-            Path to downloaded wheel file or None
+            Path to downloaded package file (wheel or sdist) or None
         """
         if not self.pip_executable:
-            logger.error("pip not found. Please install pip: python -m ensurepip --upgrade")
+            logger.error(
+                "pip not found. Please install pip: python -m ensurepip --upgrade"
+            )
             return None
 
         logger.info(f"Downloading: {dep}")
@@ -535,12 +842,26 @@ class LibraryDownloader:
                 logger.warning(f"pip download failed for {dep}: {result.stderr}")
                 return None
 
-            # Find and copy the downloaded wheel file
+            # Prefer wheel files over sdist files
+            downloaded_file = None
             for file_path in Path(temp_dir).glob("*.whl"):
-                self.cache.add_package(dep.name, file_path, dep.version)
-                shutil.copy2(file_path, dest_dir / file_path.name)
-                logger.info(f"Downloaded: {file_path.name}")
-                return dest_dir / file_path.name
+                downloaded_file = file_path
+                break
+
+            # If no wheel file, look for sdist files (.tar.gz or .zip)
+            if not downloaded_file:
+                for file_path in Path(temp_dir).glob("*.tar.gz"):
+                    downloaded_file = file_path
+                    break
+                for file_path in Path(temp_dir).glob("*.zip"):
+                    downloaded_file = file_path
+                    break
+
+            if downloaded_file:
+                self.cache.add_package(dep.name, downloaded_file, dep.version)
+                shutil.copy2(downloaded_file, dest_dir / downloaded_file.name)
+                logger.info(f"Downloaded: {downloaded_file.name}")
+                return dest_dir / downloaded_file.name
 
         return None
 
@@ -562,38 +883,57 @@ class LibraryDownloader:
         """
         dest_dir.mkdir(parents=True, exist_ok=True)
 
-        results: dict[str, bool] = {}
+        # Use list of tuples for thread-safe result collection
+        # Tuple format: (package_name, success_flag)
+        results_list: list[tuple[str, bool]] = []
         cached_count = 0
+        cached_packages: set[str] = set()  # Track cached package names efficiently
 
         logger.info(f"Total direct dependencies: {len(dependencies)}")
         logger.info(f"Using mirror: {self.mirror_url}")
 
-        # Check cache and mark cached packages
+        # Check cache and mark cached packages (single-threaded, safe)
         for dep in dependencies:
             if self.cache.get_package_path(dep.name, dep.version):
-                results[dep.name] = True
+                normalized_dep_name = normalize_package_name(dep.name)
+                results_list.append((normalized_dep_name, True))
+                cached_packages.add(normalized_dep_name)
                 cached_count += 1
                 logger.info(f"Using cached package: {dep}")
 
         # Download remaining packages concurrently
-        remaining_deps = [dep for dep in dependencies if dep.name not in results or not results[dep.name]]
+        remaining_deps = [
+            dep
+            for dep in dependencies
+            if normalize_package_name(dep.name) not in cached_packages
+        ]
         downloaded_count = 0
 
         if remaining_deps:
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                future_to_dep = {executor.submit(self._download_package, dep, dest_dir): dep for dep in remaining_deps}
+                future_to_dep = {
+                    executor.submit(self._download_package, dep, dest_dir): dep
+                    for dep in remaining_deps
+                }
 
                 for future in as_completed(future_to_dep):
                     dep = future_to_dep[future]
                     try:
                         wheel_file = future.result()
-                        results[dep.name] = wheel_file is not None
+                        normalized_dep_name = normalize_package_name(dep.name)
+                        results_list.append((
+                            normalized_dep_name,
+                            wheel_file is not None,
+                        ))
                         if wheel_file:
                             downloaded_count += 1
                     except Exception as e:
-                        logger.error(f"Error processing {dep.name}: {e}")
-                        results[dep.name] = False
+                        normalized_dep_name = normalize_package_name(dep.name)
+                        logger.error(f"Error processing {normalized_dep_name}: {e}")
+                        results_list.append((normalized_dep_name, False))
 
+        # Convert to dictionary for final result
+        results = dict(results_list)
         successful = sum(1 for v in results.values() if v)
         logger.info(
             f"Processed {successful}/{len(dependencies)} ({cached_count} cached, {downloaded_count} downloaded)"
@@ -616,6 +956,8 @@ class PyLibPack:
         cache_dir: Path | None = None,
         python_version: str | None = None,
         mirror: str = "pypi",
+        optimize: bool = True,
+        optimization_strategy: SelectiveExtractionStrategy | None = None,
     ):
         """Initialize library packer.
 
@@ -627,7 +969,15 @@ class PyLibPack:
         self.cache = LibraryCache(cache_dir)
         self.downloader = LibraryDownloader(self.cache, python_version, mirror)
 
-    def pack_project(self, project: ProjectInfo, output_dir: Path, max_workers: int = 4) -> PackResult:
+        # Set up optimization strategy
+        self.optimize = optimize
+        self.optimization_strategy = (
+            optimization_strategy or SelectiveExtractionStrategy() if optimize else None
+        )
+
+    def pack_project(
+        self, project: Project, output_dir: Path, max_workers: int = 4
+    ) -> PackResult:
         """Pack dependencies for a single project.
 
         Args:
@@ -642,9 +992,7 @@ class PyLibPack:
         logger.info(f"Packing dependencies for project: {project.name}")
         logger.info(f"{'=' * 60}")
 
-        dependencies = ProjectParser.parse_requirements_from_project(project.info)
-
-        if not dependencies:
+        if not project.dependencies:
             logger.warning(f"No dependencies found for {project.name}")
             return PackResult(
                 success=False,
@@ -656,42 +1004,62 @@ class PyLibPack:
                 packages_dir=str(output_dir),
             )
 
-        logger.info(f"Found {len(dependencies)} dependencies")
+        logger.info(f"Found {len(project.dependencies)} dependencies")
 
         # Download direct dependencies
         download_result = self.downloader.download_packages(
-            dependencies,
+            project.dependencies,
             self.cache.cache_dir,
             max_workers=max_workers,
         )
 
-        # Build wheel map and collect all required packages recursively
-        wheel_map: dict[str, Path] = {
-            pkg_name: wheel_file
-            for wheel_file in self.cache.cache_dir.glob("*.whl")
-            if (pkg_name := self.cache._extract_package_name_from_wheel(wheel_file))
-        }
-
-        # Recursively collect all dependencies
-        all_packages = self._collect_all_dependencies(wheel_map, list(download_result.results))
+        # Build package map (including both wheel and sdist files) and collect all required packages recursively
+        package_map: dict[str, Path] = {}
+
+        # Add wheel files to package map
+        for wheel_file in self.cache.cache_dir.glob("*.whl"):
+            pkg_name = self.cache._extract_package_name_from_wheel(wheel_file)
+            if pkg_name and pkg_name not in package_map:  # Prefer wheel files
+                normalized_pkg_name = normalize_package_name(pkg_name)
+                package_map[normalized_pkg_name] = wheel_file
+
+        # Add sdist files to package map (only if not already present)
+        for sdist_file in self.cache.cache_dir.glob("*.tar.gz"):
+            pkg_name = self.cache._extract_package_name_from_sdist(sdist_file)
+            if pkg_name and normalize_package_name(pkg_name) not in package_map:
+                normalized_pkg_name = normalize_package_name(pkg_name)
+                package_map[normalized_pkg_name] = sdist_file
+
+        for sdist_file in self.cache.cache_dir.glob("*.zip"):
+            pkg_name = self.cache._extract_package_name_from_sdist(sdist_file)
+            if pkg_name and normalize_package_name(pkg_name) not in package_map:
+                normalized_pkg_name = normalize_package_name(pkg_name)
+                package_map[normalized_pkg_name] = sdist_file
+
+        # Recursively collect all dependencies (pass cache instance for dependency extraction)
+        all_packages = self._collect_all_dependencies(
+            package_map, list(download_result.results), self.cache
+        )
 
         # Extract all required packages (keep order of dependency resolution)
         extracted_packages = []
         for pkg_name in all_packages:
-            if pkg_name in wheel_map:
+            if pkg_name in package_map:
                 # Skip if output directory already exists
                 output_pkg_dir = output_dir / pkg_name
                 if output_pkg_dir.exists():
                     logger.warning(f"Output directory already exists: {output_pkg_dir}")
                     continue
 
-                wheel_file = wheel_map[pkg_name]
-                logger.info(f"Extracting {wheel_file.name}...")
-                self._extract_wheel(wheel_file, output_dir)
+                package_file = package_map[pkg_name]
+                logger.info(f"Extracting {package_file.name}...")
+                self._extract_package(package_file, output_dir, pkg_name)
                 extracted_packages.append(pkg_name)
                 logger.info(f"Extracted {pkg_name}")
 
-        logger.info(f"Pack complete for {project.name}: {download_result.successful}/{download_result.total}")
+        logger.info(
+            f"Pack complete for {project.name}: {download_result.successful}/{download_result.total}"
+        )
 
         return PackResult(
             success=download_result.successful > 0,
@@ -704,57 +1072,232 @@ class PyLibPack:
         )
 
     @staticmethod
-    def _collect_all_dependencies(wheel_map: dict[str, Path], root_packages: list[str]) -> set[str]:
-        """Recursively collect all dependencies from wheel files.
+    def _collect_all_dependencies(
+        package_map: dict[str, Path], root_packages: list[str], cache: LibraryCache
+    ) -> set[str]:
+        """Recursively collect all dependencies from package files (wheel or sdist).
 
         Args:
-            wheel_map: Mapping of package names to wheel files
+            package_map: Mapping of package names to package files (wheel or sdist)
             root_packages: List of root package names to start from
+            cache: LibraryCache instance for extracting dependencies
 
         Returns:
             List of all required package names
         """
         all_packages: set[str] = set()
         visited: set[str] = set()
+        visit_stack: dict[str, int] = {}  # Track visit depth for cycle detection
 
         def visit(pkg_name: str, level: int = 0) -> None:
             """Visit a package and collect its dependencies."""
-            if pkg_name in visited:
+            # Normalize package name for consistency
+            normalized_pkg_name = normalize_package_name(pkg_name)
+
+            # Check for cycles
+            if normalized_pkg_name in visit_stack:
+                logger.warning(
+                    f"Potential circular dependency detected: {normalized_pkg_name} (current depth: {level}, "
+                    f"previous depth: {visit_stack[normalized_pkg_name]})"
+                )
+                return
+
+            # Check depth limit
+            if level > MAX_DEPTH:
+                logger.warning(
+                    f"Maximum dependency depth ({MAX_DEPTH}) reached for {normalized_pkg_name}, stopping recursion"
+                )
+                return
+
+            if normalized_pkg_name in visited:
                 return
 
-            visited.add(pkg_name)
-            all_packages.add(pkg_name)
+            # Mark as visited and track depth
+            visited.add(normalized_pkg_name)
+            visit_stack[normalized_pkg_name] = level
+            all_packages.add(normalized_pkg_name)
 
-            if pkg_name in wheel_map:
-                deps = LibraryCache._extract_dependencies_from_wheel(wheel_map[pkg_name])
-                logger.debug(f"{'  ' * level}{pkg_name} -> {deps}")
+            if normalized_pkg_name in package_map:
+                deps = cache._extract_dependencies_from_wheel(
+                    package_map[normalized_pkg_name]
+                )
+                logger.debug(f"{'  ' * level}{normalized_pkg_name} -> {deps}")
                 for dep in deps:
                     visit(dep, level + 1)
 
+            # Remove from stack when done
+            visit_stack.pop(normalized_pkg_name, None)
+
         for pkg_name in root_packages:
             visit(pkg_name)
 
-        logger.info(f"Collected {len(all_packages)} packages (including recursive dependencies)")
+        logger.info(
+            f"Collected {len(all_packages)} packages (including recursive dependencies)"
+        )
         logger.info(f"Packages: {all_packages}")
         return all_packages
 
-    @staticmethod
-    def _extract_wheel(wheel_file: Path, dest_dir: Path) -> None:
-        """Extract wheel file to destination directory.
+    def _build_and_cache_wheel(self, sdist_file: Path, package_name: str) -> None:
+        """Build wheel from sdist file and cache it for faster future access.
 
         Args:
-            wheel_file: Path to wheel file
+            sdist_file: Path to sdist file (.tar.gz or .zip)
+            package_name: Name of the package
+        """
+        with tempfile.TemporaryDirectory() as temp_wheel_dir:
+            # Use pip wheel to build wheel from sdist
+            result = subprocess.run(
+                [
+                    self.downloader.pip_executable or "pip",
+                    "wheel",
+                    "--no-deps",
+                    "--wheel-dir",
+                    temp_wheel_dir,
+                    "--no-cache-dir",
+                    str(sdist_file),
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                logger.warning(
+                    f"Failed to build wheel from sdist for {package_name}: {result.stderr}"
+                )
+                return
+
+            # Find the built wheel file
+            wheel_files = list(Path(temp_wheel_dir).glob("*.whl"))
+            if wheel_files:
+                wheel_file = wheel_files[0]
+                # Copy wheel to cache directory
+                cache_wheel_path = self.cache.cache_dir / wheel_file.name
+                shutil.copy2(wheel_file, cache_wheel_path)
+
+                # Update cache metadata
+                self.cache.add_package(package_name, wheel_file)
+
+                logger.info(
+                    f"Built and cached wheel: {wheel_file.name} for {package_name}"
+                )
+            else:
+                logger.warning(f"No wheel file was built from sdist for {package_name}")
+
+    def _extract_package(
+        self, package_file: Path, dest_dir: Path, package_name: str
+    ) -> None:
+        """Extract package file (wheel or sdist) to destination directory with optional optimization.
+
+        Args:
+            package_file: Path to package file (wheel or sdist)
             dest_dir: Destination directory
+            package_name: Name of the package being extracted
         """
-        import zipfile
+        logger.info(
+            f"Extracting {package_file.name} for package {package_name} to {dest_dir}"
+        )
 
-        with zipfile.ZipFile(wheel_file, "r") as zf:
-            zf.extractall(dest_dir)
+        # Handle sdist files (.tar.gz or .zip) - install using pip, and build wheel for cache
+        if package_file.suffix == ".gz" or package_file.suffix == ".zip":
+            logger.info(f"Installing sdist file for {package_name} using pip...")
+
+            # Use pip install --target to install sdist to temporary directory
+            with tempfile.TemporaryDirectory() as temp_install_dir:
+                result = subprocess.run(
+                    [
+                        self.downloader.pip_executable or "pip",
+                        "install",
+                        "--target",
+                        temp_install_dir,
+                        "--no-deps",  # Don't install dependencies (we handle them separately)
+                        "--no-cache-dir",
+                        str(package_file),
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+
+                if result.returncode != 0:
+                    logger.error(
+                        f"Failed to install sdist {package_file.name}: {result.stderr}"
+                    )
+                    return
+
+                # Copy installed files to dest_dir, skipping *.dist-info directories
+                temp_install_path = Path(temp_install_dir)
+                for item in temp_install_path.iterdir():
+                    # Skip dist-info directories
+                    if item.name.endswith(".dist-info"):
+                        logger.debug(f"Skipping dist-info directory: {item.name}")
+                        continue
+                    dest_path = dest_dir / item.name
+                    if item.is_dir():
+                        if dest_path.exists():
+                            shutil.rmtree(dest_path)
+                        shutil.copytree(item, dest_path)
+                    else:
+                        shutil.copy2(item, dest_path)
+
+                logger.info(
+                    f"Installed sdist file for {package_name} to site-packages structure"
+                )
+
+            # Build wheel from sdist and cache it for faster future access
+            logger.info(f"Building wheel from sdist for {package_name}...")
+            self._build_and_cache_wheel(package_file, package_name)
+            return
+
+        # Handle wheel files with optional optimization
+        with zipfile.ZipFile(package_file, "r") as zf:
+            if self.optimize and self.optimization_strategy:
+                # Apply optimization strategy - selectively extract files
+                extracted_count = 0
+                skipped_count = 0
+
+                for file_info in zf.filelist:
+                    file_path = Path(file_info.filename)
+                    # Skip dist-info directories
+                    if file_path.name.endswith(".dist-info") or any(
+                        parent.endswith(".dist-info") for parent in file_path.parts
+                    ):
+                        logger.debug(f"Skipping dist-info: {file_info.filename}")
+                        skipped_count += 1
+                        continue
+                    if self.optimization_strategy.should_extract_file(
+                        package_name, file_path
+                    ):
+                        zf.extract(file_info, dest_dir)
+                        extracted_count += 1
+                        logger.debug(f"Extracted {file_path} from {package_name}")
+                    else:
+                        skipped_count += 1
+                        logger.debug(
+                            f"Skipped {file_path} from {package_name} (filtered by optimization strategy)"
+                        )
+
+                logger.info(
+                    f"Extraction complete for {package_name}: {extracted_count} extracted, {skipped_count} skipped"
+                )
+            else:
+                # Extract all files without optimization, but skip dist-info directories
+                for file_info in zf.filelist:
+                    file_path = Path(file_info.filename)
+                    # Skip dist-info directories
+                    if file_path.name.endswith(".dist-info") or any(
+                        parent.endswith(".dist-info") for parent in file_path.parts
+                    ):
+                        logger.debug(f"Skipping dist-info: {file_info.filename}")
+                        continue
+                    zf.extract(file_info, dest_dir)
+                logger.info(
+                    f"All files extracted for {package_name} (no optimization applied, dist-info skipped)"
+                )
 
     def pack(
         self,
-        base_dir: Path,
-        output_dir: Path | None = None,
+        working_dir: Path,
         max_workers: int = 4,
     ) -> BatchPackResult:
         """Pack project dependencies from base directory.
@@ -767,24 +1310,10 @@ class PyLibPack:
         Returns:
             BatchPackResult containing batch packing statistics
         """
-        output_dir = output_dir or base_dir / "dist" / "site-packages"
-        logger.info(f"Starting dependency pack for: {base_dir}")
+        output_dir = working_dir / "dist" / "site-packages"
+        logger.info(f"Starting dependency pack for: {working_dir}")
 
-        # Ensure projects.json exists
-        projects_json = ProjectParser.ensure_projects_json(base_dir)
-        if not projects_json:
-            logger.error("Failed to create projects.json")
-            return BatchPackResult(
-                success=False,
-                total=0,
-                successful=0,
-                failed=0,
-                output_dir=str(output_dir),
-                total_time=0.0,
-            )
-
-        # Load project information
-        projects = ProjectParser.load_projects_json(projects_json)
+        projects = Solution.from_directory(root_dir=working_dir).projects
         if not projects:
             logger.error("Failed to load project information")
             return BatchPackResult(
@@ -804,21 +1333,20 @@ class PyLibPack:
         failed_projects: list[str] = []
         use_current_dir = len(projects) == 1
 
-        for project_name, project_info in projects.items():
-            project_dir = base_dir if use_current_dir else base_dir / project_name
+        for project in projects.values():
+            project_dir = working_dir if use_current_dir else working_dir / project.name
 
             if not project_dir.is_dir():
                 logger.warning(f"Project directory not found: {project_dir}, skipping")
-                failed_projects.append(project_name)
+                failed_projects.append(project.name)
                 continue
 
-            project = ProjectInfo(name=project_name, dir=project_dir, info=project_info)
             result = self.pack_project(project, output_dir, max_workers)
 
             if result.success:
                 success_count += 1
             else:
-                failed_projects.append(project_name)
+                failed_projects.append(project.name)
 
         total_time = time.perf_counter() - total_start
 
@@ -848,19 +1376,29 @@ class PyLibPack:
         self.cache.clear_cache()
 
 
-def main() -> None:
-    """Main entry point for pylibpack tool."""
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
     parser = argparse.ArgumentParser(
         prog="pylibpack",
         description="Python library packer with caching support",
     )
 
     parser.add_argument(
-        "directory", type=str, nargs="?", default=str(Path.cwd()), help="Base directory containing projects"
+        "directory",
+        type=str,
+        nargs="?",
+        default=str(Path.cwd()),
+        help="Base directory containing projects",
+    )
+    parser.add_argument(
+        "--cache-dir", type=str, default=None, help="Custom cache directory"
+    )
+    parser.add_argument(
+        "--python-version", type=str, default=None, help="Target Python version"
+    )
+    parser.add_argument(
+        "-j", "--jobs", type=int, default=4, help="Maximum concurrent downloads"
     )
-    parser.add_argument("--cache-dir", type=str, default=None, help="Custom cache directory")
-    parser.add_argument("--python-version", type=str, default=None, help="Target Python version")
-    parser.add_argument("-j", "--jobs", type=int, default=4, help="Maximum concurrent downloads")
     parser.add_argument(
         "--mirror",
         type=str,
@@ -869,44 +1407,50 @@ def main() -> None:
         help="PyPI mirror source for faster downloads in China",
     )
     parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
-    args = parser.parse_args()
+    parser.add_argument(
+        "--no-optimize",
+        "-no",
+        action="store_true",
+        help="Disable package optimization (extract all files)",
+    )
+    parser.add_argument(
+        "--list-optimizations",
+        "-lo",
+        action="store_true",
+        help="List all available optimization rules",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Main entry point for pylibpack tool."""
+    args = parse_args()
+
+    if args.list_optimizations:
+        strategy = SelectiveExtractionStrategy()
+        logging.info("Available optimization rules:")
+        for lib_name in sorted(strategy.get_library_names_with_rules()):
+            logging.info(f"  - {lib_name}")
+        return
 
     # Setup logging
     if args.debug:
-        logging.getLogger().setLevel(logging.DEBUG)
+        logger.setLevel(logging.DEBUG)
 
     # Initialize packer
     cache_dir = Path(args.cache_dir) if args.cache_dir else None
-    packer = PyLibPack(cache_dir=cache_dir, python_version=args.python_version, mirror=args.mirror)
-
-    # Pack command
-    base_dir = Path(args.directory)
-    output_dir = base_dir / "dist" / "site-packages"
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    try:
-        result = packer.pack(
-            base_dir=base_dir,
-            output_dir=output_dir,
-            max_workers=args.jobs,
-        )
-
-        if result.success:
-            logger.info("=" * 50)
-            logger.info("Packing summary:")
-            logger.info(f"  Total: {result.total}")
-            logger.info(f"  Successful: {result.successful}")
-            logger.info(f"  Failed: {result.failed}")
-            logger.info(f"  Output directory: {result.output_dir}")
-            logger.info(f"  Total time: {result.total_time:.2f}s")
-            logger.info("=" * 50)
-        else:
-            logger.error("Packing failed!")
-            sys.exit(1)
+    optimize = not args.no_optimize
+    packer = PyLibPack(
+        cache_dir=cache_dir,
+        python_version=args.python_version,
+        mirror=args.mirror,
+        optimize=optimize,
+    )
 
-    except Exception as e:
-        logger.error(f"Packing failed: {e}")
-        sys.exit(1)
+    packer.pack(
+        working_dir=Path(args.directory),
+        max_workers=args.jobs,
+    )
 
 
 if __name__ == "__main__":