multi-lang-build 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

multi_lang_build/compiler/python_support/installer.py

@@ -0,0 +1,162 @@
+"""Python dependency installation."""
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class DependencyInstaller:
+    """Install Python dependencies for various build systems."""
+
+    @staticmethod
+    def install_poetry(
+        python_executable: str,
+        source_dir: Path,
+        environment: dict[str, str],
+        dev: bool = False,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Install dependencies using Poetry."""
+        cmd = [python_executable, "-m", "poetry", "install"]
+        if dev:
+            cmd.append("--with=dev")
+
+        return DependencyInstaller._run_pip(
+            cmd, source_dir, source_dir, environment, stream_output
+        )
+
+    @staticmethod
+    def install_pip(
+        python_executable: str,
+        source_dir: Path,
+        environment: dict[str, str],
+        dev: bool = False,
+        stream_output: bool = True,
+    ) -> BuildResult:
+        """Install dependencies using pip."""
+        cmd = [python_executable, "-m", "pip", "install", "-r", str(source_dir / "requirements.txt")]
+
+        if dev:
+            cmd.append("-r")
+            cmd.append(str(source_dir / "requirements-dev.txt"))
+
+        return DependencyInstaller._run_pip(
+            cmd, source_dir, source_dir, environment, stream_output
+        )
+
+    @staticmethod
+    def _run_pip(
+        command: list[str],
+        source_dir: Path,
+        output_dir: Path,
+        environment: dict[str, str],
+        stream_output: bool,
+    ) -> BuildResult:
+        """Execute pip command."""
+        import time
+
+        start_time = time.perf_counter()
+
+        try:
+            if stream_output:
+                return DependencyInstaller._stream_pip(
+                    command, source_dir, environment, start_time
+                )
+            else:
+                return DependencyInstaller._capture_pip(
+                    command, source_dir, environment, start_time
+                )
+        except Exception as e:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-2,
+                stdout="",
+                stderr=f"Install error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+
+    @staticmethod
+    def _stream_pip(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute pip with streaming output."""
+        import os
+        import subprocess as sp
+        import sys
+
+        stdout_buffer = []
+        stderr_buffer = []
+
+        process = sp.Popen(
+            command,
+            cwd=source_dir,
+            stdout=sp.PIPE,
+            stderr=sp.PIPE,
+            text=True,
+            env={**os.environ, **environment},
+        )
+
+        # Read stdout
+        if process.stdout:
+            for line in process.stdout:
+                line = line.rstrip('\n\r')
+                stdout_buffer.append(line)
+                print(line)
+                sys.stdout.flush()
+
+        # Read stderr
+        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=source_dir,
+            duration_seconds=duration,
+        )
+
+    @staticmethod
+    def _capture_pip(
+        command: list[str],
+        source_dir: Path,
+        environment: dict[str, str],
+        start_time: float,
+    ) -> BuildResult:
+        """Execute pip with captured output."""
+        result = subprocess.run(
+            command,
+            cwd=source_dir,
+            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=source_dir,
+            duration_seconds=duration,
+        )

multi_lang_build/compiler/python_support/venv.py

@@ -0,0 +1,63 @@
+"""Python virtual environment management."""
+
+import time
+import venv
+from pathlib import Path
+
+from multi_lang_build.compiler.base import BuildResult
+
+
+class VenvManager:
+    """Manage Python virtual environments."""
+
+    @staticmethod
+    def create(
+        directory: Path,
+        python_path: str | None = None,
+        mirror_enabled: bool = True,
+    ) -> BuildResult:
+        """Create a virtual environment.
+
+        Args:
+            directory: Directory to create the venv in
+            python_path: Python interpreter to use
+            mirror_enabled: Whether to configure pip mirror
+
+        Returns:
+            BuildResult containing success status and output information.
+        """
+        start_time = time.perf_counter()
+
+        try:
+            env_builder = venv.EnvBuilder(with_pip=True, clear=True)
+            env_builder.create(directory)
+
+            # Configure pip mirror if enabled
+            if mirror_enabled:
+                pip_config_dir = directory / "pip.conf"
+                pip_config_dir.write_text(
+                    "[global]\n"
+                    "index-url = https://pypi.tuna.tsinghua.edu.cn/simple\n"
+                    "trusted-host = pypi.tuna.tsinghua.edu.cn\n"
+                )
+
+            duration = time.perf_counter() - start_time
+
+            return BuildResult(
+                success=True,
+                return_code=0,
+                stdout=f"Virtual environment created at {directory}",
+                stderr="",
+                output_path=directory,
+                duration_seconds=duration,
+            )
+        except Exception as e:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-1,
+                stdout="",
+                stderr=f"Failed to create virtual environment: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )

