mcpforunityserver 8.7.0__py3-none-any.whl → 9.1.0__py3-none-any.whl

cli/commands/batch.py

@@ -0,0 +1,184 @@
+"""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, UnityConnectionError
+
+
+@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.")
+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...")
+
+    try:
+        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")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@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.")
+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()
+
+    try:
+        commands = json.loads(commands_json)
+    except json.JSONDecodeError as e:
+        print_error(f"Invalid JSON: {e}")
+        sys.exit(1)
+
+    if not isinstance(commands, list):
+        print_error("Commands must be an array")
+        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
+
+    try:
+        result = run_command("batch_execute", params, config)
+        click.echo(format_output(result, config.format))
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@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)

cli/commands/code.py

@@ -0,0 +1,189 @@
+"""Code CLI commands - read source code. search might be implemented later (but can be totally achievable with AI)."""
+
+import sys
+import os
+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, UnityConnectionError
+
+
+@click.group()
+def code():
+    """Code operations - read source files."""
+    pass
+
+
+@code.command("read")
+@click.argument("path")
+@click.option(
+    "--start-line", "-s",
+    default=None,
+    type=int,
+    help="Starting line number (1-based)."
+)
+@click.option(
+    "--line-count", "-n",
+    default=None,
+    type=int,
+    help="Number of lines to read."
+)
+def read(path: str, start_line: Optional[int], line_count: Optional[int]):
+    """Read a source file.
+
+    \b
+    Examples:
+        unity-mcp code read "Assets/Scripts/Player.cs"
+        unity-mcp code read "Assets/Scripts/Player.cs" --start-line 10 --line-count 20
+    """
+    config = get_config()
+
+    # Extract name and directory from path
+    parts = path.replace("\\", "/").split("/")
+    filename = os.path.splitext(parts[-1])[0]
+    directory = "/".join(parts[:-1]) or "Assets"
+
+    params: dict[str, Any] = {
+        "action": "read",
+        "name": filename,
+        "path": directory,
+    }
+
+    if start_line:
+        params["startLine"] = start_line
+    if line_count:
+        params["lineCount"] = line_count
+
+    try:
+        result = run_command("manage_script", params, config)
+        # For read, output content directly if available
+        if result.get("success") and result.get("data"):
+            data = result.get("data", {})
+            if isinstance(data, dict) and "contents" in data:
+                click.echo(data["contents"])
+            else:
+                click.echo(format_output(result, config.format))
+        else:
+            click.echo(format_output(result, config.format))
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@code.command("search")
+@click.argument("pattern")
+@click.argument("path")
+@click.option(
+    "--max-results", "-n",
+    default=50,
+    type=int,
+    help="Maximum number of results (default: 50)."
+)
+@click.option(
+    "--case-sensitive", "-c",
+    is_flag=True,
+    help="Make search case-sensitive (default: case-insensitive)."
+)
+def search(pattern: str, path: str, max_results: int, case_sensitive: bool):
+    """Search for patterns in Unity scripts using regex.
+
+    PATTERN is a regex pattern to search for.
+    PATH is the script path (e.g., Assets/Scripts/Player.cs).
+
+    \\b
+    Examples:
+        unity-mcp code search "class.*Player" "Assets/Scripts/Player.cs"
+        unity-mcp code search "private.*int" "Assets/Scripts/GameManager.cs"
+        unity-mcp code search "TODO|FIXME" "Assets/Scripts/Utils.cs"
+    """
+    import re
+    import base64
+
+    config = get_config()
+
+    # Extract name and directory from path
+    parts = path.replace("\\", "/").split("/")
+    filename = os.path.splitext(parts[-1])[0]
+    directory = "/".join(parts[:-1]) or "Assets"
+
+    # Step 1: Read the file via Unity's manage_script
+    read_params: dict[str, Any] = {
+        "action": "read",
+        "name": filename,
+        "path": directory,
+    }
+
+    try:
+        result = run_command("manage_script", read_params, config)
+
+        # Handle nested response structure: {status, result: {success, data}}
+        inner_result = result.get("result", result)
+
+        if not inner_result.get("success") and result.get("status") != "success":
+            click.echo(format_output(result, config.format))
+            return
+
+        # Get file contents from nested data
+        data = inner_result.get("data", {})
+        contents = data.get("contents")
+
+        # Handle base64 encoded content
+        if not contents and data.get("contentsEncoded") and data.get("encodedContents"):
+            try:
+                contents = base64.b64decode(
+                    data["encodedContents"]).decode("utf-8", "replace")
+            except (ValueError, TypeError):
+                pass
+
+        if not contents:
+            print_error(f"Could not read file content from {path}")
+            sys.exit(1)
+
+        # Step 2: Perform regex search locally
+        flags = re.MULTILINE
+        if not case_sensitive:
+            flags |= re.IGNORECASE
+
+        try:
+            regex = re.compile(pattern, flags)
+        except re.error as e:
+            print_error(f"Invalid regex pattern: {e}")
+            sys.exit(1)
+
+        found = list(regex.finditer(contents))
+
+        if not found:
+            print_info(f"No matches found for pattern: {pattern}")
+            return
+
+        results = []
+        for m in found[:max_results]:
+            start_idx = m.start()
+
+            # Calculate line number
+            line_num = contents.count('\n', 0, start_idx) + 1
+
+            # Get line content
+            line_start = contents.rfind('\n', 0, start_idx) + 1
+            line_end = contents.find('\n', start_idx)
+            if line_end == -1:
+                line_end = len(contents)
+
+            line_content = contents[line_start:line_end].strip()
+
+            results.append({
+                "line": line_num,
+                "content": line_content,
+                "match": m.group(0),
+            })
+
+        # Display results
+        click.echo(f"Found {len(results)} matches (total: {len(found)}):\n")
+        for match in results:
+            click.echo(f"  Line {match['line']}: {match['content']}")
+
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)

cli/commands/component.py

@@ -0,0 +1,212 @@
+"""Component 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, UnityConnectionError
+
+
+@click.group()
+def component():
+    """Component operations - add, remove, modify components on GameObjects."""
+    pass
+
+
+@component.command("add")
+@click.argument("target")
+@click.argument("component_type")
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_id", "by_name", "by_path"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+@click.option(
+    "--properties", "-p",
+    default=None,
+    help='Initial properties as JSON (e.g., \'{"mass": 5.0}\').'
+)
+def add(target: str, component_type: str, search_method: Optional[str], properties: Optional[str]):
+    """Add a component to a GameObject.
+
+    \b
+    Examples:
+        unity-mcp component add "Player" Rigidbody
+        unity-mcp component add "-81840" BoxCollider --search-method by_id
+        unity-mcp component add "Enemy" Rigidbody --properties '{"mass": 5.0, "useGravity": true}'
+    """
+    config = get_config()
+
+    params: dict[str, Any] = {
+        "action": "add",
+        "target": target,
+        "componentType": component_type,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+    if properties:
+        try:
+            params["properties"] = json.loads(properties)
+        except json.JSONDecodeError as e:
+            print_error(f"Invalid JSON for properties: {e}")
+            sys.exit(1)
+
+    try:
+        result = run_command("manage_components", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Added {component_type} to '{target}'")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@component.command("remove")
+@click.argument("target")
+@click.argument("component_type")
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_id", "by_name", "by_path"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+@click.option(
+    "--force", "-f",
+    is_flag=True,
+    help="Skip confirmation prompt."
+)
+def remove(target: str, component_type: str, search_method: Optional[str], force: bool):
+    """Remove a component from a GameObject.
+
+    \b
+    Examples:
+        unity-mcp component remove "Player" Rigidbody
+        unity-mcp component remove "-81840" BoxCollider --search-method by_id --force
+    """
+    config = get_config()
+
+    if not force:
+        click.confirm(f"Remove {component_type} from '{target}'?", abort=True)
+
+    params: dict[str, Any] = {
+        "action": "remove",
+        "target": target,
+        "componentType": component_type,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    try:
+        result = run_command("manage_components", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Removed {component_type} from '{target}'")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@component.command("set")
+@click.argument("target")
+@click.argument("component_type")
+@click.argument("property_name")
+@click.argument("value")
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_id", "by_name", "by_path"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+def set_property(target: str, component_type: str, property_name: str, value: str, search_method: Optional[str]):
+    """Set a single property on a component.
+
+    \b
+    Examples:
+        unity-mcp component set "Player" Rigidbody mass 5.0
+        unity-mcp component set "Enemy" Transform position "[0, 5, 0]"
+        unity-mcp component set "-81840" Light intensity 2.5 --search-method by_id
+    """
+    config = get_config()
+
+    # Try to parse value as JSON for complex types
+    try:
+        parsed_value = json.loads(value)
+    except json.JSONDecodeError:
+        # Keep as string if not valid JSON
+        parsed_value = value
+
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": component_type,
+        "property": property_name,
+        "value": parsed_value,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    try:
+        result = run_command("manage_components", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Set {component_type}.{property_name} = {value}")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@component.command("modify")
+@click.argument("target")
+@click.argument("component_type")
+@click.option(
+    "--properties", "-p",
+    required=True,
+    help='Properties to set as JSON (e.g., \'{"mass": 5.0, "useGravity": false}\').'
+)
+@click.option(
+    "--search-method",
+    type=click.Choice(["by_id", "by_name", "by_path"]),
+    default=None,
+    help="How to find the target GameObject."
+)
+def modify(target: str, component_type: str, properties: str, search_method: Optional[str]):
+    """Set multiple properties on a component at once.
+
+    \b
+    Examples:
+        unity-mcp component modify "Player" Rigidbody --properties '{"mass": 5.0, "useGravity": false}'
+        unity-mcp component modify "Light" Light --properties '{"intensity": 2.0, "color": [1, 0, 0, 1]}'
+    """
+    config = get_config()
+
+    try:
+        props_dict = json.loads(properties)
+    except json.JSONDecodeError as e:
+        print_error(f"Invalid JSON for properties: {e}")
+        sys.exit(1)
+
+    params: dict[str, Any] = {
+        "action": "set_property",
+        "target": target,
+        "componentType": component_type,
+        "properties": props_dict,
+    }
+
+    if search_method:
+        params["searchMethod"] = search_method
+
+    try:
+        result = run_command("manage_components", params, config)
+        click.echo(format_output(result, config.format))
+        if result.get("success"):
+            print_success(f"Modified {component_type} on '{target}'")
+    except UnityConnectionError as e:
+        print_error(str(e))
+        sys.exit(1)