multi-lang-build 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

multi_lang_build/compiler/pnpm.py

@@ -3,43 +3,42 @@
 from pathlib import Path
 from typing import Final
 import shutil
-import json
 import os
-import time
 
 from multi_lang_build.compiler.base import CompilerBase, BuildResult, CompilerInfo
-from multi_lang_build.mirror.config import get_mirror_config, apply_mirror_environment
+from multi_lang_build.mirror.config import apply_mirror_environment
+from multi_lang_build.compiler.pnpm_support import PnpmProject, PnpmExecutor
 
 
 class PnpmCompiler(CompilerBase):
     """Compiler for pnpm-based frontend projects."""
-    
+
     NAME: Final[str] = "pnpm"
     DEFAULT_MIRROR: Final[str] = "https://registry.npmmirror.com"
-    
+
     def __init__(self, pnpm_path: str | None = None) -> None:
         """Initialize the PNPM compiler.
-        
+
         Args:
             pnpm_path: Optional path to pnpm executable. If None, uses system PATH.
         """
         self._pnpm_path = pnpm_path
         self._version_cache: str | None = None
-    
+
     @property
     def name(self) -> str:
         """Get the compiler name."""
         return self.NAME
-    
+
     @property
     def version(self) -> str:
         """Get the pnpm version."""
         if self._version_cache:
             return self._version_cache
-        
+
         pnpm_executable = self._get_executable_path()
         import subprocess