multi_lang_build/ide_register.py

@@ -0,0 +1,97 @@
+"""Register multi-lang-build as a skill for various IDEs."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from typing import Literal
+
+from multi_lang_build.register.support import (
+    register_claude_code,
+    register_opencode,
+    register_trae,
+    register_codebuddy,
+)
+
+
+def get_cli_path() -> str:
+    """Get the path to the multi-lang-build CLI."""
+    result = subprocess.run(
+        ["which", "multi-lang-build"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return f"{sys.executable} -m multi_lang_build"
+
+
+def register_skill(
+    ide: Literal["claude", "opencode", "trae", "codebuddy", "all"] = "claude",
+    global_level: bool = False
+) -> bool:
+    """Register multi-lang-build as a skill for the specified IDE.
+
+    Args:
+        ide: The IDE to register with. Options: "claude", "opencode", "trae", "codebuddy", "all"
+             Default is "claude".
+        global_level: If True, register to global config. If False (default), register to project-level.
+
+    Returns:
+        True if registration succeeded, False otherwise.
+    """
+    print(f"📝 Registering multi-lang-build for {ide}...\n")
+
+    if ide == "all":
+        results = [
+            ("Claude Code", register_claude_code(project_level=not global_level)),
+            ("OpenCode", register_opencode(project_level=not global_level)),
+            ("Trae", register_trae(project_level=not global_level)),
+            ("CodeBuddy", register_codebuddy(project_level=not global_level)),
+        ]
+
+        print("\n" + "=" * 50)
+        print("Registration Summary:")
+        for name, success in results:
+            status = "✅" if success else "❌"
+            print(f"  {status} {name}")
+
+        return all(success for _, success in results)
+
+    elif ide == "claude":
+        return register_claude_code(project_level=not global_level)
+    elif ide == "opencode":
+        return register_opencode(project_level=not global_level)
+    elif ide == "trae":
+        return register_trae(project_level=not global_level)
+    elif ide == "codebuddy":
+        return register_codebuddy(project_level=not global_level)
+    else:
+        print(f"❌ Unknown IDE: {ide}")
+        print("Supported IDEs: claude, opencode, trae, codebuddy, all")
+        return False
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Register multi-lang-build as an IDE skill"
+    )
+    parser.add_argument(
+        "ide",
+        nargs="?",
+        default="claude",
+        choices=["claude", "opencode", "trae", "codebuddy", "all"],
+        help="IDE to register with (default: claude)",
+    )
+    parser.add_argument(
+        "--global",
+        dest="global_level",
+        action="store_true",
+        help="Register to global config instead of project-level",
+    )
+
+    args = parser.parse_args()
+    success = register_skill(args.ide, global_level=args.global_level)
+    sys.exit(0 if success else 1)

multi_lang_build/mirror/config.py

@@ -249,3 +249,22 @@ def validate_mirror_config(mirror_config: MirrorConfig) -> bool:
         return False
     
     return True
+
+
+# Go mirrors in failover order (goproxy.io → goproxy.cn → goproxy.vip.cn)
+GO_MIRROR_FALLBACK_ORDER = ["go_qiniu", "go", "go_vip"]
+
+
+def get_go_mirror_with_fallback(failover: bool = True) -> list[str]:
+    """Get Go mirror list for failover.
+
+    Args:
+        failover: If True, return all mirrors in fallback order.
+                 If False, return only the default mirror.
+
+    Returns:
+        List of mirror keys to try.
+    """
+    if failover:
+        return GO_MIRROR_FALLBACK_ORDER
+    return ["go"]

multi_lang_build/register/support/__init__.py

@@ -0,0 +1,13 @@
+"""IDE registration support modules."""
+
+from multi_lang_build.register.support.claude import register_claude_code
+from multi_lang_build.register.support.opencode import register_opencode
+from multi_lang_build.register.support.trae import register_trae
+from multi_lang_build.register.support.codebuddy import register_codebuddy
+
+__all__ = [
+    "register_claude_code",
+    "register_opencode",
+    "register_trae",
+    "register_codebuddy",
+]

multi_lang_build/register/support/claude.py

@@ -0,0 +1,94 @@
+"""Register with Claude Code."""
+
+from pathlib import Path
+import subprocess
+
+
+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/multi-lang-build.md.
+                      If False, register to global ~/.claude/CLAUDE.md.
+    """
+    try:
+        # Determine registration path
+        if project_level:
+            # Project-level: .claude/multi-lang-build.md in current directory
+            config_dir = Path.cwd() / ".claude"
+            config_dir.mkdir(exist_ok=True)
+            skill_file = config_dir / "multi-lang-build.md"
+            level_name = "project-level"
+        else:
+            # Global-level: ~/.claude/CLAUDE.md (only check CLI for global)
+            result = subprocess.run(
+                ["which", "claude"],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode != 0:
+                print("❌ Claude Code CLI not found. Please install it first:")
+                print("   npm install -g @anthropic-ai/claude-code")
+                return False
+
+            claude_dir = Path.home() / ".claude"
+            claude_dir.mkdir(exist_ok=True)
+            skill_file = claude_dir / "CLAUDE.md"
+            level_name = "global"
+
+        skill_content = """## Multi-Lang Build Tool
+
+You can use the `multi-lang-build` tool to compile projects:
+
+### Available Commands:
+- `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
+# Build Go project
+multi-lang-build go ./src --output ./bin/app --mirror
+
+# Build with specific target (multi-entry support)
+multi-lang-build go ./src --output ./bin/server --target cmd/server/main.go
+
+# Build Python project
+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 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:
+            # 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

multi_lang_build/register/support/codebuddy.py

@@ -0,0 +1,100 @@
+"""Register with CodeBuddy."""
+
+from pathlib import Path
+
+
+def register_codebuddy(project_level: bool = True) -> bool:
+    """Register as CodeBuddy skill.
+
+    Args:
+        project_level: If True (default), register to project-level .codebuddy/skills.yaml.
+                      If False, register to global ~/.codebuddy/skills.yaml.
+    """
+    try:
+        # Determine registration path
+        if project_level:
+            # Project-level: .codebuddy/skills.yaml in current directory
+            base_dir = Path.cwd()
+            config_dir = base_dir / ".codebuddy"
+            config_dir.mkdir(exist_ok=True)
+            skills_file = config_dir / "skills.yaml"
+            level_name = "project-level"
+        else:
+            # Global-level: ~/.codebuddy/skills.yaml
+            config_dir = Path.home() / ".codebuddy"
+            config_dir.mkdir(exist_ok=True)
+            skills_file = config_dir / "skills.yaml"
+            level_name = "global"
+
+        skill_config = """# Multi-Lang Build Skill
+skills:
+  multi-lang-build:
+    name: "Multi-Lang Build"
+    description: "Multi-language automated build tool with mirror acceleration"
+    version: "0.2.0"
+
+    commands:
+      build-go:
+        description: "Build Go project"
+        command: "multi-lang-build go {source} --output {output}"
+        args:
+          - name: source
+            description: "Source directory"
+            required: true
+          - name: output
+            description: "Output path"
+            required: true
+          - name: target
+            description: "Build target (file or directory)"
+            required: false
+          - name: mirror
+            description: "Enable mirror acceleration"
+            type: flag
+
+      build-python:
+        description: "Build Python project"
+        command: "multi-lang-build python {source} --output {output}"
+        args:
+          - name: source
+            description: "Source directory"
+            required: true
+          - name: output
+            description: "Output directory"
+            required: true
+          - name: mirror
+            description: "Enable mirror acceleration"
+            type: flag
+
+      build-pnpm:
+        description: "Build pnpm project"
+        command: "multi-lang-build pnpm {source} --output {output}"
+        args:
+          - name: source
+            description: "Source directory"
+            required: true
+          - name: output
+            description: "Output directory"
+            required: true
+          - name: mirror
+            description: "Enable mirror acceleration"
+            type: flag
+"""
+
+        # Append or create
+        if skills_file.exists():
+            content = skills_file.read_text()
+            if "multi-lang-build" not in content:
+                with open(skills_file, "a") as f:
+                    f.write("\n" + skill_config)
+                print(f"✅ Registered with CodeBuddy ({level_name}, updated {skills_file})")
+            else:
+                print(f"ℹ️ Already registered with CodeBuddy ({level_name}, {skills_file})")
+        else:
+            skills_file.write_text(skill_config)
+            print(f"✅ Registered with CodeBuddy ({level_name}, created {skills_file})")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Failed to register with CodeBuddy: {e}")
+        return False

multi_lang_build/register/support/opencode.py

@@ -0,0 +1,62 @@
+"""Register with OpenCode."""
+
+import json
+from pathlib import Path
+
+
+def register_opencode(project_level: bool = True) -> bool:
+    """Register as OpenCode skill.
+
+    Args:
+        project_level: If True (default), register to project-level .opencode/skills.json.
+                      If False, register to global ~/.config/opencode/skills.json.
+    """
+    try:
+        # Determine registration path
+        if project_level:
+            # Project-level: .opencode/skills.json in current directory
+            base_dir = Path.cwd()
+            config_dir = base_dir / ".opencode"
+            config_dir.mkdir(exist_ok=True)
+            skills_file = config_dir / "skills.json"
+            level_name = "project-level"
+        else:
+            # Global-level: ~/.config/opencode/skills.json
+            config_dir = Path.home() / ".config" / "opencode"
+            config_dir.mkdir(parents=True, exist_ok=True)
+            skills_file = config_dir / "skills.json"
+            level_name = "global"
+
+        # Create or update skills.json
+        skills: dict = {}
+
+        if skills_file.exists():
+            with open(skills_file) as f:
+                skills = json.load(f)
+
+        # Add multi-lang-build skill
+        skills["multi-lang-build"] = {
+            "name": "multi-lang-build",
+            "description": "Multi-language automated build tool with mirror acceleration",
+            "commands": {
+                "build-go": "multi-lang-build go <source> --output <output> [--mirror] [--target <target>]",
+                "build-python": "multi-lang-build python <source> --output <output> [--mirror]",
+                "build-pnpm": "multi-lang-build pnpm <source> --output <output> [--mirror]",
+            },
+            "examples": [
+                "multi-lang-build go ./src --output ./bin/app --mirror",
+                "multi-lang-build go ./src --output ./bin/server --target cmd/server/main.go",
+                "multi-lang-build python ./src --output ./dist --mirror",
+                "multi-lang-build pnpm ./src --output ./dist --mirror",
+            ]
+        }
+
+        with open(skills_file, "w") as f:
+            json.dump(skills, f, indent=2)
+
+        print(f"✅ Registered with OpenCode ({level_name}, config: {skills_file})")
+        return True
+
+    except Exception as e:
+        print(f"❌ Failed to register with OpenCode: {e}")
+        return False

multi_lang_build/register/support/trae.py

@@ -0,0 +1,72 @@
+"""Register with Trae."""
+
+import json
+from pathlib import Path
+
+
+def register_trae(project_level: bool = True) -> bool:
+    """Register as Trae skill.
+
+    Args:
+        project_level: If True (default), register to project-level .trae/skills.json.
+                      If False, register to global ~/.trae/skills.json.
+    """
+    try:
+        # Determine registration path
+        if project_level:
+            # Project-level: .trae/skills.json in current directory
+            base_dir = Path.cwd()
+            config_dir = base_dir / ".trae"
+            config_dir.mkdir(exist_ok=True)
+            skills_file = config_dir / "skills.json"
+            level_name = "project-level"
+        else:
+            # Global-level: ~/.trae/skills.json
+            config_dir = Path.home() / ".trae"
+            config_dir.mkdir(exist_ok=True)
+            skills_file = config_dir / "skills.json"
+            level_name = "global"
+
+        # Create or update skills.json
+        skills: dict = {}
+
+        if skills_file.exists():
+            with open(skills_file) as f:
+                skills = json.load(f)
+
+        # Add multi-lang-build skill
+        skills["multi-lang-build"] = {
+            "name": "Multi-Lang Build",
+            "description": "Automated build tool for Go, Python, and pnpm projects",
+            "category": "build",
+            "commands": [
+                {
+                    "name": "build-go",
+                    "command": "multi-lang-build go {source} --output {output}",
+                    "description": "Build Go project",
+                    "args": ["source", "output", "target", "mirror"]
+                },
+                {
+                    "name": "build-python",
+                    "command": "multi-lang-build python {source} --output {output}",
+                    "description": "Build Python project",
+                    "args": ["source", "output", "mirror"]
+                },
+                {
+                    "name": "build-pnpm",
+                    "command": "multi-lang-build pnpm {source} --output {output}",
+                    "description": "Build pnpm project",
+                    "args": ["source", "output", "mirror"]
+                }
+            ]
+        }
+
+        with open(skills_file, "w") as f:
+            json.dump(skills, f, indent=2)
+
+        print(f"✅ Registered with Trae ({level_name}, config: {skills_file})")
+        return True
+
+    except Exception as e:
+        print(f"❌ Failed to register with Trae: {e}")
+        return False