multi-lang-build 0.2.0__tar.gz → 0.2.2__tar.gz

{multi_lang_build-0.2.0 → multi_lang_build-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-lang-build
-Version: 0.2.0
+Version: 0.2.2
 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.0 → multi_lang_build-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "multi-lang-build"
-version = "0.2.0"
+version = "0.2.2"
 description = "Multi-language automated build tool with domestic mirror acceleration support"
 readme = "README.md"
 license = {text = "MIT"}
@@ -43,6 +43,7 @@ pnpm-build = "multi_lang_build.compiler.pnpm:main"
 go-build = "multi_lang_build.compiler.go:main"
 python-build = "multi_lang_build.compiler.python:main"
 multi-lang-register = "multi_lang_build:main_register"
+multi-lang-mirror = "multi_lang_build.mirror.cli:mirror_main"
 
 [project.urls]
 Homepage = "https://github.com/example/multi-lang-build"

{multi_lang_build-0.2.0 → multi_lang_build-0.2.2}/src/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.1"
 __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-0.2.0 → multi_lang_build-0.2.2}/src/multi_lang_build/cli.py

@@ -92,12 +92,54 @@ Supported languages:
     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(
@@ -210,18 +252,33 @@ Examples:
                 )
         
         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
+            from multi_lang_build.mirror.cli import configure_mirror, print_mirrors, get_current_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']}")
+            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-0.2.2/src/multi_lang_build/mirror/cli.py

