multi-lang-build 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

multi_lang_build/compiler/go.py

@@ -110,16 +110,18 @@ class GoCompiler(CompilerBase):
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Execute the Go build process.
-        
+
         Args:
             source_dir: Source code directory
             output_dir: Build output directory (for binary)
             environment: Additional environment variables
             mirror_enabled: Whether to use Go proxy mirror
             extra_args: Additional arguments to pass to go build
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
@@ -147,22 +149,24 @@ class GoCompiler(CompilerBase):
                 source_dir,
                 output_dir,
                 environment=env,
+                stream_output=stream_output,
             )
-            
+
             if not deps_result["success"]:
                 return deps_result
-        
+
         # Build the project
         build_args = [go_executable, "build", "-o", str(output_dir)]
-        
+
         if extra_args:
             build_args.extend(extra_args)
-        
+
         return self._run_build(
             build_args,
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
     
     def build_binary(
@@ -175,9 +179,10 @@ class GoCompiler(CompilerBase):
         mirror_enabled: bool = True,
         ldflags: str | None = None,
         tags: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Build a specific Go binary.
-        
+
         Args:
             source_dir: Source code directory (working directory for build)
             output_path: Output path for the binary
@@ -187,40 +192,42 @@ class GoCompiler(CompilerBase):
             mirror_enabled: Whether to use Go proxy mirror
             ldflags: Linker flags to pass to the compiler
             tags: Build tags to pass to the compiler
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
         go_executable = self._get_executable_path()
-        
+
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-        
+
         # Ensure output directory exists
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             mirror_key = self._mirror or "go"
             env = apply_mirror_environment(mirror_key, env)
-        
+
         build_args = [go_executable, "build", "-o", str(output_path)]
-        
+
         if ldflags:
             build_args.extend(["-ldflags", ldflags])
-        
+
         if tags:
             build_args.extend(["-tags", ",".join(tags)])
-        
+
         # Add target if specified (target is relative to source_dir)
         if target:
             build_args.append(str(target))
-        
+
         return self._run_build(
             build_args,
             source_dir,
             output_path.parent,
             environment=env,
+            stream_output=stream_output,
         )
     
     def build_all(
@@ -231,42 +238,45 @@ class GoCompiler(CompilerBase):
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
         platform: str | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Build all binaries defined in a Makefile or build script.
-        
+
         Args:
             source_dir: Source code directory
             output_dir: Output directory for all binaries
             environment: Additional environment variables
             mirror_enabled: Whether to use Go proxy mirror
             platform: Target platform (e.g., "linux/amd64", "windows/amd64")
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
         go_executable = self._get_executable_path()
-        
+
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
         output_dir = self._validate_directory(output_dir, create_if_not_exists=True)
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             mirror_key = self._mirror or "go"
             env = apply_mirror_environment(mirror_key, env)
-        
+
         build_args = [go_executable, "build", "-o", str(output_dir), "./..."]
-        
+
         if platform:
             env["GOOS"], env["GOARCH"] = platform.split("/")
-        
+
         return self._run_build(
             build_args,
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
-    
+
     def run_tests(
         self,
         source_dir: Path,
@@ -275,16 +285,18 @@ class GoCompiler(CompilerBase):
         mirror_enabled: bool = True,
         verbose: bool = True,
         race: bool = False,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Run Go tests.
-        
+
         Args:
             source_dir: Source code directory
             environment: Additional environment variables
             mirror_enabled: Whether to use Go proxy mirror
             verbose: Enable verbose test output
             race: Enable race detector
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
@@ -299,52 +311,56 @@ class GoCompiler(CompilerBase):
             env = apply_mirror_environment(mirror_key, env)
         
         test_args = [go_executable, "test"]
-        
+
         if verbose:
             test_args.append("-v")
-        
+
         if race:
             test_args.append("-race")
-        
+
         return self._run_build(
             test_args,
             source_dir,
             source_dir,
             environment=env,
+            stream_output=stream_output,
         )
-    
+
     def tidy_modules(
         self,
         source_dir: Path,
         *,
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Run go mod tidy to clean up dependencies.
-        
+
         Args:
             source_dir: Source code directory
             environment: Additional environment variables
             mirror_enabled: Whether to use Go proxy mirror
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
         go_executable = self._get_executable_path()
-        
+
         source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-        
+
         env = environment.copy() if environment else {}
-        
+
         if mirror_enabled:
             mirror_key = self._mirror or "go"
             env = apply_mirror_environment(mirror_key, env)
-        
+
         return self._run_build(
             [go_executable, "mod", "tidy"],
             source_dir,
             source_dir,
             environment=env,
+            stream_output=stream_output,
         )
     
     def clean(self, directory: Path) -> bool:

multi_lang_build/compiler/pnpm.py

@@ -108,48 +108,94 @@ class PnpmCompiler(CompilerBase):
         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
-        
+
         try:
             os.chdir(working_dir)
-            
+
             start_time = time.perf_counter()
-            
-            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,
-            )
-            
+
+            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(
@@ -171,7 +217,6 @@ class PnpmCompiler(CompilerBase):
                 duration_seconds=duration,
             )
         finally:
-            # Always return to original working directory
             os.chdir(original_cwd)
     
     def build(
@@ -182,16 +227,18 @@ class PnpmCompiler(CompilerBase):
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Execute the pnpm build process with auto-detection of project root.
-        
+
         Args:
             source_dir: Source code directory or subdirectory
             output_dir: Build output directory
             environment: Additional environment variables
             mirror_enabled: Whether to use mirror acceleration
             extra_args: Additional arguments to pass to pnpm build
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
@@ -225,20 +272,22 @@ class PnpmCompiler(CompilerBase):
             [pnpm_executable, "install"],
             project_root,
             env,
+            stream_output=stream_output,
         )
-        
+
         if not install_result["success"]:
             return install_result
-        
+
         # Run build
         build_args = [pnpm_executable, "build"]
         if extra_args:
             build_args.extend(extra_args)
-        
+
         return self._execute_in_directory(
             build_args,
             project_root,
             env,
+            stream_output=stream_output,
         )
     
     def install_dependencies(
@@ -282,11 +331,12 @@ class PnpmCompiler(CompilerBase):
         command = [pnpm_executable, "install"]
         if production:
             command.append("--prod")
-        
+
         return self._execute_in_directory(
             command,
             project_root,
             env,
+            stream_output=True,
         )
     
     def run_script(

multi_lang_build/compiler/python.py

@@ -106,16 +106,18 @@ class PythonCompiler(CompilerBase):
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Execute the Python build process.
-        
+
         Args:
             source_dir: Source code directory
             output_dir: Build output directory
             environment: Additional environment variables
             mirror_enabled: Whether to use PyPI mirror
             extra_args: Additional arguments to pass to build command
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
@@ -134,18 +136,18 @@ class PythonCompiler(CompilerBase):
         
         # Determine build system
         build_system = self._detect_build_system(source_dir)
-        
+
         if build_system == "poetry":
             return self._build_with_poetry(
-                python_executable, source_dir, output_dir, env, extra_args
+                python_executable, source_dir, output_dir, env, extra_args, stream_output
             )
         elif build_system == "setuptools":
             return self._build_with_setuptools(
-                python_executable, source_dir, output_dir, env, extra_args
+                python_executable, source_dir, output_dir, env, extra_args, stream_output
             )
         elif build_system == "pdm":
             return self._build_with_pdm(
-                python_executable, source_dir, output_dir, env, extra_args
+                python_executable, source_dir, output_dir, env, extra_args, stream_output
             )
         else:
             return BuildResult(
@@ -200,34 +202,37 @@ class PythonCompiler(CompilerBase):
         output_dir: Path,
         env: dict[str, str],
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Build using Poetry."""
         # Install dependencies
         install_cmd = [python_executable, "-m", "poetry", "install"]
-        
+
         install_result = self._run_build(
             install_cmd,
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
-        
+
         if not install_result["success"]:
             return install_result
-        
+
         # Build package
         build_cmd = [python_executable, "-m", "poetry", "build"]
-        
+
         if extra_args:
             build_cmd.extend(extra_args)
-        
+
         return self._run_build(
             build_cmd,
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
-    
+
     def _build_with_setuptools(
         self,
         python_executable: str,
@@ -235,6 +240,7 @@ class PythonCompiler(CompilerBase):
         output_dir: Path,
         env: dict[str, str],
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Build using setuptools."""
         # Install build dependencies first
@@ -253,8 +259,9 @@ class PythonCompiler(CompilerBase):
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
-    
+
     def _build_with_pdm(
         self,
         python_executable: str,
@@ -262,19 +269,21 @@ class PythonCompiler(CompilerBase):
         output_dir: Path,
         env: dict[str, str],
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Build using PDM."""
         # Build with PDM
         build_cmd = [python_executable, "-m", "pdm", "build"]
-        
+
         if extra_args:
             build_cmd.extend(extra_args)
-        
+
         return self._run_build(
             build_cmd,
             source_dir,
             output_dir,
             environment=env,
+            stream_output=stream_output,
         )
     
     def install_dependencies(