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

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.0"
+__version__ = "0.2.3"
 __all__ = [
     "BuildConfig",
     "BuildResult",
@@ -55,3 +55,10 @@ def main_register() -> None:
     args = parser.parse_args()
     success = register_skill(args.ide)
     sys.exit(0 if success else 1)
+
+
+def main_mirror() -> None:
+    """Entry point for the mirror CLI tool."""
+    from multi_lang_build.mirror.cli import mirror_main
+
+    mirror_main()

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,16 +90,59 @@ 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",
         help="Manage mirror configurations",
-        description="List or configure mirror settings",
+        description="List or configure domestic mirror acceleration settings",
+        epilog="""
+Examples:
+  %(prog)s mirror list              List all available mirrors
+  %(prog)s mirror set pip           Configure pip mirror (default)
+  %(prog)s mirror set go            Configure go proxy mirror
+  %(prog)s mirror set pnpm          Configure pnpm registry mirror
+  %(prog)s mirror show              Show current configuration
+  %(prog)s mirror reset             Reset configuration
+        """,
     )
     mirror_subparsers = mirror_parser.add_subparsers(dest="mirror_action")
 
     list_parser = mirror_subparsers.add_parser("list", help="List available mirrors")
-    list_parser.add_argument("--language", type=str, help="Filter by language")
+    list_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    set_parser = mirror_subparsers.add_parser("set", help="Set mirror configuration")
+    set_parser.add_argument(
+        "type",
+        type=str,
+        default="pip",
+        nargs="?",
+        choices=["pip", "go", "npm", "pnpm"],
+        help="Package manager type (default: pip)",
+    )
+    set_parser.add_argument(
+        "mirror",
+        type=str,
+        nargs="?",
+        default="pip",
+        help="Mirror to use",
+    )
+
+    show_parser = mirror_subparsers.add_parser("show", help="Show current configuration")
+    show_parser.add_argument(
+        "--global",
+        dest="global_level",
+        action="store_true",
+        help="Show global config instead of project-level",
+    )
+
+    reset_parser = mirror_subparsers.add_parser("reset", help="Reset configuration")
+    reset_parser.add_argument(
+        "--global",
+        dest="global_level",
+        action="store_true",
+        help="Reset global config instead of project-level",
+    )
 
     # Register subcommand for IDE integration
     register_parser = subparsers.add_parser(
@@ -133,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,
@@ -152,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,
@@ -174,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
@@ -183,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,
@@ -207,21 +255,37 @@ Examples:
                     parsed_args.source_dir,
                     parsed_args.output,
                     mirror_enabled=parsed_args.mirror,
+                    stream_output=parsed_args.stream_output,
                 )
         
         elif parsed_args.language == "mirror":
-            if parsed_args.mirror_action == "list":
-                from multi_lang_build.mirror.config import get_all_mirror_names, get_mirror_config
-
-                mirrors = get_all_mirror_names()
-                if parsed_args.language:
-                    mirrors = [m for m in mirrors if m in parsed_args.language.split(",")]
+            from multi_lang_build.mirror.cli import configure_mirror, print_mirrors, get_current_config
 
-                print("Available mirrors:")
-                for mirror_name in sorted(mirrors):
-                    config = get_mirror_config(mirror_name)
-                    if config:
-                        print(f"  {mirror_name}: {config['url']}")
+            if parsed_args.mirror_action == "list":
+                if getattr(parsed_args, "json", False):
+                    from multi_lang_build.mirror.cli import get_all_mirrors
+                    import json
+                    print(json.dumps(get_all_mirrors(), indent=2, ensure_ascii=False))
+                else:
+                    print_mirrors()
+            elif parsed_args.mirror_action == "set":
+                mirror_type = getattr(parsed_args, "type", "pip")
+                mirror_key = getattr(parsed_args, "mirror", "pip")
+                success = configure_mirror(mirror_type, mirror_key)
+                sys.exit(0 if success else 1)
+            elif parsed_args.mirror_action == "show":
+                config = get_current_config()
+                if config:
+                    print("\n📦 Current Mirror Configuration:")
+                    print("-" * 40)
+                    for key, value in config.items():
+                        print(f"  • {key}: {value}")
+                    print()
+                else:
+                    print("\n📦 No mirror configured")
+                    print("   Run 'multi-lang-build mirror set <type> <mirror>' to configure")
+                    print()
+                    print_mirrors()
             else:
                 mirror_parser.print_help()
 

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(