@@ -0,0 +1,340 @@
+"""Mirror configuration CLI for domestic acceleration."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Literal
+
+
+def get_all_mirrors() -> dict:
+    """Get all available mirrors with their configurations."""
+    from multi_lang_build.mirror.config import MIRROR_CONFIGS
+
+    mirrors = {}
+    for key, config in MIRROR_CONFIGS.items():
+        mirrors[key] = {
+            "name": config["name"],
+            "url": config["url"],
+        }
+    return mirrors
+
+
+def print_mirrors() -> None:
+    """Print all available mirrors."""
+    mirrors = get_all_mirrors()
+
+    print("\n📦 Available Mirrors:")
+    print("-" * 60)
+
+    # Group by category
+    categories = {
+        "js": ["npm", "pnpm", "yarn"],
+        "go": ["go", "go_qiniu", "go_vip"],
+        "python": ["pip", "pip_aliyun", "pip_douban", "pip_huawei", "python", "poetry"],
+    }
+
+    category_names = {
+        "js": "🌐 JavaScript (npm/pnpm/yarn)",
+        "go": "🔷 Go",
+        "python": "🐍 Python (pip/PyPI)",
+    }
+
+    for cat_key, cat_mirrors in categories.items():
+        print(f"\n{category_names.get(cat_key, cat_key)}")
+        for mirror_key in cat_mirrors:
+            if mirror_key in mirrors:
+                config = mirrors[mirror_key]
+                print(f"  • {mirror_key:12} - {config['name']}")
+                print(f"               {config['url']}")
+
+    print()
+
+
+def configure_pip(mirror_key: str) -> bool:
+    """Configure pip mirror using pip config command."""
+    from multi_lang_build.mirror.config import get_mirror_config
+
+    config = get_mirror_config(mirror_key)
+    if config is None:
+        print(f"❌ Unknown pip mirror: {mirror_key}")
+        return False
+
+    url = config["url"]
+    if not url.endswith("/simple") and not url.endswith("/simple/"):
+        url = f"{url}/simple"
+
+    # Try pip3 first, fallback to pip
+    pip_cmd = "pip3" if sys.platform != "win32" else "pip"
+
+    try:
+        subprocess.run(
+            [pip_cmd, "config", "set", "global.index-url", url],
+            check=True,
+        )
+        print(f"✅ pip mirror set to: {url}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to set pip mirror: {e}")
+        return False
+    except FileNotFoundError:
+        # Try alternative
+        try:
+            alternative = "pip" if pip_cmd == "pip3" else "pip3"
+            subprocess.run(
+                [alternative, "config", "set", "global.index-url", url],
+                check=True,
+            )
+            print(f"✅ pip mirror set to: {url}")
+            return True
+        except Exception:
+            print("❌ pip/pip3 not found")
+            return False
+
+
+def configure_go(mirror_key: str) -> bool:
+    """Configure Go proxy using go env -w."""
+    from multi_lang_build.mirror.config import get_mirror_config
+
+    config = get_mirror_config(mirror_key)
+    if config is None:
+        print(f"❌ Unknown Go mirror: {mirror_key}")
+        return False
+
+    # Get the GOPROXY value from environment variables
+    proxy_value = config["environment_variables"].get("GOPROXY", f"{config['url']},direct")
+
+    try:
+        subprocess.run(
+            ["go", "env", "-w", f"GOPROXY={proxy_value}"],
+            check=True,
+        )
+        print(f"✅ Go GOPROXY set to: {proxy_value}")
+
+        # Also set GOSUMDB if present
+        gosumdb = config["environment_variables"].get("GOSUMDB")
+        if gosumdb:
+            subprocess.run(
+                ["go", "env", "-w", f"GOSUMDB={gosumdb}"],
+                check=True,
+            )
+            print(f"✅ Go GOSUMDB set to: {gosumdb}")
+
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to set Go mirror: {e}")
+        return False
+    except FileNotFoundError:
+        print("❌ go not found")
+        return False
+
+
+def configure_npm(mirror_key: str) -> bool:
+    """Configure npm/pnpm registry."""
+    from multi_lang_build.mirror.config import get_mirror_config
+
+    config = get_mirror_config(mirror_key)
+    if config is None:
+        print(f"❌ Unknown npm mirror: {mirror_key}")
+        return False
+
+    url = config["url"]
+
+    try:
+        subprocess.run(
+            ["npm", "config", "set", "registry", url],
+            check=True,
+        )
+        print(f"✅ npm registry set to: {url}")
+
+        # Also set for pnpm if available
+        try:
+            subprocess.run(
+                ["pnpm", "config", "set", "registry", url],
+                check=True,
+            )
+            print(f"✅ pnpm registry set to: {url}")
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to set npm registry: {e}")
+        return False
+    except FileNotFoundError:
+        print("❌ npm not found")
+        return False
+
+
+def get_current_config() -> dict:
+    """Get current mirror configuration."""
+    config = {}
+
+    # Try pip3 first, fallback to pip
+    pip_cmd = "pip3" if sys.platform != "win32" else "pip"
+
+    try:
+        result = subprocess.run(
+            [pip_cmd, "config", "get", "global.index-url"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            config["pip"] = result.stdout.strip()
+    except Exception:
+        pass
+
+    # Check Go
+    try:
+        result = subprocess.run(
+            ["go", "env", "GOPROXY"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            config["go"] = result.stdout.strip()
+    except Exception:
+        pass
+
+    # Check npm
+    try:
+        result = subprocess.run(
+            ["npm", "config", "get", "registry"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            config["npm"] = result.stdout.strip()
+    except Exception:
+        pass
+
+    return config
+
+
+def configure_mirror(mirror_type: str, mirror_key: str) -> bool:
+    """Configure mirror for a specific package manager.
+
+    Args:
+        mirror_type: Package manager type (pip, go, npm)
+        mirror_key: Mirror key to use
+
+    Returns:
+        True if successful, False otherwise
+    """
+    if mirror_type == "pip":
+        return configure_pip(mirror_key)
+    elif mirror_type == "go":
+        return configure_go(mirror_key)
+    elif mirror_type in ["npm", "pnpm"]:
+        return configure_npm(mirror_key)
+    else:
+        print(f"❌ Unknown package manager: {mirror_type}")
+        return False
+
+
+def mirror_main():
+    """Main entry point for mirror command."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Configure domestic mirror acceleration",
+        epilog="""
+Examples:
+  %(prog)s list                    List all available mirrors
+  %(prog)s set pip                 Configure pip mirror (default)
+  %(prog)s set go                  Configure Go proxy
+  %(prog)s set npm                 Configure npm registry
+  %(prog)s show                    Show current configuration
+        """,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s 0.2.2",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # list command
+    list_parser = subparsers.add_parser("list", help="List available mirrors")
+    list_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output as JSON",
+    )
+    list_parser.add_argument(
+        "--type",
+        type=str,
+        choices=["pip", "go", "npm"],
+        help="Filter by type",
+    )
+
+    # set command
+    set_parser = subparsers.add_parser("set", help="Configure mirror")
+    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 command
+    show_parser = subparsers.add_parser("show", help="Show current mirror configuration")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        mirrors = get_all_mirrors()
+        if getattr(args, "json", False):
+            print(json.dumps(mirrors, indent=2, ensure_ascii=False))
+        else:
+            print_mirrors()
+
+    elif args.command == "set":
+        mirror_type = args.type
+        mirror_key = args.mirror
+        success = configure_mirror(mirror_type, mirror_key)
+        sys.exit(0 if success else 1)
+
+    elif args.command == "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:
+        # No subcommand, show help
+        parser.print_help()
+        print("\n📋 Commands:")
+        print("  list              List all available mirrors")
+        print("  set <type> <name> Configure mirror (type: pip/go/npm)")
+        print("  show              Show current configuration")
+        print("\n📋 Examples:")
+        print("  multi-lang-build mirror list")
+        print("  multi-lang-build mirror set pip")
+        print("  multi-lang-build mirror set go")
+        print("  multi-lang-build mirror set npm")
+
+
+if __name__ == "__main__":
+    mirror_main()

{multi_lang_build-0.2.0 → multi_lang_build-0.2.2}/src/multi_lang_build/register.py

@@ -25,36 +25,44 @@ def get_cli_path() -> str:
     return f"{sys.executable} -m multi_lang_build"
 
 
-def register_claude_code() -> bool:
+def register_claude_code(project_level: bool = True) -> bool:
     """Register as Claude Code skill.
-    
-    Claude Code uses ~/.claude/CLAU.md for global instructions
-    and project-specific skills via the API.
+
+    Args:
+        project_level: If True (default), register to project-level .claude/CLAUDE.md.
+                      If False, register to global ~/.claude/CLAUDE.md.
     """
     try:
-        # Check if claude CLI is available
-        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
-        
-        # Create global instructions directory
-        claude_dir = Path.home() / ".claude"
-        claude_dir.mkdir(exist_ok=True)
-        
-        # Read existing CLAU.md or create new
-        claude_md = claude_dir / "CLAUDE.md"
+        # Determine registration path
+        if project_level:
+            # Project-level: .claude/CLAUDE.md in current directory
+            config_dir = Path.cwd() / ".claude"
+            config_dir.mkdir(exist_ok=True)
+            claude_md = config_dir / "CLAUDE.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)
+            claude_md = claude_dir / "CLAUDE.md"
+            level_name = "global"
+
+        # Read existing content
         existing_content = ""
         if claude_md.exists():
             existing_content = claude_md.read_text()
-        
-        # Add multi-lang-build skill section
+
         skill_section = """
 
 ## Multi-Lang Build Tool
@@ -83,50 +91,51 @@ multi-lang-build pnpm ./src --output ./dist --mirror
 
 When working with Go projects, check if there are multiple main packages and use the `--target` flag to specify which one to build.
 """
-        
+
         if "## Multi-Lang Build Tool" not in existing_content:
             with open(claude_md, "a") as f:
                 f.write(skill_section)
-            print(f"✅ Registered with Claude Code (added to {claude_md})")
+            print(f"✅ Registered with Claude Code ({level_name}, added to {claude_md})")
         else:
-            print(f"ℹ️ Already registered with Claude Code ({claude_md})")
-        
+            print(f"ℹ️ Already registered with Claude Code ({level_name}, {claude_md})")
+
         return True
-        
+
     except Exception as e:
         print(f"❌ Failed to register with Claude Code: {e}")
         return False
 
 
-def register_opencode() -> bool:
+def register_opencode(project_level: bool = True) -> bool:
     """Register as OpenCode skill.
-    
-    OpenCode typically uses ~/.config/opencode/ for configuration.
+
+    Args:
+        project_level: If True (default), register to project-level .opencode/skills.json.
+                      If False, register to global ~/.config/opencode/skills.json.
     """
     try:
-        # Check if opencode CLI is available
-        result = subprocess.run(
-            ["which", "opencode"],
-            capture_output=True,
-            text=True,
-        )
-        
-        if result.returncode != 0:
-            print("❌ OpenCode CLI not found. Please install it first.")
-            return False
-        
-        # Create OpenCode config directory
-        config_dir = Path.home() / ".config" / "opencode"
-        config_dir.mkdir(parents=True, exist_ok=True)
-        
+        # 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_file = config_dir / "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",
@@ -143,47 +152,48 @@ def register_opencode() -> bool:
                 "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 (config: {skills_file})")