-        
+
         try:
             result = subprocess.run(
                 [pnpm_executable, "--version"],
@@ -50,14 +49,14 @@ class PnpmCompiler(CompilerBase):
             self._version_cache = result.stdout.strip()
         except Exception:
             self._version_cache = "unknown"
-        
+
         return self._version_cache
-    
+
     @property
     def supported_mirrors(self) -> list[str]:
         """Get list of supported mirror configurations."""
         return ["npm", "pnpm", "yarn"]
-    
+
     def get_info(self) -> CompilerInfo:
         """Get compiler information."""
         return {
@@ -67,158 +66,11 @@ class PnpmCompiler(CompilerBase):
             "default_mirror": self.DEFAULT_MIRROR,
             "executable": self._get_executable_path(),
         }
-    
-    def find_project_root(self, start_path: Path) -> Path | None:
-        """Find the frontend project root directory containing package.json.
-        
-        Searches from start_path up to its ancestors and also checks subdirectories.
-        Returns the first directory containing package.json, or None if not found.
-        
-        Args:
-            start_path: Starting path to search from
-            
-        Returns:
-            Path to project root or None if not found
-        """
-        start_path = start_path.resolve()
-        
-        # Check if start_path itself is the root
-        if (start_path / "package.json").exists():
-            return start_path
-        
-        # Search upwards in the directory tree
-        current = start_path.parent
-        original_cwd = start_path
-        while current != current.parent:
-            if (current / "package.json").exists():
-                return current
-            current = current.parent
-        
-        # Search subdirectories
-        for subdir in start_path.iterdir():
-            if subdir.is_dir() and not subdir.name.startswith("."):
-                subdir_root = self.find_project_root(subdir)
-                if subdir_root:
-                    return subdir_root
-        
-        return None
-    
-    def _execute_in_directory(
-        self,
-        command: list[str],
-        working_dir: Path,
-        environment: dict[str, str],
-        stream_output: bool = True,
-    ) -> BuildResult:
-        """Execute a command in the specified directory, returning to original cwd afterwards.
-
-        Args:
-            command: Command to execute
-            working_dir: Working directory for the command
-            environment: Environment variables
-            stream_output: Whether to stream output in real-time (default: True)
 
-        Returns:
-            BuildResult containing success status and output information
-        """
-        import subprocess
-        import sys
-
-        original_cwd = Path.cwd()
-        full_command = command.copy()
-
-        start_time: float = 0.0
+    def find_project_root(self, start_path: Path) -> Path | None:
+        """Find the frontend project root directory containing package.json."""
+        return PnpmProject.find_root(start_path)
 
-        try:
-            os.chdir(working_dir)
-
-            start_time = time.perf_counter()
-
-            if stream_output:
-                stdout_buffer = []
-                stderr_buffer = []
-
-                process = subprocess.Popen(
-                    full_command,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    env={**os.environ, **environment},
-                )
-
-                stdout_buffer = []
-                stderr_buffer = []
-
-                # Read stdout in real-time
-                if process.stdout:
-                    for line in process.stdout:
-                        line = line.rstrip('\n\r')
-                        stdout_buffer.append(line)
-                        print(line)
-                        sys.stdout.flush()
-
-                # Read stderr in real-time
-                if process.stderr:
-                    for line in process.stderr:
-                        line = line.rstrip('\n\r')
-                        stderr_buffer.append(line)
-                        print(line, file=sys.stderr)
-                        sys.stderr.flush()
-
-                return_code = process.wait()
-                duration = time.perf_counter() - start_time
-
-                return BuildResult(
-                    success=return_code == 0,
-                    return_code=return_code,
-                    stdout='\n'.join(stdout_buffer),
-                    stderr='\n'.join(stderr_buffer),
-                    output_path=working_dir,
-                    duration_seconds=duration,
-                )
-            else:
-                result = subprocess.run(
-                    full_command,
-                    capture_output=True,
-                    text=True,
-                    timeout=3600,
-                    env={**os.environ, **environment},
-                )
-
-                duration = time.perf_counter() - start_time
-
-                return BuildResult(
-                    success=result.returncode == 0,
-                    return_code=result.returncode,
-                    stdout=result.stdout,
-                    stderr=result.stderr,
-                    output_path=working_dir,
-                    duration_seconds=duration,
-                )
-
-        except subprocess.TimeoutExpired:
-            duration = time.perf_counter() - start_time
-            return BuildResult(
-                success=False,
-                return_code=-1,
-                stdout="",
-                stderr="Build timed out after 1 hour",
-                output_path=None,
-                duration_seconds=duration,
-            )
-        except Exception as e:
-            duration = time.perf_counter() - start_time
-            return BuildResult(
-                success=False,
-                return_code=-2,
-                stdout="",
-                stderr=f"Build error: {str(e)}",
-                output_path=None,
-                duration_seconds=duration,
-            )
-        finally:
-            os.chdir(original_cwd)
-    
     def build(
         self,
         source_dir: Path,
@@ -243,10 +95,10 @@ class PnpmCompiler(CompilerBase):
             BuildResult containing success status and output information.
         """
         pnpm_executable = self._get_executable_path()
-        
+
         # Auto-detect project root
         project_root = self.find_project_root(source_dir)
-        
+
         if project_root is None:
             return BuildResult(
                 success=False,
@@ -256,19 +108,19 @@ class PnpmCompiler(CompilerBase):
                 output_path=None,
                 duration_seconds=0.0,
             )
-        
+
         # Validate directories
         output_dir = self._validate_directory(output_dir, create_if_not_exists=True)
-        
+
         # Prepare environment
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("pnpm", env)
             env = apply_mirror_environment("npm", env)
-        
+
         # Install dependencies in project root
-        install_result = self._execute_in_directory(
+        install_result = PnpmExecutor.execute(
             [pnpm_executable, "install"],
             project_root,
             env,
@@ -283,13 +135,13 @@ class PnpmCompiler(CompilerBase):
         if extra_args:
             build_args.extend(extra_args)
 
-        return self._execute_in_directory(
+        return PnpmExecutor.execute(
             build_args,
             project_root,
             env,
             stream_output=stream_output,
         )
-    
+
     def install_dependencies(
         self,
         source_dir: Path,
@@ -299,20 +151,20 @@ class PnpmCompiler(CompilerBase):
         production: bool = False,
     ) -> BuildResult:
         """Install dependencies using pnpm with auto-detection of project root.
-        
+
         Args:
             source_dir: Source code directory or subdirectory
             environment: Additional environment variables
             mirror_enabled: Whether to use mirror acceleration
             production: Install only production dependencies
-            
+
         Returns:
             BuildResult containing success status and output information.
         """
         pnpm_executable = self._get_executable_path()
-        
+
         project_root = self.find_project_root(source_dir)
-        
+
         if project_root is None:
             return BuildResult(
                 success=False,
@@ -322,23 +174,23 @@ class PnpmCompiler(CompilerBase):
                 output_path=None,
                 duration_seconds=0.0,
             )
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("pnpm", env)
-        
+
         command = [pnpm_executable, "install"]
         if production:
             command.append("--prod")
 
-        return self._execute_in_directory(
+        return PnpmExecutor.execute(
             command,
             project_root,
             env,
             stream_output=True,
         )
-    
+
     def run_script(
         self,
         source_dir: Path,
@@ -348,20 +200,20 @@ class PnpmCompiler(CompilerBase):
         mirror_enabled: bool = True,
     ) -> BuildResult:
         """Run a specific npm script with auto-detection of project root.
-        
+
         Args:
             source_dir: Source code directory or subdirectory
             script_name: Name of the script to run
             environment: Additional environment variables
             mirror_enabled: Whether to use mirror acceleration
-            
+
         Returns:
             BuildResult containing success status and output information.
         """
         pnpm_executable = self._get_executable_path()
-        
+
         project_root = self.find_project_root(source_dir)
-        
+
         if project_root is None:
             return BuildResult(
                 success=False,
@@ -371,71 +223,71 @@ class PnpmCompiler(CompilerBase):
                 output_path=None,
                 duration_seconds=0.0,
             )
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             env = apply_mirror_environment("pnpm", env)
-        
-        return self._execute_in_directory(
+
+        return PnpmExecutor.execute(
             [pnpm_executable, "run", script_name],
             project_root,
             env,
         )
-    
+
     def clean(self, directory: Path) -> bool:
         """Clean pnpm artifacts in the specified directory.
-        
+
         Args:
             directory: Directory to clean
-            
+
         Returns:
             True if successful, False otherwise.
         """
         import shutil
-        
+
         try:
             directory = self._validate_directory(directory, create_if_not_exists=False)
-            
+
             # Remove node_modules
             node_modules = directory / "node_modules"
             if node_modules.exists():
                 shutil.rmtree(node_modules)
-            
+
             # Remove pnpm-lock.yaml
             lock_file = directory / "pnpm-lock.yaml"
             if lock_file.exists():
                 lock_file.unlink()
-            
+
             # Remove .pnpm-store if exists
             pnpm_store = directory / ".pnpm-store"
             if pnpm_store.exists():
                 shutil.rmtree(pnpm_store)
-            
+
             return True
-            
+
         except Exception:
             return False
-    
+
     def _get_executable_path(self) -> str:
         """Get the pnpm executable path."""
         if self._pnpm_path:
             return self._pnpm_path
-        
+
         pnpm_path = shutil.which("pnpm")
         if pnpm_path is None:
             raise RuntimeError("pnpm not found in PATH. Please install pnpm or provide pnpm_path.")
-        
+
         return pnpm_path
-    
+
     @staticmethod
     def create(source_dir: Path, *, mirror_enabled: bool = True) -> "PnpmCompiler":
         """Factory method to create a PnpmCompiler instance.
-        
+
         Args:
             source_dir: Source directory for the project
             mirror_enabled: Whether to enable mirror acceleration by default
-            
+
         Returns:
             Configured PnpmCompiler instance
         """
@@ -447,7 +299,7 @@ def main() -> None:
     """PNPM compiler CLI entry point."""
     import argparse
     import sys
-    
+
     parser = argparse.ArgumentParser(description="PNPM Build Compiler")
     parser.add_argument("source_dir", type=Path, help="Source directory")
     parser.add_argument("-o", "--output", type=Path, required=True, help="Output directory")
@@ -455,11 +307,11 @@ def main() -> None:
     parser.add_argument("--no-mirror", dest="mirror", action="store_false", help="Disable mirror acceleration")
     parser.add_argument("--script", type=str, help="Run specific npm script instead of build")
     parser.add_argument("--install", action="store_true", help="Install dependencies only")
-    
+
     args = parser.parse_args()
-    
+
     compiler = PnpmCompiler()
-    
+
     if args.script:
         result = compiler.run_script(
             args.source_dir,
@@ -477,5 +329,5 @@ def main() -> None:
             args.output,
             mirror_enabled=args.mirror,
         )
-    
+
     sys.exit(0 if result["success"] else 1)

multi_lang_build/compiler/pnpm_support/__init__.py

@@ -0,0 +1,6 @@
+"""PNPM compiler support modules."""
+
+from multi_lang_build.compiler.pnpm_support.project import PnpmProject
+from multi_lang_build.compiler.pnpm_support.executor import PnpmExecutor
+
+__all__ = ["PnpmProject", "PnpmExecutor"]

multi_lang_build/compiler/pnpm_support/executor.py

@@ -0,0 +1,148 @@
+"""PNPM command execution."""
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Final
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class PnpmExecutor:
+    """Execute pnpm commands with streaming support."""
+
+    DEFAULT_TIMEOUT: Final[int] = 3600  # 1 hour
+
+    @staticmethod
+    def execute(
+        command: list[str],
+        working_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Execute a command in the specified directory.
+
+        Args:
+            command: Command to execute
+            working_dir: Working directory for the command
+            environment: Environment variables
+            stream_output: Whether to stream output in real-time
+
+        Returns:
+            BuildResult containing success status and output information
+        """
+        original_cwd = Path.cwd()
+        full_command = command.copy()
+        start_time: float = 0.0
+
+        try:
+            os.chdir(working_dir)
+            start_time = time.perf_counter()
+
+            if stream_output:
+                return PnpmExecutor._execute_stream(
+                    full_command, working_dir, environment, start_time
+                )
+            else:
+                return PnpmExecutor._execute_capture(
+                    full_command, working_dir, environment, start_time
+                )
+
+        except subprocess.TimeoutExpired:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-1,
+                stdout="",
+                stderr="Build timed out after 1 hour",
+                output_path=None,
+                duration_seconds=duration,
+            )
+        except Exception as e:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-2,
+                stdout="",
+                stderr=f"Build error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+        finally:
+            os.chdir(original_cwd)
+
+    @staticmethod
+    def _execute_stream(
+        command: list[str],
+        working_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute with real-time output streaming."""
+        stdout_buffer = []
+        stderr_buffer = []
+
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env={**os.environ, **environment},
+        )
+
+        # Read stdout in real-time
+        if process.stdout:
+            for line in process.stdout:
+                line = line.rstrip('\n\r')
+                stdout_buffer.append(line)
+                print(line)
+                sys.stdout.flush()
+
+        # Read stderr in real-time
+        if process.stderr:
+            for line in process.stderr:
+                line = line.rstrip('\n\r')
+                stderr_buffer.append(line)
+                print(line, file=sys.stderr)
+                sys.stderr.flush()
+
+        return_code = process.wait()
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=return_code == 0,
+            return_code=return_code,
+            stdout='\n'.join(stdout_buffer),
+            stderr='\n'.join(stderr_buffer),
+            output_path=working_dir,
+            duration_seconds=duration,
+        )
+
+    @staticmethod
+    def _execute_capture(
+        command: list[str],
+        working_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute with captured output."""
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=PnpmExecutor.DEFAULT_TIMEOUT,
+            env={**os.environ, **environment},
+        )
+
+        duration = time.perf_counter() - start_time
+
+        return BuildResult(
+            success=result.returncode == 0,
+            return_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            output_path=working_dir,
+            duration_seconds=duration,
+        )

multi_lang_build/compiler/pnpm_support/project.py

@@ -0,0 +1,53 @@
+"""PNPM project detection and utilities."""
+
+from pathlib import Path
+
+
+class PnpmProject:
+    """PNPM project detection and root finding."""
+
+    @staticmethod
+    def find_root(start_path: Path) -> Path | None:
+        """Find the frontend project root directory containing package.json.
+
+        Searches from start_path up to its ancestors and also checks subdirectories.
+
+        Args:
+            start_path: Starting path to search from
+
+        Returns:
+            Path to project root or None if not found
+        """
+        start_path = start_path.resolve()
+
+        # Check if start_path itself is the root
+        if (start_path / "package.json").exists():
+            return start_path
+
+        # Search upwards in the directory tree
+        current = start_path.parent
+        while current != current.parent:
+            if (current / "package.json").exists():
+                return current
+            current = current.parent
+
+        # Search subdirectories
+        for subdir in start_path.iterdir():
+            if subdir.is_dir() and not subdir.name.startswith("."):
+                subdir_root = PnpmProject.find_root(subdir)
+                if subdir_root:
+                    return subdir_root
+
+        return None
+
+    @staticmethod
+    def validate(root: Path) -> bool:
+        """Validate that the path is a valid PNPM project.
+
+        Args:
+            root: Project root path
+
+        Returns:
+            True if valid, False otherwise
+        """
+        return (root / "package.json").exists()