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

multi_lang_build/__init__.py

@@ -2,12 +2,12 @@
 
 from multi_lang_build.compiler.base import BuildConfig, BuildResult, CompilerBase
 from multi_lang_build.compiler.pnpm import PnpmCompiler
-from multi_lang_build.compiler.go import GoCompiler
+from multi_lang_build.compiler.go_compiler import GoCompiler
 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
+from multi_lang_build.ide_register import register_skill
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"
 __all__ = [
     "BuildConfig",
     "BuildResult",
@@ -33,7 +33,7 @@ def main_register() -> None:
     """Entry point for the register CLI tool."""
     import sys
     import argparse
-    from multi_lang_build.register import register_skill
+    from multi_lang_build.ide_register import register_skill
 
     parser = argparse.ArgumentParser(
         description="Register multi-lang-build as an IDE skill",

multi_lang_build/cli.py

@@ -70,7 +70,8 @@ Supported languages:
     )
     go_parser.add_argument("source_dir", type=Path, help="Source directory")
     go_parser.add_argument("-o", "--output", type=Path, required=True, help="Output file or directory")
-    go_parser.add_argument("--mirror/--no-mirror", default=True, help="Enable/disable Go proxy mirror")
+    go_parser.add_argument("--mirror", dest="mirror", action="store_true", default=True, help="Enable/disable Go proxy mirror")
+    go_parser.add_argument("--no-mirror", dest="mirror", action="store_false", help="Enable/disable Go proxy mirror")
     go_parser.add_argument("--ldflags", type=str, help="Linker flags")
     go_parser.add_argument("--tags", type=str, help="Build tags (comma-separated)")
     go_parser.add_argument("--test", action="store_true", help="Run tests instead of building")
@@ -201,7 +202,7 @@ Examples:
                 )
 
         elif parsed_args.language == "go":
-            from multi_lang_build.compiler.go import GoCompiler
+            from multi_lang_build.compiler.go_compiler import GoCompiler
 
             compiler = GoCompiler()
 

multi_lang_build/compiler/__init__.py

@@ -8,7 +8,7 @@ from multi_lang_build.compiler.base import (
 )
 
 from multi_lang_build.compiler.pnpm import PnpmCompiler