+
+        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
 
 
-def register_trae() -> bool:
+def register_trae(project_level: bool = True) -> bool:
     """Register as Trae skill.
-    
-    Trae typically uses ~/.trae/ for configuration.
+
+    Args:
+        project_level: If True (default), register to project-level .trae/skills.json.
+                      If False, register to global ~/.trae/skills.json.
     """
     try:
-        # Check if trae CLI is available
-        result = subprocess.run(
-            ["which", "trae"],
-            capture_output=True,
-            text=True,
-        )
-        
-        if result.returncode != 0:
-            print("❌ Trae CLI not found. Please install it first.")
-            return False
-        
-        # Create Trae config directory
-        config_dir = Path.home() / ".trae"
-        config_dir.mkdir(exist_ok=True)
-        
+        # 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_file = config_dir / "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",
@@ -210,49 +220,48 @@ def register_trae() -> bool:
                 }
             ]
         }
-        
+
         with open(skills_file, "w") as f:
             json.dump(skills, f, indent=2)
-        
-        print(f"✅ Registered with Trae (config: {skills_file})")
+
+        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
 
 
-def register_codebuddy() -> bool:
+def register_codebuddy(project_level: bool = True) -> bool:
     """Register as CodeBuddy skill.
-    
-    CodeBuddy typically uses ~/.codebuddy/ for configuration.
+
+    Args:
+        project_level: If True (default), register to project-level .codebuddy/skills.yaml.
+                      If False, register to global ~/.codebuddy/skills.yaml.
     """
     try:
-        # Check if codebuddy CLI is available
-        result = subprocess.run(
-            ["which", "codebuddy"],
-            capture_output=True,
-            text=True,
-        )
-        
-        if result.returncode != 0:
-            print("❌ CodeBuddy CLI not found. Please install it first.")
-            return False
-        
-        # Create CodeBuddy config directory
-        config_dir = Path.home() / ".codebuddy"
-        config_dir.mkdir(exist_ok=True)
-        
-        # Create or update skills.yaml (CodeBuddy may use YAML)
-        skills_file = config_dir / "skills.yaml"
-        
+        # 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"
@@ -270,7 +279,7 @@ skills:
           - name: mirror
             description: "Enable mirror acceleration"
             type: flag
-            
+
       build-python:
         description: "Build Python project"
         command: "multi-lang-build python {source} --output {output}"
@@ -284,7 +293,7 @@ skills:
           - name: mirror
             description: "Enable mirror acceleration"
             type: flag
-            
+
       build-pnpm:
         description: "Build pnpm project"
         command: "multi-lang-build pnpm {source} --output {output}"
@@ -299,65 +308,67 @@ skills:
             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 (updated {skills_file})")
+                print(f"✅ Registered with CodeBuddy ({level_name}, updated {skills_file})")
             else:
-                print(f"ℹ️ Already registered with CodeBuddy ({skills_file})")
+                print(f"ℹ️ Already registered with CodeBuddy ({level_name}, {skills_file})")
         else:
             skills_file.write_text(skill_config)
-            print(f"✅ Registered with CodeBuddy (created {skills_file})")
-        
+            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
 
 
 def register_skill(
-    ide: Literal["claude", "opencode", "trae", "codebuddy", "all"] = "claude"
+    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()),
-            ("OpenCode", register_opencode()),
-            ("Trae", register_trae()),
-            ("CodeBuddy", register_codebuddy()),
+            ("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()
+        return register_claude_code(project_level=not global_level)
     elif ide == "opencode":
-        return register_opencode()
+        return register_opencode(project_level=not global_level)
     elif ide == "trae":
-        return register_trae()
+        return register_trae(project_level=not global_level)
     elif ide == "codebuddy":
-        return register_codebuddy()
+        return register_codebuddy(project_level=not global_level)
     else:
         print(f"❌ Unknown IDE: {ide}")
         print("Supported IDEs: claude, opencode, trae, codebuddy, all")
@@ -377,7 +388,13 @@ if __name__ == "__main__":
         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)
+    success = register_skill(args.ide, global_level=args.global_level)
     sys.exit(0 if success else 1)