multi-lang-build 0.2.0__py3-none-any.whl

multi_lang_build/__init__.py

@@ -0,0 +1,57 @@
+"""Multi-Lang Build - Multi-language automated build tool with domestic mirror acceleration."""
+
+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.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"
+__all__ = [
+    "BuildConfig",
+    "BuildResult",
+    "CompilerBase",
+    "PnpmCompiler",
+    "GoCompiler",
+    "PythonCompiler",
+    "MirrorConfig",
+    "get_mirror_config",
+    "register_skill",
+]
+
+
+def main() -> None:
+    """Main entry point for the multi-lang-build CLI tool."""
+    import sys
+    from multi_lang_build.cli import run_cli
+
+    run_cli(sys.argv[1:])
+
+
+def main_register() -> None:
+    """Entry point for the register CLI tool."""
+    import sys
+    import argparse
+    from multi_lang_build.register import register_skill
+
+    parser = argparse.ArgumentParser(
+        description="Register multi-lang-build as an IDE skill",
+        prog="multi-lang-register",
+    )
+    parser.add_argument(
+        "ide",
+        nargs="?",
+        default="claude",
+        choices=["claude", "opencode", "trae", "codebuddy", "all"],
+        help="IDE to register with (default: claude)",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    args = parser.parse_args()
+    success = register_skill(args.ide)
+    sys.exit(0 if success else 1)

multi_lang_build/cli.py

@@ -0,0 +1,256 @@
+"""CLI interface for auto-build tool."""
+
+from pathlib import Path
+from typing import Sequence, TypedDict
+
+
+class BuildResult(TypedDict):
+    """Result of a build operation."""
+    success: bool
+    return_code: int
+    stdout: str
+    stderr: str
+    output_path: Path | None
+    duration_seconds: float
+
+
+def run_cli(args: Sequence[str]) -> None:
+    """Run the CLI with the given arguments.
+    
+    Args:
+        args: Command line arguments (excluding program name)
+    """
+    import argparse
+    import sys
+    
+    parser = argparse.ArgumentParser(
+        description="AutoBuild - Multi-language automated build tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s pnpm ./src --output ./dist --mirror
+  %(prog)s go ./src --output ./bin/app --mirror
+  %(prog)s python ./src --output ./dist --mirror --poetry
+
+Supported languages:
+  pnpm    - Frontend JavaScript/TypeScript projects
+  go      - Go projects with module support  
+  python  - Python projects with pip/poetry/pdm
+        """,
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__import__('multi_lang_build').__version__}",
+    )
+    
+    subparsers = parser.add_subparsers(
+        dest="language",
+        title="language",
+        description="Build tool for specific language",
+    )
+    
+    pnpm_parser = subparsers.add_parser(
+        "pnpm",
+        help="Build pnpm-based frontend projects",
+        description="Build pnpm-based frontend projects with mirror acceleration",
+    )
+    pnpm_parser.add_argument("source_dir", type=Path, help="Source directory")
+    pnpm_parser.add_argument("-o", "--output", type=Path, required=True, help="Output directory")
+    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")
+    
+    go_parser = subparsers.add_parser(
+        "go",
+        help="Build Go projects",
+        description="Build Go projects with module support and mirror acceleration",
+    )
+    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("--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")
+    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")
+    
+    python_parser = subparsers.add_parser(
+        "python",
+        help="Build Python projects",
+        description="Build Python projects with pip/poetry/pdm and mirror acceleration",
+    )
+    python_parser.add_argument("source_dir", type=Path, help="Source directory")
+    python_parser.add_argument("-o", "--output", type=Path, required=True, help="Output directory")
+    python_parser.add_argument("--mirror/--no-mirror", default=True, help="Enable/disable PyPI mirror")
+    python_parser.add_argument("--install", action="store_true", help="Install dependencies only")
+    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")
+    
+    mirror_parser = subparsers.add_parser(
+        "mirror",
+        help="Manage mirror configurations",
+        description="List or configure mirror settings",
+    )
+    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")
+
+    # Register subcommand for IDE integration
+    register_parser = subparsers.add_parser(
+        "register",
+        help="Register as IDE skill (Claude Code, OpenCode, Trae, CodeBuddy)",
+        description="Register multi-lang-build as a skill for various AI coding assistants and IDEs",
+        epilog="""
+Examples:
+  %(prog)s register              # Register with Claude Code (default)
+  %(prog)s register claude       # Register with Claude Code
+  %(prog)s register opencode     # Register with OpenCode
+  %(prog)s register trae         # Register with Trae
+  %(prog)s register codebuddy    # Register with CodeBuddy
+  %(prog)s register all          # Register with all supported IDEs
+        """,
+    )
+    register_parser.add_argument(
+        "ide",
+        nargs="?",
+        default="claude",
+        choices=["claude", "opencode", "trae", "codebuddy", "all"],
+        help="IDE to register with (default: claude)",
+    )
+    
+    parsed_args = parser.parse_args(args)
+    
+    if parsed_args.language is None:
+        parser.print_help()
+        sys.exit(1)
+    
+    result: BuildResult | None = None
+    
+    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,
+                    parsed_args.script,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            elif parsed_args.install:
+                result = compiler.install_dependencies(
+                    parsed_args.source_dir,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            else:
+                result = compiler.build(
+                    parsed_args.source_dir,
+                    parsed_args.output,
+                    mirror_enabled=parsed_args.mirror,
+                )
+        
+        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,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            elif parsed_args.tidy:
+                result = compiler.tidy_modules(
+                    parsed_args.source_dir,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            elif parsed_args.all:
+                result = compiler.build_all(
+                    parsed_args.source_dir,
+                    parsed_args.output,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            else:
+                tags = parsed_args.tags.split(",") if parsed_args.tags else None
+                result = compiler.build_binary(
+                    parsed_args.source_dir,
+                    parsed_args.output,
+                    mirror_enabled=parsed_args.mirror,
+                    ldflags=parsed_args.ldflags,
+                    tags=tags,
+                )
+        
+        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,
+                    mirror_enabled=parsed_args.mirror,
+                )
+            elif parsed_args.install:
+                result = compiler.install_dependencies(
+                    parsed_args.source_dir,
+                    mirror_enabled=parsed_args.mirror,
+                    dev=parsed_args.dev,
+                    poetry=parsed_args.poetry,
+                )
+            else:
+                result = compiler.build(
+                    parsed_args.source_dir,
+                    parsed_args.output,
+                    mirror_enabled=parsed_args.mirror,
+                )
+        
+        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(",")]
+
+                print("Available mirrors:")
+                for mirror_name in sorted(mirrors):
+                    config = get_mirror_config(mirror_name)
+                    if config:
+                        print(f"  {mirror_name}: {config['url']}")
+            else:
+                mirror_parser.print_help()
+
+        elif parsed_args.language == "register":
+            from multi_lang_build.register import register_skill
+
+            success = register_skill(parsed_args.ide)
+            if success:
+                print("\n✅ Registration completed successfully!")
+                print(f"\nYou can now use 'multi-lang-build' commands in {parsed_args.ide}")
+            else:
+                print("\n❌ Registration failed for some IDEs.")
+            sys.exit(0 if success else 1)
+
+        else:
+            parser.print_help()
+            sys.exit(1)
+        
+        if result is not None and result["success"]:
+            print(f"Build completed successfully in {result['duration_seconds']:.2f}s")
+            if result["output_path"]:
+                print(f"Output: {result['output_path']}")
+            sys.exit(0)
+        elif result is not None:
+            print(f"Build failed with code {result['return_code']}")
+            if result["stderr"]:
+                print(f"Error: {result['stderr']}")
+            sys.exit(1)
+    
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(2)

multi_lang_build/compiler/__init__.py

@@ -0,0 +1,22 @@
+"""Compiler module for auto-build tool."""
+
+from multi_lang_build.compiler.base import (
+    BuildConfig,
+    BuildResult,
+    CompilerInfo,
+    CompilerBase,
+)
+
+from multi_lang_build.compiler.pnpm import PnpmCompiler
+from multi_lang_build.compiler.go import GoCompiler
+from multi_lang_build.compiler.python import PythonCompiler
+
+__all__ = [
+    "BuildConfig",
+    "BuildResult", 
+    "CompilerInfo",
+    "CompilerBase",
+    "PnpmCompiler",
+    "GoCompiler",
+    "PythonCompiler",
+]

multi_lang_build/compiler/base.py

@@ -0,0 +1,196 @@
+"""Base compiler interface and common types."""
+
+from abc import ABC, abstractmethod
+from typing import TypeAlias, TypedDict, NotRequired
+from pathlib import Path
+import time
+
+
+class BuildConfig(TypedDict, total=False):
+    """Build configuration for compiler."""
+    source_dir: Path
+    output_dir: Path
+    environment: dict[str, str]
+    mirror_enabled: bool
+    mirror_region: str
+    extra_args: list[str]
+
+
+class BuildResult(TypedDict):
+    """Result of a build operation."""
+    success: bool
+    return_code: int
+    stdout: str
+    stderr: str
+    output_path: Path | None
+    duration_seconds: float
+
+
+class CompilerInfo(TypedDict):
+    """Information about a compiler."""
+    name: str
+    version: str
+    supported_mirrors: list[str]
+    default_mirror: str
+    executable: str
+
+
+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,
+        source_dir: Path,
+        output_dir: Path,
+        *,
+        environment: dict[str, str] | None = None,
+        mirror_enabled: bool = True,
+        extra_args: list[str] | None = None,
+    ) -> 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
+            
+        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],
+        source_dir: Path,
+        output_dir: Path,
+        *,
+        environment: dict[str, str] | None = None,
+        extra_args: list[str] | None = None,
+    ) -> 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
+            
+        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()
+        
+        try:
+            result = subprocess.run(
+                full_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,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                output_path=output_dir if result.returncode == 0 else None,
+                duration_seconds=duration,
+            )
+            
+        except subprocess.TimeoutExpired:
+            duration = time.perf_counter() - start_time
+            return BuildResult(
+                success=False,
+                return_code=-1,
+                stdout="",
+                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="",
+                stderr=f"Build error: {str(e)}",
+                output_path=None,
+                duration_seconds=duration,
+            )
+    
+    def _validate_directory(self, directory: Path, create_if_not_exists: bool = True) -> Path:
+        """Validate and optionally create a directory.
+        
+        Args:
+            directory: Directory path to validate
+            create_if_not_exists: Create directory if it doesn't exist
+            
+        Returns:
+            Resolved absolute path
+            
+        Raises:
+            ValueError: If directory cannot be created or is not a directory
+        """
+        if not directory.exists():
+            if create_if_not_exists:
+                directory.mkdir(parents=True, exist_ok=True)
+            else:
+                raise ValueError(f"Directory does not exist: {directory}")
+        
+        if not directory.is_dir():
+            raise ValueError(f"Path is not a directory: {directory}")
+        
+        return directory.resolve()