-from multi_lang_build.compiler.go import GoCompiler
+from multi_lang_build.compiler.go_compiler import GoCompiler
 from multi_lang_build.compiler.python import PythonCompiler
 
 __all__ = [

multi_lang_build/compiler/go_compiler.py

@@ -0,0 +1,388 @@
+"""Go compiler with mirror acceleration support and failover."""
+
+from pathlib import Path
+from typing import Final
+import shutil
+import subprocess
+
+from loguru import logger
+
+from multi_lang_build.compiler.base import CompilerBase, BuildResult, CompilerInfo
+from multi_lang_build.mirror.config import (
+    apply_mirror_environment,
+    DEFAULT_GO_MIRROR,
+)
+from multi_lang_build.compiler.go_support import (
+    GoMirrorFailover,
+    GoBinaryBuilder,
+    GoModuleBuilder,
+    GoTester,
+    GoEnvironment,
+    GoCleaner,
+)
+
+
+class GoCompiler(CompilerBase):
+    """Compiler for Go projects with module support and mirror failover."""
+
+    NAME: Final[str] = "go"
+    DEFAULT_MIRROR: Final[str] = DEFAULT_GO_MIRROR
+
+    def __init__(
+        self,
+        go_path: str | None = None,
+        mirror: str | None = None,
+    ):
+        """Initialize Go compiler.
+
+        Args:
+            go_path: Optional path to Go executable
+            mirror: Mirror configuration name (e.g., "go", "go_qiniu", "go_vip")
+        """
+        self._go_path = go_path
+        self._mirror = mirror
+        self._version_cache: str | None = None
+        self._mirror_failover = GoMirrorFailover(mirror)
+
+    @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,
+            )
+            version_output = result.stdout.strip()
+            if "version go" in version_output:
+                self._version_cache = version_output.split("version go")[1].split()[0]
+            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"]
+
+    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 _get_executable_path(self) -> str:
+        """Get the path to the Go executable."""
+        if self._go_path:
+            return shutil.which(self._go_path) or self._go_path
+
+        go_executable = shutil.which("go")
+        if not go_executable:
+            raise RuntimeError("Go executable not found in PATH")
+
+        return go_executable
+
+    def _prepare_environment(self, environment: dict[str, str] | None = None) -> dict[str, str]:
+        """Prepare environment with GOMODCACHE and GOCACHE set."""
+        return GoEnvironment.prepare(environment)
+
+    def _execute_with_mirror_failover(
+        self,
+        command: list[str],
+        source_dir: Path,
+        output_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool,
+    ) -> BuildResult:
+        """Execute build command with mirror failover."""
+        def run_build(cmd, src, out, env, stream):
+            return self._run_build(cmd, src, out, environment=env, stream_output=stream)
+
+        return self._mirror_failover.try_build_with_fallback(
+            command, source_dir, output_dir, environment, stream_output, run_build
+        )
+
+    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
+            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.
+        """
+        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)
+
+        cwd = Path.cwd().resolve()
+        logger.info(f"当前工作目录: {cwd}")
+
+        env = self._prepare_environment(environment)
+
+        # Download dependencies if go.mod exists
+        go_mod = source_dir / "go.mod"
+        if go_mod.exists():
+            logger.info("⬇️  下载Go依赖...")
+            deps_result = self._execute_with_mirror_failover(
+                [go_executable, "mod", "download"],
+                source_dir, output_dir, env, stream_output,
+            )
+            logger.info("✅ 依赖下载完成")
+
+            if not deps_result["success"]:
+                return deps_result
+
+        # Build the project
+        logger.info("🔨 开始构建...")
+        build_args = [go_executable, "build", "-o", str(output_dir)]
+
+        if extra_args:
+            build_args.extend(extra_args)
+
+        if mirror_enabled and self._mirror is None:
+            build_result = self._execute_with_mirror_failover(
+                build_args, source_dir, output_dir, env, stream_output
+            )
+        else:
+            if mirror_enabled:
+                env = apply_mirror_environment(self._mirror or "go", env)
+            build_result = self._run_build(
+                build_args, source_dir, output_dir, environment=env, stream_output=stream_output
+            )
+
+        if build_result["success"]:
+            logger.info("✅ 构建成功")
+
+        return build_result
+
+    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
+            output_path: Output path for the binary
+            target: Build target file or directory
+            environment: Additional environment variables
+            mirror_enabled: Whether to use Go proxy mirror
+            ldflags: Linker flags
+            tags: Build tags
+            stream_output: Whether to stream output in real-time
+
+        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_path.parent.mkdir(parents=True, exist_ok=True)
+
+        cwd = Path.cwd().resolve()
+        logger.info(f"当前工作目录: {cwd}")
+
+        env = self._prepare_environment(environment)
+
+        def run_build(cmd, src, out, env_copy):
+            return self._run_build(cmd, src, out, environment=env_copy, stream_output=stream_output)
+
+        if mirror_enabled and self._mirror is None:
+            return GoBinaryBuilder.build_with_failover(
+                go_executable, source_dir, output_path, env,
+                ldflags, tags, target, run_build, stream_output
+            )
+        else:
+            if mirror_enabled:
+                env = apply_mirror_environment(self._mirror or "go", env)
+            return GoBinaryBuilder.build_single(
+                go_executable, source_dir, output_path, env,
+                ldflags, tags, target, run_build, 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 in the project.
+
+        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")
+            stream_output: Whether to stream output in real-time
+
+        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)
+
+        cwd = Path.cwd().resolve()
+        logger.info(f"当前工作目录: {cwd}")
+
+        env = self._prepare_environment(environment)
+
+        def run_build(cmd, src, out, env_copy):
+            return self._run_build(cmd, src, out, environment=env_copy, stream_output=stream_output)
+
+        if mirror_enabled and self._mirror is None:
+            build_result = self._execute_with_mirror_failover(
+                [go_executable, "build", "-o", str(output_dir), "./..."],
+                source_dir, output_dir, env, stream_output
+            )
+        else:
+            if mirror_enabled:
+                env = apply_mirror_environment(self._mirror or "go", env)
+            build_result = GoModuleBuilder.build_all(
+                go_executable, source_dir, output_dir, env, platform, run_build, stream_output
+            )
+
+        return build_result
+
+    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
+
+        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)
+
+        cwd = Path.cwd().resolve()
+        logger.info(f"当前工作目录: {cwd}")
+
+        env = self._prepare_environment(environment)
+
+        if mirror_enabled:
+            env = apply_mirror_environment(self._mirror or "go", env)
+
+        def run_test(cmd, src, out, env_copy):
+            return self._run_build(cmd, src, out, environment=env_copy, stream_output=stream_output)
+
+        return GoTester.run(
+            go_executable, source_dir, env, verbose, race, stream_output, run_test
+        )
+
+    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
+
+        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)
+
+        cwd = Path.cwd().resolve()
+        logger.info(f"当前工作目录: {cwd}")
+
+        env = self._prepare_environment(environment)
+
+        def run_build(cmd, src, out, env_copy):
+            return self._run_build(cmd, src, out, environment=env_copy, stream_output=stream_output)
+
+        if mirror_enabled and self._mirror is None:
+            return self._execute_with_mirror_failover(
+                [go_executable, "mod", "tidy"],
+                source_dir, source_dir, env, stream_output
+            )
+        else:
+            if mirror_enabled:
+                env = apply_mirror_environment(self._mirror or "go", env)
+            return GoModuleBuilder.tidy(go_executable, source_dir, env, run_build, 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.
+        """
+        directory = self._validate_directory(directory, create_if_not_exists=False)
+        return GoCleaner.clean(directory)

