mcpforunityserver 9.4.0b20260203025228__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,3 @@
+"""Unity MCP Command Line Interface."""
+
+__version__ = "1.0.0"

cli/commands/__init__.py

@@ -0,0 +1,3 @@
+"""CLI command modules."""
+
+# Commands will be registered in main.py

cli/commands/animation.py

@@ -0,0 +1,84 @@
+"""Animation CLI commands - placeholder for future implementation."""
+
+import click
+from typing import Optional, Any
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_info
+from cli.utils.connection import run_command, handle_unity_errors
+from cli.utils.constants import SEARCH_METHOD_CHOICE_BASIC
+
+
+@click.group()
+def animation():
+    """Animation operations - control Animator, play animations."""
+    pass
+
+
+@animation.command("play")
+@click.argument("target")
+@click.argument("state_name")
+@click.option(
+    "--layer", "-l",
+    default=0,
+    type=int,
+    help="Animator layer(TODO)."
+)
+@click.option(
+    "--search-method",
+    type=SEARCH_METHOD_CHOICE_BASIC,
+    default=None,
+    help="How to find the target."
+)
+@handle_unity_errors
+def play(target: str, state_name: str, layer: int, search_method: Optional[str]):
+    """Play an animation state on a target's Animator.
+
+    \b
+    Examples:
+        unity-mcp animation play "Player" "Walk"
+        unity-mcp animation play "Enemy" "Attack" --layer 1
+    """
+    config = get_config()
+
+    # Set Animator parameter to trigger state
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": "Animator",
+        "property": "Play",
+        "value": state_name,
+        "layer": layer,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    result = run_command("manage_components", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@animation.command("set-parameter")
+@click.argument("target")
+@click.argument("param_name")
+@click.argument("value")
+@click.option(
+    "--type", "-t",
+    "param_type",
+    type=click.Choice(["float", "int", "bool", "trigger"]),
+    default="float",
+    help="Parameter type."
+)
+def set_parameter(target: str, param_name: str, value: str, param_type: str):
+    """Set an Animator parameter.
+
+    \b
+    Examples:
+        unity-mcp animation set-parameter "Player" "Speed" 5.0
+        unity-mcp animation set-parameter "Player" "IsRunning" true --type bool
+        unity-mcp animation set-parameter "Player" "Jump" "" --type trigger
+    """
+    config = get_config()
+    print_info(
+        "Animation parameter command - requires custom Unity implementation")
+    click.echo(f"Would set {param_name}={value} ({param_type}) on {target}")

cli/commands/asset.py

@@ -0,0 +1,280 @@
+"""Asset CLI commands."""
+
+import sys
+import json
+import click
+from typing import Optional, Any
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_success
+from cli.utils.connection import run_command, handle_unity_errors
+from cli.utils.parsers import parse_json_dict_or_exit
+from cli.utils.confirmation import confirm_destructive_action
+
+
+@click.group()
+def asset():
+    """Asset operations - search, import, create, delete assets."""
+    pass
+
+
+@asset.command("search")
+@click.argument("pattern", default="*")
+@click.option(
+    "--path", "-p",
+    default="Assets",
+    help="Folder path to search in."
+)
+@click.option(
+    "--type", "-t",
+    "filter_type",
+    default=None,
+    help="Filter by asset type (e.g., Material, Prefab, MonoScript)."
+)
+@click.option(
+    "--limit", "-l",
+    default=25,
+    type=int,
+    help="Maximum results per page."
+)
+@click.option(
+    "--page",
+    default=1,
+    type=int,
+    help="Page number (1-based)."
+)
+@handle_unity_errors
+def search(pattern: str, path: str, filter_type: Optional[str], limit: int, page: int):
+    """Search for assets.
+
+    \b
+    Examples:
+        unity-mcp asset search "*.prefab"
+        unity-mcp asset search "Player*" --path "Assets/Characters"
+        unity-mcp asset search "*" --type Material
+        unity-mcp asset search "t:MonoScript" --path "Assets/Scripts"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "search",
+        "path": path,
+        "searchPattern": pattern,
+        "pageSize": limit,
+        "pageNumber": page,
+    }
+
+    if filter_type:
+        params["filterType"] = filter_type
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@asset.command("info")
+@click.argument("path")
+@click.option(
+    "--preview",
+    is_flag=True,
+    help="Generate preview thumbnail (may be large)."
+)
+@handle_unity_errors
+def info(path: str, preview: bool):
+    """Get detailed information about an asset.
+
+    \b
+    Examples:
+        unity-mcp asset info "Assets/Materials/Red.mat"
+        unity-mcp asset info "Assets/Prefabs/Player.prefab" --preview
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "get_info",
+        "path": path,
+        "generatePreview": preview,
+    }
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@asset.command("create")
+@click.argument("path")
+@click.argument("asset_type")
+@click.option(
+    "--properties", "-p",
+    default=None,
+    help='Initial properties as JSON.'
+)
+@handle_unity_errors
+def create(path: str, asset_type: str, properties: Optional[str]):
+    """Create a new asset.
+
+    \b
+    Examples:
+        unity-mcp asset create "Assets/Materials/Blue.mat" Material
+        unity-mcp asset create "Assets/NewFolder" Folder
+        unity-mcp asset create "Assets/Materials/Custom.mat" Material --properties '{"color": [0,0,1,1]}'
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "create",
+        "path": path,
+        "assetType": asset_type,
+    }
+
+    if properties:
+        params["properties"] = parse_json_dict_or_exit(properties, "properties")
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Created {asset_type}: {path}")
+
+
+@asset.command("delete")
+@click.argument("path")
+@click.option(
+    "--force", "-f",
+    is_flag=True,
+    help="Skip confirmation prompt."
+)
+@handle_unity_errors
+def delete(path: str, force: bool):
+    """Delete an asset.
+
+    \b
+    Examples:
+        unity-mcp asset delete "Assets/OldMaterial.mat"
+        unity-mcp asset delete "Assets/Unused" --force
+    """
+    config = get_config()
+
+    confirm_destructive_action("Delete", "asset", path, force)
+
+    result = run_command(
+        "manage_asset", {"action": "delete", "path": path}, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Deleted: {path}")
+
+
+@asset.command("duplicate")
+@click.argument("source")
+@click.argument("destination")
+@handle_unity_errors
+def duplicate(source: str, destination: str):
+    """Duplicate an asset.
+
+    \b
+    Examples:
+        unity-mcp asset duplicate "Assets/Materials/Red.mat" "Assets/Materials/RedCopy.mat"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "duplicate",
+        "path": source,
+        "destination": destination,
+    }
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Duplicated to: {destination}")
+
+
+@asset.command("move")
+@click.argument("source")
+@click.argument("destination")
+@handle_unity_errors
+def move(source: str, destination: str):
+    """Move an asset to a new location.
+
+    \b
+    Examples:
+        unity-mcp asset move "Assets/Old/Material.mat" "Assets/New/Material.mat"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "move",
+        "path": source,
+        "destination": destination,
+    }
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Moved to: {destination}")
+
+
+@asset.command("rename")
+@click.argument("path")
+@click.argument("new_name")
+@handle_unity_errors
+def rename(path: str, new_name: str):
+    """Rename an asset.
+
+    \b
+    Examples:
+        unity-mcp asset rename "Assets/Materials/Old.mat" "New.mat"
+    """
+    config = get_config()
+
+    # Construct destination path
+    import os
+    dir_path = os.path.dirname(path)
+    destination = os.path.join(dir_path, new_name).replace("\\", "/")
+
+    params: dict[str, Any] = {
+        "action": "rename",
+        "path": path,
+        "destination": destination,
+    }
+
+    result = run_command("manage_asset", params, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Renamed to: {new_name}")
+
+
+@asset.command("import")
+@click.argument("path")
+@handle_unity_errors
+def import_asset(path: str):
+    """Import/reimport an asset.
+
+    \b
+    Examples:
+        unity-mcp asset import "Assets/Textures/NewTexture.png"
+    """
+    config = get_config()
+
+    result = run_command(
+        "manage_asset", {"action": "import", "path": path}, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Imported: {path}")
+
+
+@asset.command("mkdir")
+@click.argument("path")
+@handle_unity_errors
+def mkdir(path: str):
+    """Create a folder.
+
+    \b
+    Examples:
+        unity-mcp asset mkdir "Assets/NewFolder"
+        unity-mcp asset mkdir "Assets/Levels/Chapter1"
+    """
+    config = get_config()
+
+    result = run_command(
+        "manage_asset", {"action": "create_folder", "path": path}, config)
+    click.echo(format_output(result, config.format))
+    if result.get("success"):
+        print_success(f"Created folder: {path}")

cli/commands/audio.py

@@ -0,0 +1,125 @@
+"""Audio CLI commands - placeholder for future implementation."""
+
+import sys
+import click
+from typing import Optional, Any
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_info
+from cli.utils.connection import run_command, handle_unity_errors
+from cli.utils.constants import SEARCH_METHOD_CHOICE_BASIC
+
+
+@click.group()
+def audio():
+    """Audio operations - AudioSource control, audio settings."""
+    pass
+
+
+@audio.command("play")
+@click.argument("target")
+@click.option(
+    "--clip", "-c",
+    default=None,
+    help="Audio clip path to play."
+)
+@click.option(
+    "--search-method",
+    type=SEARCH_METHOD_CHOICE_BASIC,
+    default=None,
+    help="How to find the target."
+)
+@handle_unity_errors
+def play(target: str, clip: Optional[str], search_method: Optional[str]):
+    """Play audio on a target's AudioSource.
+
+    \b
+    Examples:
+        unity-mcp audio play "MusicPlayer"
+        unity-mcp audio play "SFXSource" --clip "Assets/Audio/explosion.wav"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": "AudioSource",
+        "property": "Play",
+        "value": True,
+    }
+
+    if clip:
+        params["clip"] = clip
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    result = run_command("manage_components", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@audio.command("stop")
+@click.argument("target")
+@click.option(
+    "--search-method",
+    type=SEARCH_METHOD_CHOICE_BASIC,
+    default=None,
+    help="How to find the target."
+)
+@handle_unity_errors
+def stop(target: str, search_method: Optional[str]):
+    """Stop audio on a target's AudioSource.
+
+    \b
+    Examples:
+        unity-mcp audio stop "MusicPlayer"
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": "AudioSource",
+        "property": "Stop",
+        "value": True,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    result = run_command("manage_components", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@audio.command("volume")
+@click.argument("target")
+@click.argument("level", type=float)
+@click.option(
+    "--search-method",
+    type=SEARCH_METHOD_CHOICE_BASIC,
+    default=None,
+    help="How to find the target."
+)
+@handle_unity_errors
+def volume(target: str, level: float, search_method: Optional[str]):
+    """Set audio volume on a target's AudioSource.
+
+    \b
+    Examples:
+        unity-mcp audio volume "MusicPlayer" 0.5
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": "AudioSource",
+        "property": "volume",
+        "value": level,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    result = run_command("manage_components", params, config)
+    click.echo(format_output(result, config.format))

cli/commands/batch.py

@@ -0,0 +1,171 @@
+"""Batch CLI commands for executing multiple Unity operations efficiently."""
+
+import sys
+import json
+import click
+from typing import Optional, Any
+
+from cli.utils.config import get_config
+from cli.utils.output import format_output, print_error, print_success, print_info
+from cli.utils.connection import run_command, handle_unity_errors
+from cli.utils.parsers import parse_json_list_or_exit
+
+
+@click.group()
+def batch():
+    """Batch operations - execute multiple commands efficiently."""
+    pass
+
+
+@batch.command("run")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--parallel", is_flag=True, help="Execute read-only commands in parallel.")
+@click.option("--fail-fast", is_flag=True, help="Stop on first failure.")
+@handle_unity_errors
+def batch_run(file: str, parallel: bool, fail_fast: bool):
+    """Execute commands from a JSON file.
+
+    The JSON file should contain an array of command objects with 'tool' and 'params' keys.
+
+    \\b
+    File format:
+        [
+            {"tool": "manage_gameobject", "params": {"action": "create", "name": "Cube1"}},
+            {"tool": "manage_gameobject", "params": {"action": "create", "name": "Cube2"}},
+            {"tool": "manage_components", "params": {"action": "add", "target": "Cube1", "componentType": "Rigidbody"}}
+        ]
+
+    \\b
+    Examples:
+        unity-mcp batch run commands.json
+        unity-mcp batch run setup.json --parallel
+        unity-mcp batch run critical.json --fail-fast
+    """
+    config = get_config()
+
+    try:
+        with open(file, 'r') as f:
+            commands = json.load(f)
+    except json.JSONDecodeError as e:
+        print_error(f"Invalid JSON in file: {e}")
+        sys.exit(1)
+    except IOError as e:
+        print_error(f"Error reading file: {e}")
+        sys.exit(1)
+
+    if not isinstance(commands, list):
+        print_error("JSON file must contain an array of commands")
+        sys.exit(1)
+
+    if len(commands) > 25:
+        print_error(f"Maximum 25 commands per batch, got {len(commands)}")
+        sys.exit(1)
+
+    params: dict[str, Any] = {"commands": commands}
+    if parallel:
+        params["parallel"] = True
+    if fail_fast:
+        params["failFast"] = True
+
+    click.echo(f"Executing {len(commands)} commands...")
+
+    result = run_command("batch_execute", params, config)
+    click.echo(format_output(result, config.format))
+
+    if isinstance(result, dict):
+        results = result.get("data", {}).get("results", [])
+        succeeded = sum(1 for r in results if r.get("success"))
+        failed = len(results) - succeeded
+
+        if failed == 0:
+            print_success(
+                f"All {succeeded} commands completed successfully")
+        else:
+            print_info(f"{succeeded} succeeded, {failed} failed")
+
+
+@batch.command("inline")
+@click.argument("commands_json")
+@click.option("--parallel", is_flag=True, help="Execute read-only commands in parallel.")
+@click.option("--fail-fast", is_flag=True, help="Stop on first failure.")
+@handle_unity_errors
+def batch_inline(commands_json: str, parallel: bool, fail_fast: bool):
+    """Execute commands from inline JSON.
+
+    \\b
+    Examples:
+        unity-mcp batch inline '[{"tool": "manage_scene", "params": {"action": "get_active"}}]'
+
+        unity-mcp batch inline '[
+            {"tool": "manage_gameobject", "params": {"action": "create", "name": "A", "primitiveType": "Cube"}},
+            {"tool": "manage_gameobject", "params": {"action": "create", "name": "B", "primitiveType": "Sphere"}}
+        ]'
+    """
+    config = get_config()
+
+    commands = parse_json_list_or_exit(commands_json, "commands")
+
+    if len(commands) > 25:
+        print_error(f"Maximum 25 commands per batch, got {len(commands)}")
+        sys.exit(1)
+
+    params: dict[str, Any] = {"commands": commands}
+    if parallel:
+        params["parallel"] = True
+    if fail_fast:
+        params["failFast"] = True
+
+    result = run_command("batch_execute", params, config)
+    click.echo(format_output(result, config.format))
+
+
+@batch.command("template")
+@click.option("--output", "-o", type=click.Path(), help="Output file (default: stdout)")
+def batch_template(output: Optional[str]):
+    """Generate a sample batch commands file.
+
+    \\b
+    Examples:
+        unity-mcp batch template > commands.json
+        unity-mcp batch template -o my_batch.json
+    """
+    template = [
+        {
+            "tool": "manage_scene",
+            "params": {"action": "get_active"}
+        },
+        {
+            "tool": "manage_gameobject",
+            "params": {
+                "action": "create",
+                "name": "BatchCube",
+                "primitiveType": "Cube",
+                "position": [0, 1, 0]
+            }
+        },
+        {
+            "tool": "manage_components",
+            "params": {
+                "action": "add",
+                "target": "BatchCube",
+                "componentType": "Rigidbody"
+            }
+        },
+        {
+            "tool": "manage_gameobject",
+            "params": {
+                "action": "modify",
+                "target": "BatchCube",
+                "position": [0, 5, 0]
+            }
+        }
+    ]
+
+    json_output = json.dumps(template, indent=2)
+
+    if output:
+        with open(output, 'w') as f:
+            f.write(json_output)
+        print_success(f"Template written to: {output}")
+    else:
+        click.echo(json_output)