multi-lang-build 0.2.2__tar.gz → 0.2.4__tar.gz

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-lang-build
-Version: 0.2.2
+Version: 0.2.4
 Summary: Multi-language automated build tool with domestic mirror acceleration support
 Project-URL: Homepage, https://github.com/example/multi-lang-build
 Project-URL: Repository, https://github.com/example/multi-lang-build

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "multi-lang-build"
-version = "0.2.2"
+version = "0.2.4"
 description = "Multi-language automated build tool with domestic mirror acceleration support"
 readme = "README.md"
 license = {text = "MIT"}

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/src/multi_lang_build/__init__.py

@@ -7,7 +7,7 @@ from multi_lang_build.compiler.python import PythonCompiler
 from multi_lang_build.mirror.config import MirrorConfig, get_mirror_config
 from multi_lang_build.register import register_skill
 
-__version__ = "0.2.1"
+__version__ = "0.2.4"
 __all__ = [
     "BuildConfig",
     "BuildResult",

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/src/multi_lang_build/cli.py

@@ -61,7 +61,8 @@ Supported languages:
     pnpm_parser.add_argument("--mirror/--no-mirror", default=True, help="Enable/disable mirror acceleration")
     pnpm_parser.add_argument("--script", type=str, help="Run specific npm script")
     pnpm_parser.add_argument("--install", action="store_true", help="Install dependencies only")
-    
+    pnpm_parser.add_argument("--stream/--no-stream", dest="stream_output", default=True, help="Enable/disable real-time output streaming (default: enabled)")
+
     go_parser = subparsers.add_parser(
         "go",
         help="Build Go projects",
@@ -75,7 +76,8 @@ Supported languages:
     go_parser.add_argument("--test", action="store_true", help="Run tests instead of building")
     go_parser.add_argument("--tidy", action="store_true", help="Run go mod tidy")
     go_parser.add_argument("--all", action="store_true", help="Build all packages")
-    
+    go_parser.add_argument("--stream/--no-stream", dest="stream_output", default=True, help="Enable/disable real-time output streaming (default: enabled)")
+
     python_parser = subparsers.add_parser(
         "python",
         help="Build Python projects",
@@ -88,6 +90,7 @@ Supported languages:
     python_parser.add_argument("--dev", action="store_true", help="Include development dependencies")
     python_parser.add_argument("--poetry", action="store_true", help="Force using poetry")
     python_parser.add_argument("--create-venv", type=Path, help="Create virtual environment at path")
+    python_parser.add_argument("--stream/--no-stream", dest="stream_output", default=True, help="Enable/disable real-time output streaming (default: enabled)")
     
     mirror_parser = subparsers.add_parser(
         "mirror",
@@ -175,9 +178,9 @@ Examples:
     try:
         if parsed_args.language == "pnpm":
             from multi_lang_build.compiler.pnpm import PnpmCompiler
-            
+
             compiler = PnpmCompiler()
-            
+
             if parsed_args.script:
                 result = compiler.run_script(
                     parsed_args.source_dir,
@@ -194,13 +197,14 @@ Examples:
                     parsed_args.source_dir,
                     parsed_args.output,
                     mirror_enabled=parsed_args.mirror,
+                    stream_output=parsed_args.stream_output,
                 )
-        
+
         elif parsed_args.language == "go":
             from multi_lang_build.compiler.go import GoCompiler
-            
+
             compiler = GoCompiler()
-            
+
             if parsed_args.test:
                 result = compiler.run_tests(
                     parsed_args.source_dir,
@@ -216,6 +220,7 @@ Examples:
                     parsed_args.source_dir,
                     parsed_args.output,
                     mirror_enabled=parsed_args.mirror,
+                    stream_output=parsed_args.stream_output,
                 )
             else:
                 tags = parsed_args.tags.split(",") if parsed_args.tags else None
@@ -225,13 +230,14 @@ Examples:
                     mirror_enabled=parsed_args.mirror,
                     ldflags=parsed_args.ldflags,
                     tags=tags,
+                    stream_output=parsed_args.stream_output,
                 )
-        
+
         elif parsed_args.language == "python":
             from multi_lang_build.compiler.python import PythonCompiler
-            
+
             compiler = PythonCompiler()
-            
+
             if parsed_args.create_venv:
                 result = compiler.create_venv(
                     parsed_args.create_venv,
@@ -249,6 +255,7 @@ Examples:
                     parsed_args.source_dir,
                     parsed_args.output,
                     mirror_enabled=parsed_args.mirror,
+                    stream_output=parsed_args.stream_output,
                 )
         
         elif parsed_args.language == "mirror":

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/src/multi_lang_build/compiler/base.py

@@ -4,6 +4,8 @@ from abc import ABC, abstractmethod
 from typing import TypeAlias, TypedDict, NotRequired
 from pathlib import Path
 import time
+import subprocess
+import sys
 
 
 class BuildConfig(TypedDict, total=False):
@@ -37,30 +39,30 @@ class CompilerInfo(TypedDict):
 
 class CompilerBase(ABC):
     """Abstract base class for all language compilers."""
-    
+
     @property
     @abstractmethod
     def name(self) -> str:
         """Get the compiler name."""
         ...
-    
+
     @property
     @abstractmethod
     def version(self) -> str:
         """Get the compiler version."""
         ...
-    
+
     @property
     @abstractmethod
     def supported_mirrors(self) -> list[str]:
         """Get list of supported mirror configurations."""
         ...
-    
+
     @abstractmethod
     def get_info(self) -> CompilerInfo:
         """Get compiler information."""
         ...
-    
+
     @abstractmethod
     def build(
         self,
@@ -70,33 +72,35 @@ class CompilerBase(ABC):
         environment: dict[str, str] | None = None,
         mirror_enabled: bool = True,
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Execute the build process.
-        
+
         Args:
             source_dir: Source code directory
             output_dir: Build output directory
             environment: Additional environment variables
             mirror_enabled: Whether to use mirror acceleration
             extra_args: Additional arguments to pass to the build command
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult containing success status and output information.
         """
         ...
-    
+
     @abstractmethod
     def clean(self, directory: Path) -> bool:
         """Clean build artifacts in the specified directory.
-        
+
         Args:
             directory: Directory to clean
-            
+
         Returns:
             True if successful, False otherwise.
         """
         ...
-    
+
     def _run_build(
         self,
         command: list[str],
@@ -105,42 +109,151 @@ class CompilerBase(ABC):
         *,
         environment: dict[str, str] | None = None,
         extra_args: list[str] | None = None,
+        stream_output: bool = True,
     ) -> BuildResult:
         """Execute a build command with timing and error handling.
-        
+
         Args:
             command: Build command to execute
             source_dir: Source directory for the build
             output_dir: Output directory for build artifacts
             environment: Additional environment variables
             extra_args: Additional arguments to append to command
-            
+            stream_output: Whether to stream output in real-time (default: True)
+
         Returns:
             BuildResult with success status and output information.
         """
-        import subprocess
-        
         full_command = command.copy()
         if extra_args:
             full_command.extend(extra_args)
-        
+
         env = environment.copy() if environment else {}
         env.setdefault("PATH", "")
-        
+
         start_time = time.perf_counter()
-        
+
+        if stream_output:
+            return self._run_build_stream(
+                full_command, source_dir, output_dir, env, start_time
+            )
+        else:
+            return self._run_build_capture(
+                full_command, source_dir, output_dir, env, start_time
+            )
+
+    def _run_build_stream(
+        self,
+        command: list[str],
+        source_dir: Path,
+        output_dir: Path,
+        env: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute build command with real-time output streaming.
+
+        Args:
+            command: Build command to execute
+            source_dir: Source directory for the build
+            output_dir: Output directory for build artifacts
+            env: Environment variables
+            start_time: Start time for duration calculation
+
+        Returns:
+            BuildResult with success status and output information.
+        """
+        stdout_buffer = []
+        stderr_buffer = []
+
+        try:
+            process = subprocess.Popen(
+                command,
+                cwd=source_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+            )
+
+            # Read stdout in real-time
+            for line in process.stdout:
+                line = line.rstrip('\n\r')
+                stdout_buffer.append(line)
+                print(line)
+                sys.stdout.flush()
+
+            # Read stderr in real-time
+            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=output_dir if return_code == 0 else None,
+                duration_seconds=duration,
+            )
+
+        except subprocess.TimeoutExpired:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-1,
+                stdout='\n'.join(stdout_buffer),
+                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='\n'.join(stdout_buffer),
+                stderr=f"Build error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+
+    def _run_build_capture(
+        self,
+        command: list[str],
+        source_dir: Path,
+        output_dir: Path,
+        env: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute build command with captured output (no real-time display).
+
+        Args:
+            command: Build command to execute
+            source_dir: Source directory for the build
+            output_dir: Output directory for build artifacts
+            env: Environment variables
+            start_time: Start time for duration calculation
+
+        Returns:
+            BuildResult with success status and output information.
+        """
         try:
             result = subprocess.run(
-                full_command,
+                command,
                 cwd=source_dir,
                 capture_output=True,
                 text=True,
                 env=env,
                 timeout=3600,  # 1 hour timeout
             )
-            
+
             duration = time.perf_counter() - start_time
-            
+
             return BuildResult(
                 success=result.returncode == 0,
                 return_code=result.returncode,
@@ -149,7 +262,7 @@ class CompilerBase(ABC):
                 output_path=output_dir if result.returncode == 0 else None,
                 duration_seconds=duration,
             )
-            
+
         except subprocess.TimeoutExpired:
             duration = time.perf_counter() - start_time
             return BuildResult(

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/src/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-0.2.2 → multi_lang_build-0.2.4}/src/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-0.2.2 → multi_lang_build-0.2.4}/src/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(

{multi_lang_build-0.2.2 → multi_lang_build-0.2.4}/src/multi_lang_build/register.py

@@ -29,17 +29,18 @@ def register_claude_code(project_level: bool = True) -> bool:
     """Register as Claude Code skill.
 
     Args:
-        project_level: If True (default), register to project-level .claude/CLAUDE.md.
+        project_level: If True (default), register to project-level .claude/multi-lang-build.md.
                       If False, register to global ~/.claude/CLAUDE.md.
     """
     try:
         # Determine registration path
         if project_level:
-            # Project-level: .claude/CLAUDE.md in current directory
+            # Project-level: .claude/multi-lang-build.md in current directory
             config_dir = Path.cwd() / ".claude"
             config_dir.mkdir(exist_ok=True)
-            claude_md = config_dir / "CLAUDE.md"
+            skill_file = config_dir / "multi-lang-build.md"
             level_name = "project-level"
+            is_new = not skill_file.exists()
         else:
             # Global-level: ~/.claude/CLAUDE.md (only check CLI for global)
             result = subprocess.run(
@@ -55,17 +56,11 @@ def register_claude_code(project_level: bool = True) -> bool:
 
             claude_dir = Path.home() / ".claude"
             claude_dir.mkdir(exist_ok=True)
-            claude_md = claude_dir / "CLAUDE.md"
+            skill_file = claude_dir / "CLAUDE.md"
             level_name = "global"
+            is_new = not skill_file.exists()
 
-        # Read existing content
-        existing_content = ""
-        if claude_md.exists():
-            existing_content = claude_md.read_text()
-
-        skill_section = """
-
-## Multi-Lang Build Tool
+        skill_content = """## Multi-Lang Build Tool
 
 You can use the `multi-lang-build` tool to compile projects:
 
@@ -73,6 +68,7 @@ You can use the `multi-lang-build` tool to compile projects:
 - `multi-lang-build pnpm <source> --output <dir>` - Build pnpm projects
 - `multi-lang-build go <source> --output <bin>` - Build Go projects
 - `multi-lang-build python <source> --output <dir>` - Build Python projects
+- `multi-lang-build mirror list|set|show` - Configure domestic mirrors
 
 ### Examples:
 ```bash
@@ -87,23 +83,39 @@ multi-lang-build python ./src --output ./dist --mirror
 
 # Build pnpm project
 multi-lang-build pnpm ./src --output ./dist --mirror
+
+# Configure mirror
+multi-lang-build mirror set pip pip_aliyun
+multi-lang-build mirror set go
 ```
 
 When working with Go projects, check if there are multiple main packages and use the `--target` flag to specify which one to build.
 """
 
-        if "## Multi-Lang Build Tool" not in existing_content:
-            with open(claude_md, "a") as f:
-                f.write(skill_section)
-            print(f"✅ Registered with Claude Code ({level_name}, added to {claude_md})")
+        if project_level:
+            # Project-level: create dedicated file
+            with open(skill_file, "w") as f:
+                f.write(skill_content)
+            print(f"✅ Registered with Claude Code ({level_name}, created {skill_file})")
         else:
-            print(f"ℹ️ Already registered with Claude Code ({level_name}, {claude_md})")
+            # Global-level: append to existing CLAUDE.md if not already present
+            existing_content = ""
+            if skill_file.exists():
+                existing_content = skill_file.read_text()
+
+            if "## Multi-Lang Build Tool" not in existing_content:
+                with open(skill_file, "a") as f:
+                    f.write(skill_content)
+                print(f"✅ Registered with Claude Code ({level_name}, added to {skill_file})")
+            else:
+                print(f"ℹ️ Already registered with Claude Code ({level_name}, {skill_file})")
 
         return True
 
     except Exception as e:
         print(f"❌ Failed to register with Claude Code: {e}")
         return False
+        return False
 
 
 def register_opencode(project_level: bool = True) -> bool: