### Install GodotIQ

Source: https://godotiq.com

Use uvx for automatic installation via MCP clients or pip for manual and CI environments.

```bash
# MCP clients (recommended)
uvx godotiq

# Manual / CI
pip install godotiq
```

--------------------------------

### Example AI Prompts

Source: https://godotiq.com

Common queries to interact with the GodotIQ MCP server.

```text
"Analyze my project"
"Where should I put this printer?"
"What breaks if I change this signal?"
```

--------------------------------

### Control Game Execution

Source: https://godotiq.com

Starts or stops the game instance. Play must be called before using game-side tools.

```text
> godotiq_run --action play --scene main
  ✓ Game started (scene: main.tscn)
```

--------------------------------

### Get File Context

Source: https://godotiq.com

Provides deep context for a file, including dependencies and usage, before editing.

```bash
> godotiq_file_context Player.gd
  12 deps, 4 signals, used in 3 scenes, 8 importers
```

--------------------------------

### Monitor Property Changes

Source: https://godotiq.com

Starts persistent monitoring of specific node properties.

```text
> godotiq_watch --action start --watches [{node: "Player", properties: ["position"]}]
  ✓ Watching Player.position (500ms interval)
```

--------------------------------

### Summarize Project

Source: https://godotiq.com

Provides a high-level overview of project architecture, including autoloads and file counts.

```bash
> godotiq_project_summary
  48 scripts, 23 scenes, 5 autoloads, 156 signals mapped
```

--------------------------------

### Query Navigation

Source: https://godotiq.com

Performs live pathfinding queries via NavigationServer3D.

```bash
> godotiq_nav_query --from_node Player --to_node Exit
  ✓ Reachable, distance: 28.4m, 12 waypoints
```

--------------------------------

### Suggest Model Scale

Source: https://godotiq.com

Recommends scale and position for models based on similar assets in the scene.

```bash
> godotiq_suggest_scale printer.glb --scene main.tscn
  Recommended: scale (1,1,1), position (4,0,2) based on 3 similar
```

--------------------------------

### Configure MCP Client

Source: https://godotiq.com

Add the GodotIQ server configuration to your MCP-compatible client, ensuring the project root path is set correctly.

```json
{
  "mcpServers": {
    "godotiq": {
      "command": "uvx",
      "args": ["godotiq"],
      "env": {
        "GODOTIQ_PROJECT_ROOT": "/path/to/your/godot/project"
      }
    }
  }
}
```

--------------------------------

### Build Scene Nodes

Source: https://godotiq.com

Creates multiple nodes in a scene using patterns like grids or lines.

```text
> godotiq_build_scene --grid {rows: 3, cols: 4, scene: "res://shelf.tscn"}
  ✓ 12 nodes created in grid pattern
```

--------------------------------

### Registry Assets

Source: https://godotiq.com

Inventories project assets to find unused files or missing references.

```bash
> godotiq_asset_registry
  124 assets: 48 textures, 32 audio, 3 unused, 1 missing ref
```

--------------------------------

### Map UI Elements

Source: https://godotiq.com

Maps UI elements on screen to understand layout and interactivity.

```bash
> godotiq_ui_map
  HUD → HealthBar (10,10) → Label "HP: 100" → Button "Shop"
```

--------------------------------

### Analyze Dependency Graph

Source: https://godotiq.com

Maps signals, imports, and reverse dependencies to assess refactoring impact.

```bash
> godotiq_dependency_graph Player.gd
  Player.gd → Health.gd → UI/HUD.tscn (impact: high)
```

--------------------------------

### godotiq_placement

Source: https://godotiq.com

Finds safe placement positions for new objects within a scene.

```APIDOC
## godotiq_placement

### Description
Finds safe placement positions for new objects. Checks Marker3D slots first, then performs grid-searches with wall/overlap validation.

### Parameters
#### Query Parameters
- **near** (string) - Required - The reference object name to place near.
- **object_type** (string) - Required - The type of object being placed.
```

--------------------------------

### Snapshot Performance Metrics

Source: https://godotiq.com

Retrieves performance data including FPS, draw calls, and memory usage.

```text
> godotiq_perf_snapshot
  60 FPS, 142 draw calls, 12.4MB texture memory
```

