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

{multi_lang_build-0.2.7.dist-info → multi_lang_build-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-lang-build
-Version: 0.2.7
+Version: 0.2.10
 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.10.dist-info/RECORD

@@ -0,0 +1,40 @@
+multi_lang_build/__init__.py,sha256=HFLjChxI1v6o36HTscv8X8p0WQMEuwXHVt9FzYZE4x8,1795
+multi_lang_build/cli.py,sha256=SSj7f_auQ0qmjiY65aU0xEIW56w0xgA-8PgI9ICj04I,13100
+multi_lang_build/ide_register.py,sha256=lz345IOs9S6-neh7t_6txJhz7XLypEiNzwvSl3ouVo8,3028
+multi_lang_build/py.typed,sha256=c8jtFarMovqA5DdwhEzKPH4WrX85xaoiWilIlvuc6KU,84
+multi_lang_build/types.py,sha256=iCyz_6KmEBU4xwpCtfJnpzXoiSsmOcOKOhzHJVx8Z4Q,1043
+multi_lang_build/compiler/__init__.py,sha256=7cfE3n7ATXZ8JabON_Qg0npxd7EY2jEU4tC6FxDupIs,493
+multi_lang_build/compiler/base.py,sha256=crtDW9bthfV-FSpp96O2Hi0DrViNqcIt4TjAVK2lPXE,9391
+multi_lang_build/compiler/go_compiler.py,sha256=HPNp6UQD_umjlV5ewqsYmRET3rfegqFaHOtOWy_cCIM,13234
+multi_lang_build/compiler/pnpm.py,sha256=0dwcf5LoPdzqlpkjEBVy8YNZNjd6CnUTOxIdonckwjo,10463
+multi_lang_build/compiler/python.py,sha256=P-4ydqoUerMFkupVISu7j_KGSJVsZfmxeAZzCy36WWo,11797
+multi_lang_build/compiler/go_support/__init__.py,sha256=UGsWdG_RdbjgLGYtvbftjzLjPwHF9tmb-pmezKvEWMQ,675
+multi_lang_build/compiler/go_support/binary.py,sha256=XGt9jzRaCl2tykaHy8iqF1KrLHa3eW4hiolDozMMtaI,3698
+multi_lang_build/compiler/go_support/builder.py,sha256=NtavFLgEtZ5zFvygvudzylJ5AMo2wuRxCMJCDxHTmQA,6531
+multi_lang_build/compiler/go_support/cleaner.py,sha256=UW5YQhzJtgypBpG0BQusmguxl7C8T3TLxlt58Krgvmg,1046
+multi_lang_build/compiler/go_support/env.py,sha256=GPXFkePQb2QHaiiJuLXXVnSE9VtHjjPiZx82oYuVx3k,1270
+multi_lang_build/compiler/go_support/mirror.py,sha256=BWT8mhLEshSVCFZa2D0amIvR366ZSXJCvP8djAqP11Q,3786
+multi_lang_build/compiler/go_support/module.py,sha256=5ubgiMJu0P8UeiutV3tIIifO30IBhbktDfJB4orWgvk,2204
+multi_lang_build/compiler/go_support/tester.py,sha256=r6DVL4EtNUYQB_Jm84MGmZ1sDl9QsV6JqanZwHj-XyM,5428
+multi_lang_build/compiler/pnpm_support/__init__.py,sha256=_bPoy8XWGykiijpC8xwGMfJK3H4iBzIOYlcZUStwb9A,225
+multi_lang_build/compiler/pnpm_support/executor.py,sha256=w52GN4fCGqbt90yEPq_LyaaWcGhoRbhudI_RJ38OkZY,4352
+multi_lang_build/compiler/pnpm_support/project.py,sha256=JPHAxK0z1FOtNsAgJUUlp70wPGP4bq5pSB5o0FK44Co,1531
+multi_lang_build/compiler/python_support/__init__.py,sha256=YjLyDtSvFy9VnhD9f0Mr9saMk98FnsKOe5O1L5pOAVc,459
+multi_lang_build/compiler/python_support/cleaner.py,sha256=AT1KdRRX5vTGdtVLAgml2SuAUNEz0MzeuEgaHzBrAJo,1526
+multi_lang_build/compiler/python_support/cli.py,sha256=q3guZAST1Rs2gy79BOb9GAWvShy7LBcdl1R1p8nfNXY,1642
+multi_lang_build/compiler/python_support/detector.py,sha256=eMHSLsU--a_LbyeXlgFuqwN_CHM8MeSbE8rNX8fe35E,1804
+multi_lang_build/compiler/python_support/installer.py,sha256=1gDqQPZRhYB6DIVlCxdRuIwJ_i5WpO4B5j2cG-VWVHI,4575
+multi_lang_build/compiler/python_support/venv.py,sha256=It6tppc7BFToJBzFxR9hPfpYeteVpNIw-mHjF3pwdr4,1957
+multi_lang_build/mirror/__init__.py,sha256=RrZOQ83bxImAR275zeAUKyyCgwqdGt5xH8tF_-UShJo,489
+multi_lang_build/mirror/cli.py,sha256=qv6RI6izxUIsfMCIDOtTK3avcNSJpAaUF3NPiK1W49A,9820
+multi_lang_build/mirror/config.py,sha256=ZQo9upkE29vw0QFuBT6sYw85DhOhHQg59RSYu-OcdQg,9067
+multi_lang_build/register/support/__init__.py,sha256=Hg5oKJn5KhJ-qikzpDtFf0CO9WVnMvJVhExf20-PC10,443
+multi_lang_build/register/support/claude.py,sha256=YgXdU0--1wr6QIDL6rojY_zLKnlb-nu6fDqvpKywzd4,3370
+multi_lang_build/register/support/codebuddy.py,sha256=6ZPj0bs6erkSvok5lHueLbqxjIOCqml98zJoVTuBKj4,3356
+multi_lang_build/register/support/opencode.py,sha256=zGrTREyCNUX8RZgTbv9p2KV0ZcQjB68jZQqIClFbD1k,2394
+multi_lang_build/register/support/trae.py,sha256=nkiQRCWp8in3cI3BLuWHMMLzQwiQQv3crxAU06sXOuk,2527
+multi_lang_build-0.2.10.dist-info/METADATA,sha256=1UZ3bhhQbW4AXA8fR-M6nF6ZU29gl18OIRuFEa_EucA,10074
+multi_lang_build-0.2.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+multi_lang_build-0.2.10.dist-info/entry_points.txt,sha256=0vd5maQH5aZoqnpbr2Yr_IWB_-ncWX1rO3jGBCW3pHY,319
+multi_lang_build-0.2.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+multi_lang_build-0.2.10.dist-info/RECORD,,

multi_lang_build/compiler/go.py

@@ -1,532 +0,0 @@
-"""Go compiler with mirror acceleration support."""
-
-from pathlib import Path
-from typing import Final, Literal
-import shutil
-import subprocess
-import os
-import tempfile
-
-from multi_lang_build.compiler.base import CompilerBase, BuildResult, CompilerInfo
-from multi_lang_build.mirror.config import (
-    get_mirror_config, 
-    apply_mirror_environment,
-    GO_PROXY_GOPROXY_CN,
-    GO_PROXY_GOPROXY_IO,
-    GO_PROXY_GOVIP_CN,
-    DEFAULT_GO_MIRROR,
-)
-
-
-class GoCompiler(CompilerBase):
-    """Compiler for Go projects with module support."""
-    
-    NAME: Final[str] = "go"
-    DEFAULT_MIRROR: Final[str] = DEFAULT_GO_MIRROR
-    
-    def __init__(
-        self, 
-        go_path: str | None = None,
-        mirror: str | None = None,
-    ) -> None:
-        """Initialize the Go compiler.
-        
-        Args:
-            go_path: Optional path to go executable. If None, uses system PATH.
-            mirror: Mirror configuration name (e.g., "go", "go_qiniu", "go_vip").
-                    Defaults to DEFAULT_GO_MIRROR (goproxy.cn).
-        """
-        self._go_path = go_path
-        self._mirror = mirror
-        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 Go version."""
-        if self._version_cache:
-            return self._version_cache
-        
-        go_executable = self._get_executable_path()
-        
-        try:
-            result = subprocess.run(
-                [go_executable, "version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            output = result.stdout.strip()
-            if output:
-                parts = output.split()
-                if len(parts) >= 3:
-                    self._version_cache = parts[2]
-                else:
-                    self._version_cache = output
-            else:
-                self._version_cache = "unknown"
-        except Exception:
-            self._version_cache = "unknown"
-        
-        return self._version_cache
-    
-    @property
-    def supported_mirrors(self) -> list[str]:
-        """Get list of supported mirror configurations."""
-        return ["go", "go_qiniu", "go_vip"]
-    
-    @property
-    def current_mirror(self) -> str:
-        """Get the current mirror configuration name."""
-        return self._mirror or "go"
-    
-    def get_info(self) -> CompilerInfo:
-        """Get compiler information."""
-        return {
-            "name": self.name,
-            "version": self.version,
-            "supported_mirrors": self.supported_mirrors,
-            "default_mirror": self.DEFAULT_MIRROR,
-            "executable": self._get_executable_path(),
-        }
-    
-    def set_mirror(self, mirror: str) -> None:
-        """Set the mirror configuration.
-        
-        Args:
-            mirror: Mirror configuration name (e.g., "go", "go_qiniu", "go_vip")
-        """
-        self._mirror = mirror
-    
-    def build(
-        self,
-        source_dir: Path,
-        output_dir: Path,
-        *,
-        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.
-        """
-        from loguru import logger
-
-        go_executable = self._get_executable_path()
-
-        # Validate directories
-        source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-        output_dir = self._validate_directory(output_dir, create_if_not_exists=True)
-
-        # Print current working directory
-        cwd = Path.cwd().resolve()
-        logger.info(f"当前工作目录: {cwd}")
-
-        # Prepare environment
-        env = environment.copy() if environment else {}
-
-        # Ensure GOMODCACHE is set
-        if "GOMODCACHE" not in env and "GOPATH" not in env:
-            default_cache = Path.home() / "go" / "pkg" / "mod"
-            env["GOMODCACHE"] = str(default_cache)
-            logger.info(f"Go模块缓存: {default_cache}")
-
-        if mirror_enabled:
-            mirror_key = self._mirror or "go"
-            env = apply_mirror_environment(mirror_key, env)
-
-        # Check for go.mod
-        go_mod = source_dir / "go.mod"
-        has_go_mod = go_mod.exists()
-
-        # Download dependencies if go.mod exists
-        if has_go_mod:
-            deps_result = self._run_build(
-                [go_executable, "mod", "download"],
-                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(
-        self,
-        source_dir: Path,
-        output_path: Path,
-        *,
-        target: str | Path | None = None,
-        environment: dict[str, str] | None = None,
-        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
-            target: Build target - can be a .go file (e.g., "server.go", "cmd/server/main.go")
-                   or a directory (e.g., "./cmd/server"). If None, builds current directory.
-            environment: Additional environment variables
-            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.
-        """
-        from loguru import logger
-
-        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)
-
-        # Print current working directory
-        cwd = Path.cwd().resolve()
-        logger.info(f"当前工作目录: {cwd}")
-
-        # Prepare environment
-        env = environment.copy() if environment else {}
-
-        # Ensure GOMODCACHE is set
-        if "GOMODCACHE" not in env and "GOPATH" not in env:
-            default_cache = Path.home() / "go" / "pkg" / "mod"
-            env["GOMODCACHE"] = str(default_cache)
-            logger.info(f"Go模块缓存: {default_cache}")
-
-        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(
-        self,
-        source_dir: Path,
-        output_dir: Path,
-        *,
-        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.
-        """
-        from loguru import logger
-
-        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)
-
-        # Print current working directory
-        cwd = Path.cwd().resolve()
-        logger.info(f"当前工作目录: {cwd}")
-
-        # Prepare environment
-        env = environment.copy() if environment else {}
-
-        # Ensure GOMODCACHE is set
-        if "GOMODCACHE" not in env and "GOPATH" not in env:
-            default_cache = Path.home() / "go" / "pkg" / "mod"
-            env["GOMODCACHE"] = str(default_cache)
-            logger.info(f"Go模块缓存: {default_cache}")
-
-        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,
-        *,
-        environment: dict[str, str] | None = None,
-        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.
-        """
-        from loguru import logger
-
-        go_executable = self._get_executable_path()
-
-        source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-
-        # Print current working directory
-        cwd = Path.cwd().resolve()
-        logger.info(f"当前工作目录: {cwd}")
-
-        # Prepare environment
-        env = environment.copy() if environment else {}
-
-        # Ensure GOMODCACHE is set
-        if "GOMODCACHE" not in env and "GOPATH" not in env:
-            default_cache = Path.home() / "go" / "pkg" / "mod"
-            env["GOMODCACHE"] = str(default_cache)
-            logger.info(f"Go模块缓存: {default_cache}")
-
-        if mirror_enabled:
-            mirror_key = self._mirror or "go"
-            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.
-        """
-        from loguru import logger
-
-        go_executable = self._get_executable_path()
-
-        source_dir = self._validate_directory(source_dir, create_if_not_exists=False)
-
-        # Print current working directory
-        cwd = Path.cwd().resolve()
-        logger.info(f"当前工作目录: {cwd}")
-
-        # Prepare environment
-        env = environment.copy() if environment else {}
-
-        # Ensure GOMODCACHE is set
-        if "GOMODCACHE" not in env and "GOPATH" not in env:
-            default_cache = Path.home() / "go" / "pkg" / "mod"
-            env["GOMODCACHE"] = str(default_cache)
-            logger.info(f"Go模块缓存: {default_cache}")
-
-        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:
-        """Clean Go build 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 go.sum
-            go_sum = directory / "go.sum"
-            if go_sum.exists():
-                go_sum.unlink()
-            
-            # Remove vendor directory
-            vendor = directory / "vendor"
-            if vendor.exists():
-                shutil.rmtree(vendor)
-            
-            # Remove bin directory
-            bin_dir = directory / "bin"
-            if bin_dir.exists():
-                shutil.rmtree(bin_dir)
-            
-            return True
-            
-        except Exception:
-            return False
-    
-    def _get_executable_path(self) -> str:
-        """Get the go executable path."""
-        if self._go_path:
-            return self._go_path
-        
-        go_path = shutil.which("go")
-        if go_path is None:
-            raise RuntimeError("go not found in PATH. Please install Go or provide go_path.")
-        
-        return go_path
-    
-    @staticmethod
-    def create(source_dir: Path, *, mirror_enabled: bool = True) -> "GoCompiler":
-        """Factory method to create a GoCompiler instance.
-        
-        Args:
-            source_dir: Source directory for the project
-            mirror_enabled: Whether to enable mirror acceleration by default
-            
-        Returns:
-            Configured GoCompiler instance
-        """
-        compiler = GoCompiler()
-        return compiler
-
-
-def main() -> None:
-    """Go compiler CLI entry point."""
-    import argparse
-    import sys
-    
-    parser = argparse.ArgumentParser(description="Go Build Compiler")
-    parser.add_argument("source_dir", type=Path, help="Source directory (working directory)")
-    parser.add_argument("-o", "--output", type=Path, required=True, help="Output binary path")
-    parser.add_argument("-t", "--target", type=str, help="Build target: .go file (e.g., server.go, cmd/main.go) or directory (e.g., ./cmd/server)")
-    parser.add_argument("--mirror", action="store_true", default=True, help="Enable Go proxy mirror")
-    parser.add_argument("--no-mirror", dest="mirror", action="store_false", help="Disable Go proxy mirror")
-    parser.add_argument("--ldflags", type=str, help="Linker flags")
-    parser.add_argument("--tags", type=str, help="Build tags (comma-separated)")
-    parser.add_argument("--test", action="store_true", help="Run tests instead of building")
-    parser.add_argument("--tidy", action="store_true", help="Run go mod tidy")
-    parser.add_argument("--all", action="store_true", help="Build all packages")
-    
-    args = parser.parse_args()
-    
-    compiler = GoCompiler()
-    
-    if args.test:
-        result = compiler.run_tests(args.source_dir, mirror_enabled=args.mirror)
-    elif args.tidy:
-        result = compiler.tidy_modules(args.source_dir, mirror_enabled=args.mirror)
-    elif args.all:
-        result = compiler.build_all(
-            args.source_dir,
-            args.output,
-            mirror_enabled=args.mirror,
-        )
-    else:
-        tags = args.tags.split(",") if args.tags else None
-        result = compiler.build_binary(
-            args.source_dir,
-            args.output,
-            target=args.target,
-            mirror_enabled=args.mirror,
-            ldflags=args.ldflags,
-            tags=tags,
-        )
-    
-    sys.exit(0 if result["success"] else 1)