multi_lang_build/compiler/go_support/__init__.py

@@ -0,0 +1,19 @@
+"""Go compiler support modules."""
+
+from multi_lang_build.compiler.go_support.mirror import GoMirrorFailover
+from multi_lang_build.compiler.go_support.builder import GoBuilder
+from multi_lang_build.compiler.go_support.binary import GoBinaryBuilder
+from multi_lang_build.compiler.go_support.module import GoModuleBuilder
+from multi_lang_build.compiler.go_support.tester import GoTester
+from multi_lang_build.compiler.go_support.env import GoEnvironment
+from multi_lang_build.compiler.go_support.cleaner import GoCleaner
+
+__all__ = [
+    "GoMirrorFailover",
+    "GoBuilder",
+    "GoBinaryBuilder",
+    "GoModuleBuilder",
+    "GoTester",
+    "GoEnvironment",
+    "GoCleaner",
+]

multi_lang_build/compiler/go_support/binary.py

@@ -0,0 +1,117 @@
+"""Go binary building with mirror failover support."""
+
+from pathlib import Path
+
+from loguru import logger
+
+from multi_lang_build.compiler.base import BuildResult
+from multi_lang_build.mirror.config import apply_mirror_environment, MIRROR_CONFIGS
+
+
+class GoBinaryBuilder:
+    """Build Go binaries with optional mirror failover."""
+
+    MIRROR_KEYS = ["go_qiniu", "go", "go_vip"]
+
+    @staticmethod
+    def build_with_failover(
+        go_executable: str,
+        source_dir: Path,
+        output_path: Path,
+        env: dict[str, str],
+        ldflags: str | None,
+        tags: list[str] | None,
+        target: str | Path | None,
+        run_build,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Build binary with automatic mirror failover.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_path: Output path for binary
+            env: Environment variables
+            ldflags: Linker flags
+            tags: Build tags
+            target: Build target
+            run_build: Callback to execute build
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        last_result: BuildResult | None = None
+
+        for i, mirror_key in enumerate(GoBinaryBuilder.MIRROR_KEYS):
+            env_copy = env.copy()
+            mirror_name = MIRROR_CONFIGS.get(mirror_key, {}).get("name", mirror_key)
+            logger.info(f"🔗 使用代理: {mirror_name}")
+            env_copy = apply_mirror_environment(mirror_key, env_copy)
+
+            build_args = [go_executable, "build", "-o", str(output_path)]
+
+            if ldflags:
+                build_args.extend(["-ldflags", ldflags])
+            if tags:
+                build_args.extend(["-tags", ",".join(tags)])
+            if target:
+                build_args.append(str(target))
+
+            result = run_build(build_args, source_dir, output_path.parent, env_copy)
+            last_result = result
+
+            if result["success"]:
+                logger.info("✅ 构建成功")
+                return result
+
+            if i < len(GoBinaryBuilder.MIRROR_KEYS) - 1:
+                logger.warning(f"❌ {mirror_name} 失败，切换到备用镜像...")
+
+        assert last_result is not None
+        return last_result
+
+    @staticmethod
+    def build_single(
+        go_executable: str,
+        source_dir: Path,
+        output_path: Path,
+        env: dict[str, str],
+        ldflags: str | None,
+        tags: list[str] | None,
+        target: str | Path | None,
+        run_build,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Build binary with single mirror.
+
+        Args:
+            go_executable: Path to Go executable
+            source_dir: Source directory
+            output_path: Output path for binary
+            env: Environment variables
+            ldflags: Linker flags
+            tags: Build tags
+            target: Build target
+            run_build: Callback to execute build
+            stream_output: Whether to stream output
+
+        Returns:
+            BuildResult with success status
+        """
+        build_args = [go_executable, "build", "-o", str(output_path)]
+
+        if ldflags:
+            build_args.extend(["-ldflags", ldflags])
+        if tags:
+            build_args.extend(["-tags", ",".join(tags)])
+        if target:
+            build_args.append(str(target))
+
+        logger.info("🔨 开始构建...")
+        build_result = run_build(build_args, source_dir, output_path.parent, env)
+
+        if build_result["success"]:
+            logger.info("✅ 构建成功")
+
+        return build_result