--------------------------------

### Retrieve Editor Context

Source: https://godotiq.com

Returns the current editor state including open scenes, selected nodes, and project status.

```text
> godotiq_editor_context
  Scene: main.tscn, 3 selected, game: stopped
```

--------------------------------

### Find Object Placement

Source: https://godotiq.com

Identifies safe positions for new objects using Marker3D slots or grid-searching.

```bash
> godotiq_placement --near Printer --object_type shelf
  Suggestion 1: (4.2, 0, -1.8) confidence: 0.95 ✓ marker slot
```

--------------------------------

### Validate Project Conventions

Source: https://godotiq.com

Checks for missing type hints, class names, and naming violations.

```bash
> godotiq_validate
  ✓ 42 rules passed, ⚠ 2 warnings (missing type hints)
```

--------------------------------

### Explore Scene Visually

Source: https://godotiq.com

Performs autonomous visual inspection of a scene using a drone camera.

```bash
> godotiq_explore main.tscn --mode tour
  4 areas found, 127 nodes, 8 screenshots captured
```

--------------------------------

### Map Project Signals

Source: https://godotiq.com

Visualizes signal wiring across the project to identify orphan or missing signals.

```bash
> godotiq_signal_map
  health_changed: Player.gd emits → HUD.gd, GameManager.gd
```

--------------------------------

### Simulate Player Input

Source: https://godotiq.com

Simulates inputs like actions, keys, or UI taps in the running game.

```text
> godotiq_input [{actions: ["move_left"], hold_ms: 500}, {wait_ms: 200}]
  ✓ 2 commands executed, 0 errors
```

--------------------------------

### Inspect Runtime State

Source: https://godotiq.com

Queries runtime property values for nodes or autoloads.

```text
> godotiq_state_inspect [{autoload: "EconomyManager", properties: ["balance"]}]
  EconomyManager.balance = 1500
```

--------------------------------

### Perform Filesystem Operations

Source: https://godotiq.com

Handles file management tasks like listing, reading, and moving files while respecting protected paths.

```text
> godotiq_file_ops --op list --path res://scenes
  5 files: main.tscn, level1.tscn, menu.tscn...
```

--------------------------------

### Retrieve Animation Info

Source: https://godotiq.com

Extracts metadata for animation nodes including tracks, keyframes, and state transitions.

```bash
> godotiq_animation_info Player.tscn
  3 animations, 24 keyframes, idle: 1.2s loop, run: 0.8s loop
```

--------------------------------

### Read Live Scene Tree

Source: https://godotiq.com

Reads the live state of the editor scene tree, including transforms and scripts.

```text
> godotiq_scene_tree --depth 3
  Main → World → Player (pos: 3,1,0) → Camera3D
```

--------------------------------

### godotiq_dependency_graph

Source: https://godotiq.com

Generates a complete dependency graph for a script or scene.

```APIDOC
## godotiq_dependency_graph

### Description
Analyzes signals, listeners, imports, and reverse dependencies to provide an impact rating for refactoring.

### Parameters
#### Path Parameters
- **file** (string) - Required - The script or scene file to analyze.
```

--------------------------------

### Execute GDScript Code

Source: https://godotiq.com

Runs arbitrary GDScript code. The provided code must contain a 'func run():' definition.

```text
> godotiq_exec "func run():
  return Engine.get_version_info()"
  {major: 4, minor: 3}
```

--------------------------------

### Bridge Tools

Source: https://godotiq.com

Tools for interacting with the Godot editor's live state and performing core editing operations.

```APIDOC
## GET godotiq_editor_context

### Description
Returns the current state of the Godot editor, including open scenes, selected nodes, and whether the game is running.

### Method
GET

### Endpoint
/godotiq_editor_context

### Response
#### Success Response (200)
- **scene** (string) - The name of the currently open scene.
- **selected_nodes** (integer) - The number of nodes currently selected.
- **game_running** (boolean) - Indicates if the game is currently running.
- **project_path** (string) - The path to the Godot project.

### Response Example
```json
{
  "scene": "main.tscn",
  "selected_nodes": 3,
  "game_running": false,
  "project_path": "/path/to/project"
}
```
```

```APIDOC
## GET godotiq_scene_tree

### Description
Retrieves the live scene tree of the editor, including node transforms, scripts, groups, and visibility. This reads the editor's live state, unlike `scene_map`.

### Method
GET

### Endpoint
/godotiq_scene_tree

### Query Parameters
- **depth** (integer) - Optional - The maximum depth to traverse the scene tree.

### Response
#### Success Response (200)
- **tree** (object) - A nested object representing the scene tree.

### Response Example
```json
{
  "tree": {
    "name": "Main",
    "children": [
      {
        "name": "World",
        "children": [
          {
            "name": "Player",
            "transform": {"position": [3,1,0]},
            "children": [
              {
                "name": "Camera3D"
              }
            ]
          }
        ]
      }
    ]
  }
}
```
```

```APIDOC
## POST godotiq_node_ops

### Description
Performs batch operations on nodes in the scene tree with undo/redo support. Operations include move, rotate, scale, set property, add child, delete, duplicate, reparent, rename, and get property.

### Method
POST

### Endpoint
/godotiq_node_ops

### Request Body
- **operations** (array) - Required - A list of operations to perform.
  - **op** (string) - Required - The type of operation (e.g., "move", "scale").
  - **node** (string) - Required - The name of the node to operate on.
  - **position** (array) - Optional - The new position for "move" operation [x, y, z].
  - **scale** (array) - Optional - The new scale for "scale" operation [x, y, z].
  - **property** (string) - Optional - The property name for "set_property" or "get_property".
  - **value** (any) - Optional - The new value for "set_property".
  - **parent** (string) - Optional - The new parent node for "reparent".

### Request Example
```json
{
  "operations": [
    {"op": "move", "node": "Shelf", "position": [2,0,3]},
    {"op": "scale", "node": "Player", "scale": [1.1, 1.1, 1.1]}
  ]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure.
- **message** (string) - A message describing the result of the operations.

#### Response Example
```json
{
  "status": "success",
  "message": "✓ Shelf moved to (2, 0, 3), Player scaled. — Ctrl+Z to undo"
}
```
```

```APIDOC
## POST godotiq_build_scene

### Description
Creates multiple nodes in the scene using predefined patterns like grid, line, scatter, or an explicit list. All created nodes are grouped under a single undo action.

### Method
POST

### Endpoint
/godotiq_build_scene

### Query Parameters
- **mode** (string) - Required - The pattern to use for building the scene (e.g., "grid", "line", "scatter", "explicit").

### Request Body
- **grid** (object) - Parameters for grid mode.
  - **rows** (integer) - Required - Number of rows.
  - **cols** (integer) - Required - Number of columns.
  - **scene** (string) - Required - Path to the scene to instance.
- **line** (object) - Parameters for line mode.
  - **count** (integer) - Required - Number of nodes.
  - **scene** (string) - Required - Path to the scene to instance.
- **scatter** (object) - Parameters for scatter mode.
  - **count** (integer) - Required - Number of nodes.
  - **scene** (string) - Required - Path to the scene to instance.
- **explicit** (array) - Parameters for explicit mode.
  - **nodes** (array) - Required - List of node configurations.
    - **scene** (string) - Required - Path to the scene to instance.
    - **position** (array) - Optional - Position [x, y, z].

### Request Example
```json
{
  "mode": "grid",
  "grid": {
    "rows": 3,
    "cols": 4,
    "scene": "res://shelf.tscn"
  }
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure.
- **message** (string) - A message describing the result of the operation.

#### Response Example
```json
{
  "status": "success",
  "message": "✓ 12 nodes created in grid pattern"
}
```
```

```APIDOC
## POST godotiq_save_scene

### Description
Saves the current state of the editor scene to disk. This should be called after making modifications using other node operations.

### Method
POST

### Endpoint
/godotiq_save_scene

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure.
- **message** (string) - A message confirming the save operation.

### Response Example
```json
{
  "status": "success",
  "message": "✓ Saved main.tscn"
}
```
```

```APIDOC
## POST godotiq_script_ops

### Description
Performs operations on GDScript files, including reading, writing, and patching. Supports convention validation and a safe patch mode for find-and-replace operations.

### Method
POST

### Endpoint
/godotiq_script_ops

### Query Parameters
- **op** (string) - Required - The operation to perform ("read", "write", "patch").
- **path** (string) - Required - The path to the GDScript file.

### Request Body
- **content** (string) - Optional - The new content for "write" or "patch" operations.
- **patch_rules** (array) - Optional - A list of find-and-replace rules for "patch" operations.
  - **find** (string) - Required - The text to find.
  - **replace** (string) - Required - The text to replace with.

### Request Example
```json
{
  "op": "read",
  "path": "Player.gd"
}
```

### Response
#### Success Response (200)
- **content** (string) - The content of the script file for "read" operations.
- **lines** (integer) - The number of lines in the script.
- **message** (string) - A status message for "write" or "patch" operations.

#### Response Example
```json
{
  "content": "class_name Player extends CharacterBody3D\n\nfunc _ready():\n    pass\n",
  "lines": 42
}
```
```

```APIDOC
## POST godotiq_file_ops

### Description
Provides filesystem operations such as listing, reading, writing, moving, deleting, searching, and renaming files. It also handles UID to path conversions and respects protected files defined in `.godotiq.json`.

### Method
POST

### Endpoint
/godotiq_file_ops

### Query Parameters
- **op** (string) - Required - The file operation to perform (e.g., "list", "read", "write", "move", "delete", "search", "tree", "uid_to_path", "path_to_uid", "rename").
- **path** (string) - Optional - The path for the operation.
- **dest_path** (string) - Optional - The destination path for "move" or "rename" operations.
- **search_term** (string) - Optional - The term to search for.
- **uid** (string) - Optional - The unique ID for path conversion.

### Request Body
- **content** (string) - Optional - The content to write for "write" operations.
- **new_name** (string) - Optional - The new name for "rename" operations.

### Request Example
```json
{
  "op": "list",
  "path": "res://scenes"
}
```

### Response
#### Success Response (200)
- **files** (array) - A list of file names for "list" or "search" operations.
- **content** (string) - The content of the file for "read" operations.
- **message** (string) - A status message for other operations.
- **path** (string) - The converted path for UID operations.

#### Response Example
```json
{
  "files": ["main.tscn", "level1.tscn", "menu.tscn"],
  "count": 5
}
```
```

```APIDOC
## POST godotiq_exec

### Description
Executes GDScript code within the Godot environment. The provided code must contain a `func run():` function. This should be used as a last resort, preferring dedicated tools when available.

### Method
POST

### Endpoint
/godotiq_exec

### Request Body
- **code** (string) - Required - The GDScript code to execute, must include `func run():`.

### Request Example
```json
{
  "code": "func run():\n  return Engine.get_version_info()"
}
```

### Response
#### Success Response (200)
- **result** (any) - The return value of the `run()` function.

#### Response Example
```json
{
  "result": {"major": 4, "minor": 3}
}
```
```

```APIDOC
## POST godotiq_run

### Description
Starts or stops the Godot game execution. The game must be started using this command before utilizing game-side tools.

### Method
POST

### Endpoint
/godotiq_run

### Query Parameters
- **action** (string) - Required - The action to perform ("play" or "stop").
- **scene** (string) - Optional - The name of the scene to play (without extension).

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure.
- **message** (string) - A message confirming the action.

### Response Example
```json
{
  "status": "success",
  "message": "✓ Game started (scene: main.tscn)"
}
```
```

```APIDOC
## POST godotiq_input

### Description
Simulates player input within the running Godot game. Supports input actions, key presses, UI taps, and timed waits. Can also verify signals and track side effects.

### Method
POST

### Endpoint
/godotiq_input

### Request Body
- **commands** (array) - Required - A list of input commands to execute.
  - **actions** (array) - Optional - List of input action names to trigger.
  - **hold_ms** (integer) - Optional - Duration in milliseconds to hold the input.
  - **wait_ms** (integer) - Optional - Duration in milliseconds to wait.
  - **keys** (array) - Optional - List of key names to press.
  - **tap** (object) - Optional - UI tap coordinates {x, y}.

### Request Example
```json
[
  {"actions": ["move_left"], "hold_ms": 500},
  {"wait_ms": 200}
]
```

### Response
#### Success Response (200)
- **executed_commands** (integer) - The number of commands successfully executed.
- **errors** (integer) - The number of errors encountered.
- **message** (string) - A summary message.

#### Response Example
```json
{
  "executed_commands": 2,
  "errors": 0,
  "message": "✓ 2 commands executed, 0 errors"
}
```
```

```APIDOC
## POST godotiq_screenshot

### Description
Captures a screenshot of the Godot game or editor viewport for visual verification. Parameters like scale and quality can be adjusted for efficiency.

### Method
POST

### Endpoint
/godotiq_screenshot

### Query Parameters
- **viewport** (string) - Optional - The viewport to capture ("game" or "editor"). Defaults to "game".
- **scale** (float) - Optional - The scaling factor for the screenshot (e.g., 0.25 for lower resolution).
- **quality** (float) - Optional - The quality setting for the image (0.0 to 1.0).

### Response
#### Success Response (200)
- **image_data** (string) - Base64 encoded image data.
- **format** (string) - The image format (e.g., "webp").
- **dimensions** (string) - The resolution of the captured image (e.g., "480x270").
- **size_kb** (integer) - The size of the image in kilobytes.

### Response Example
```json
{
  "image_data": "/9j/4AAQSkZJRg...",
  "format": "webp",
  "dimensions": "480x270",
  "size_kb": 12
}
```
```

```APIDOC
## GET godotiq_camera

### Description
Controls the 3D camera within the Godot editor. Allows retrieving the current camera position, repositioning it, or focusing it on a specific node. This operates on the editor camera, not the game camera.

### Method
GET

### Endpoint
/godotiq_camera

### Query Parameters
- **action** (string) - Required - The camera action to perform ("get_position", "focus_node", "set_position").
- **node** (string) - Optional - The name of the node to focus on for the "focus_node" action.
- **position** (array) - Optional - The target position [x, y, z] for the "set_position" action.

### Response
#### Success Response (200)
- **message** (string) - A confirmation message including the camera's state or action result.

### Response Example
```json
{
  "message": "Camera focused on Player at (3, 1, 0)"
}
```
```

```APIDOC
## POST godotiq_state_inspect

### Description
Queries runtime property values from the running Godot game. This is more efficient than screenshots for checking specific states. It supports accessing properties via autoloads, node paths, nested properties, and method calls.

### Method
POST

### Endpoint
/godotiq_state_inspect

### Request Body
- **queries** (array) - Required - A list of queries to execute.
  - **autoload** (string) - Optional - The name of an autoload singleton to query.
  - **node_path** (string) - Optional - The path to a node in the scene tree.
  - **properties** (array) - Required - A list of property names or method calls to inspect.
    - **name** (string) - The property name or method name.
    - **args** (array) - Optional - Arguments for method calls.

### Request Example
```json
[
  {"autoload": "EconomyManager", "properties": [{"name": "balance"}]},
  {"node_path": "Player/Health", "properties": [{"name": "current_hp"}]}
]
```

### Response
#### Success Response (200)
- **results** (array) - The results of the inspection queries.
  - **query** (object) - The original query object.
  - **value** (any) - The retrieved value.

#### Response Example
```json
{
  "results": [
    {"query": {"autoload": "EconomyManager", "properties": [{"name": "balance"}]}, "value": 1500},
    {"query": {"node_path": "Player/Health", "properties": [{"name": "current_hp"}]}, "value": 100}
  ]
}
```
```

```APIDOC
## GET godotiq_perf_snapshot

### Description
Collects performance metrics from the running Godot game, including Frames Per Second (FPS), draw calls, and memory usage.

### Method
GET

### Endpoint
/godotiq_perf_snapshot

### Response
#### Success Response (200)
- **fps** (integer) - Frames Per Second.
- **draw_calls** (integer) - Number of draw calls.
- **texture_memory_mb** (float) - Texture memory usage in megabytes.
- **node_count** (integer) - Total number of nodes in the scene.

### Response Example
```json
{
  "fps": 60,
  "draw_calls": 142,
  "texture_memory_mb": 12.4,
  "node_count": 500
}
```
```

```APIDOC
## POST godotiq_watch

### Description
Starts or stops monitoring specific properties of nodes in the running game. It records changes over time, allowing for analysis of property evolution.

### Method
POST

### Endpoint
/godotiq_watch

### Query Parameters
- **action** (string) - Required - The action to perform ("start", "stop", "get_changes").

### Request Body
- **watches** (array) - Required for "start" action - A list of properties to watch.
  - **node** (string) - Required - The name or path of the node.
  - **properties** (array) - Required - A list of property names to watch.
- **interval_ms** (integer) - Optional - The interval in milliseconds between checks (defaults to 500ms).

### Request Example
```json
{
  "action": "start",
  "watches": [
    {"node": "Player", "properties": ["position", "velocity"]}
  ],
  "interval_ms": 1000
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message.
- **changes** (array) - List of recorded property changes for "get_changes" action.

#### Response Example
```json
{
  "message": "✓ Watching Player.position and Player.velocity (1000ms interval)"
}
```
```

```APIDOC
## GET godotiq_undo_history

### Description
Retrieves information about the undo/redo history in the Godot editor, including the last action performed and whether undo/redo operations are currently possible.

### Method
GET

### Endpoint
/godotiq_undo_history

### Response
#### Success Response (200)
- **last_action** (string) - The description of the last action performed.
- **can_undo** (boolean) - Indicates if the last action can be undone.
- **can_redo** (boolean) - Indicates if an undone action can be redone.

### Response Example
```json
{
  "last_action": "Move Shelf",
  "can_undo": true,
  "can_redo": false
}
```
```

```APIDOC
## POST godotiq_check_errors

### Description
Checks GDScript files for compilation and parse errors. You can specify the scope of the check (e.g., "scene", "project").

### Method
POST

### Endpoint
/godotiq_check_errors

### Query Parameters
- **scope** (string) - Required - The scope to check for errors (e.g., "scene", "project", "all").

### Response
#### Success Response (200)
- **errors_found** (integer) - The total number of errors found.
- **message** (string) - A summary message.

### Response Example
```json
{
  "errors_found": 0,
  "message": "✓ 0 errors in 12 scripts checked"
}
```
```

```APIDOC
## POST godotiq_verify_motion

### Description
Verifies if a node's property has changed over a specified duration, indicating movement or animation. It takes two snapshots and compares the property values.

### Method
POST

### Endpoint
/godotiq_verify_motion

### Request Body
- **node** (string) - Required - The name or path of the node to verify.
- **property** (string) - Required - The property to monitor for changes (e.g., "position").
- **duration** (float) - Required - The duration in seconds to observe the property.

### Request Example
```json
{
  "node": "Player",
  "property": "position",
  "duration": 2.0
}
```

### Response
#### Success Response (200)
- **verdict** (string) - The result of the verification ("MOVING", "STATIONARY", "ERROR").
- **message** (string) - A detailed message about the verification result.
- **initial_value** (any) - The value of the property at the start.
- **final_value** (any) - The value of the property at the end.

#### Response Example
```json
{
  "verdict": "MOVING",
  "message": "Verdict: MOVING — position changed (0,1,0) → (3,1,2)",
  "initial_value": [0,1,0],
  "final_value": [3,1,2]
}
```
```

--------------------------------

### Capture Viewport Screenshot

Source: https://godotiq.com

Captures a visual verification of the game or editor viewport.

```text
> godotiq_screenshot --viewport editor --scale 0.25
  Captured 480×270 webp (12KB)
```

--------------------------------

### Trace Execution Flow

Source: https://godotiq.com

Traces the call chain from a specific function or signal through the codebase.

```bash
> godotiq_trace_flow start_print_job --depth 10
  PrintManager._ready → queue_job → Worker.execute → done signal
```

--------------------------------

### Review Undo History

Source: https://godotiq.com

Displays the recent history of GodotIQ actions and undo/redo state.

```text
> godotiq_undo_history
  Last: "Move Shelf" — can undo: true, can redo: false
```

--------------------------------

### Save Scene Changes

Source: https://godotiq.com

Persists current editor modifications to the disk.

```text
> godotiq_save_scene
  ✓ Saved main.tscn
```

--------------------------------

### Verify Node Motion

Source: https://godotiq.com

Confirms if a node property changes over a specified duration.

```text
> godotiq_verify_motion --node Player --duration 2.0
  Verdict: MOVING — position changed (0,1,0) → (3,1,2)
```

--------------------------------

### Manage GDScript Files

Source: https://godotiq.com

Reads, writes, or patches GDScript files with validation.

```text
> godotiq_script_ops --op read --path Player.gd
  class_name Player extends CharacterBody3D (42 lines)
```

--------------------------------

### Ping Server

Source: https://godotiq.com

Checks the health status and version of the GodotIQ server.

```bash
> godotiq_ping
  ✓ GodotIQ v0.4.0, server healthy, 36 tools loaded
```

--------------------------------

### Spatial Tools

Source: https://godotiq.com

Tools for analyzing and understanding the spatial relationships within Godot scenes.

```APIDOC
## GET godotiq_scene_map

### Description
Analyzes a `.tscn` scene file to understand spatial relationships, including positions, distances, and directions between nodes. Useful for planning object placement.

### Method
GET

### Endpoint
/godotiq_scene_map

### Query Parameters
- **scene_file** (string) - Required - The path to the `.tscn` scene file.
- **focus** (string) - Optional - The name of the node to use as the reference point.
- **radius** (float) - Optional - The radius around the focus node to consider.

### Response
#### Success Response (200)
- **analysis** (string) - A textual description of the spatial relationships found.

### Response Example
```json
{
  "analysis": "Player (0,1,0) → Shelf (2,0,3) 3.2m east → Door (5,0,0) 5.1m east"
}
```
```

--------------------------------

### Audit Animations

Source: https://godotiq.com

Identifies issues like broken tracks or missing transitions.

```bash
> godotiq_animation_audit
  ⚠ 1 broken track, 1 missing transition idle→jump
```

--------------------------------

### Control Editor Camera

Source: https://godotiq.com

Manages the editor 3D camera position and focus.

```text
> godotiq_camera --action focus_node --node Player
  Camera focused on Player at (3, 1, 0)
```

--------------------------------

### Audit 3D Scenes

Source: https://godotiq.com

Checks for common spatial issues like floating objects and scale mismatches.

```bash
> godotiq_spatial_audit main.tscn
  ⚠ 2 floating objects, 1 scale mismatch, 0 z-fighting
```

--------------------------------

### godotiq_ping

Source: https://godotiq.com

Health check tool for the GodotIQ server.

```APIDOC
## godotiq_ping

### Description
Returns the server status, version, and the number of tools currently loaded.
```

--------------------------------

### Perform Batch Node Operations

Source: https://godotiq.com

Executes multiple scene editing operations as a single undoable action.

```text
> godotiq_node_ops [{op: "move", node: "Shelf", position: [2,0,3]}]
  ✓ Shelf moved to (2, 0, 3) — Ctrl+Z to undo
```

--------------------------------

### Check Script Errors

Source: https://godotiq.com

Validates GDScript files for compilation or parsing errors.

```text
> godotiq_check_errors --scope scene
  ✓ 0 errors in 12 scripts checked
```

--------------------------------

### godotiq_spatial_audit

Source: https://godotiq.com

Performs an automated 3D scene linter to detect common spatial issues.

```APIDOC
## godotiq_spatial_audit

### Description
Automated 3D scene linter that detects floating objects, scale mismatches, z-fighting, overlapping instances, and extreme positions.

### Parameters
#### Path Parameters
- **scene_file** (string) - Required - The path to the .tscn file to audit.
```

--------------------------------

### Check Change Impact

Source: https://godotiq.com

Predicts potential breakage by identifying affected files and callers before applying changes.

```bash
> godotiq_impact_check Player.gd
  7 files affected, 3 signals, risk: high
```

--------------------------------

### Map Scene Spatial Data

Source: https://godotiq.com

Provides spatial understanding of a scene, including positions and distances.

```text
> godotiq_scene_map main.tscn --focus Player --radius 10
  Player (0,1,0) → Shelf (2,0,3) 3.2m east → Door (5,0,0) 5.1m east
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.