god-code 0.5.5__tar.gz → 0.6.1__tar.gz

{god_code-0.5.5 → god_code-0.6.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: god-code
-Version: 0.5.5
+Version: 0.6.1
 Summary: AI coding agent specialized for Godot game development
-Project-URL: Homepage, https://github.com/chuisiufai/god-code
-Project-URL: Repository, https://github.com/chuisiufai/god-code
+Project-URL: Homepage, https://github.com/888wing/god-code
+Project-URL: Repository, https://github.com/888wing/god-code
 Author: chuisiufai
 License: GPL-3.0-or-later
 License-File: LICENSE

{god_code-0.5.5 → god_code-0.6.1}/README.md

@@ -25,16 +25,35 @@ AI coding agent specialized for Godot 4.4 game development. Unlike generic codin
 pip install god-code
 ```
 
-Or from source:
+With MCP support (for Claude Code / Codex integration):
 
 ```bash
-git clone https://github.com/chuisiufai/god-code.git
-cd god-code
-pip install -e ".[dev]"
+pip install god-code[mcp]
 ```
 
 Requires Python 3.9+.
 
+### Claude Code Skill (one-click setup)
+
+If you use Claude Code, install the god-code skill for automated setup:
+
+```bash
+# Copy the skill to your Claude Code skills directory
+mkdir -p ~/.claude/skills/god-code-setup
+curl -sL https://raw.githubusercontent.com/888wing/god-code/main/skills/god-code-setup/SKILL.md \
+  -o ~/.claude/skills/god-code-setup/SKILL.md
+```
+
+Then in Claude Code, just say: **"install god-code and configure MCP"** — it will handle everything automatically.
+
+### From Source
+
+```bash
+git clone https://github.com/888wing/god-code.git
+cd god-code
+pip install -e ".[dev,mcp]"
+```
+
 ## Quick Start
 
 ### 1. Configure API key (BYOK — Bring Your Own Key)
@@ -192,7 +211,7 @@ God Code executes tools on your local machine. The LLM decides which tools to ca
 
 ## MCP Server (for Claude Code / Codex / AI Agents)
 
-God Code can run as an MCP (Model Context Protocol) server, exposing 12 Godot tools directly to AI agents. **No LLM middleman, zero token cost** — tools run locally.
+God Code can run as an MCP (Model Context Protocol) server, exposing 20 Godot tools directly to AI agents. **No LLM middleman, zero token cost** — tools run locally.
 
 ### Install
 

{god_code-0.5.5 → god_code-0.6.1}/godot_agent/cli.py

@@ -702,7 +702,7 @@ def _run_setup_wizard(config_path: Path | None = None) -> None:
     click.echo()
 
 
-_VERSION = "0.5.5"
+_VERSION = "0.6.1"
 
 
 def _check_update() -> None:
@@ -1680,5 +1680,57 @@ def mcp_command(project: str):
     run_mcp_server(project_path=project)
 
 
+@main.command()
+def tools():
+    """List all available MCP tools with descriptions."""
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+
+    console = Console()
+
+    try:
+        from godot_agent.mcp_server import mcp as mcp_instance
+        mcp_tools = mcp_instance._tool_manager._tools
+    except Exception:
+        console.print("[red]MCP not available. Install with: pip install god-code[mcp][/]")
+        return
+
+    t = Table(show_header=True, padding=(0, 1))
+    t.add_column("#", style="dim", width=3)
+    t.add_column("Tool", style="green bold")
+    t.add_column("Description", style="dim")
+
+    for i, (name, tool) in enumerate(sorted(mcp_tools.items()), 1):
+        desc = (tool.description or "").split("\n")[0][:80]
+        t.add_row(str(i), name, desc)
+
+    console.print(Panel(t, title=f"[cyan]God Code MCP Tools ({len(mcp_tools)})[/]", border_style="cyan"))
+    console.print()
+    console.print("[dim]Use these tools via MCP in Claude Code, or directly in god-code chat.[/]")
+
+
+@main.command("update-skill")
+def update_skill():
+    """Download/update the god-code-setup skill for Claude Code."""
+    from pathlib import Path
+    import httpx
+
+    skill_dir = Path.home() / ".claude" / "skills" / "god-code-setup"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    skill_file = skill_dir / "SKILL.md"
+    url = "https://raw.githubusercontent.com/888wing/god-code/main/skills/god-code-setup/SKILL.md"
+
+    click.echo(f"Downloading skill from {url}...")
+    try:
+        resp = httpx.get(url, timeout=10, follow_redirects=True)
+        resp.raise_for_status()
+        skill_file.write_text(resp.text)
+        click.secho(f"Skill updated: {skill_file}", fg="green")
+        click.echo("Restart Claude Code to activate.")
+    except Exception as e:
+        click.secho(f"Failed: {e}", fg="red")
+
+
 if __name__ == "__main__":
     main()

god_code-0.6.1/godot_agent/mcp_server.py

@@ -0,0 +1,393 @@
+"""MCP Server — exposes god-code's Godot tools to AI agents (Claude Code, Codex, etc).
+
+Usage:
+    god-code mcp --project /path/to/godot/project
+
+Runs as a local stdio process. No backend server needed.
+12 analysis tools + 8 write/execute tools = full game development capability.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+log = logging.getLogger(__name__)
+
+mcp = FastMCP("god-code")
+
+_project_root: Path | None = None
+
+
+def set_mcp_project_root(path: Path) -> None:
+    global _project_root
+    _project_root = path.resolve()
+
+
+def _root() -> Path:
+    return _project_root or Path.cwd()
+
+
+def _godot_path() -> str:
+    config_file = Path.home() / ".config" / "god-code" / "config.json"
+    if config_file.exists():
+        return json.loads(config_file.read_text()).get("godot_path", "godot")
+    return "godot"
+
+
+# ═══════════════════════════════════════════════════════════════════
+# ANALYSIS TOOLS (read-only, zero side effects)
+# ═══════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def validate_project(project_path: str = "") -> dict:
+    """Run Godot headless validation. Returns errors and warnings."""
+    from godot_agent.runtime.error_loop import validate_project as _validate, format_validation_for_llm
+    root = project_path or str(_root())
+    result = await _validate(root, _godot_path(), timeout=30)
+    return {
+        "success": result.success,
+        "errors": [{"file": e.file, "line": e.line, "message": e.message} for e in result.errors],
+        "warnings": [{"file": w.file, "line": w.line, "message": w.message} for w in result.warnings],
+        "summary": format_validation_for_llm(result),
+    }
+
+
+@mcp.tool()
+def validate_tscn(file_path: str, auto_fix: bool = False) -> dict:
+    """Validate .tscn format. Optionally auto-fix ordering issues (sub_resource before node, load_steps count)."""
+    from godot_agent.godot.tscn_validator import validate_tscn as _validate, validate_and_fix
+    text = Path(file_path).read_text(errors="replace")
+    if auto_fix:
+        fixed_text, issues = validate_and_fix(text)
+        if fixed_text != text:
+            Path(file_path).write_text(fixed_text)
+        return {"fixed": fixed_text != text, "remaining_issues": [str(i) for i in issues]}
+    issues = _validate(text)
+    return {"issues": [str(i) for i in issues], "has_errors": any(i.severity == "error" for i in issues)}
+
+
+@mcp.tool()
+def lint_script(file_path: str) -> dict:
+    """Lint GDScript for naming, ordering, type annotations, and anti-patterns."""
+    from godot_agent.godot.gdscript_linter import lint_gdscript, format_lint_report
+    text = Path(file_path).read_text(errors="replace")
+    issues = lint_gdscript(text, filename=Path(file_path).name)
+    return {
+        "report": format_lint_report(issues, Path(file_path).name),
+        "error_count": sum(1 for i in issues if i.severity == "error"),
+        "warning_count": sum(1 for i in issues if i.severity == "warning"),
+    }
+
+
+@mcp.tool()
+def check_consistency(project_path: str = "") -> dict:
+    """Check cross-file consistency: collision layers, signals, resource paths, groups."""
+    from godot_agent.godot.consistency_checker import check_consistency as _check, format_consistency_report
+    root = Path(project_path) if project_path else _root()
+    issues = _check(root)
+    return {"report": format_consistency_report(issues), "error_count": sum(1 for i in issues if i.severity == "error")}
+
+
+@mcp.tool()
+def plan_collision(entities: list[str]) -> dict:
+    """Generate standard collision layer/mask config. Entities: player, enemy, player_bullet, enemy_bullet, terrain, pickup, trigger, interactable."""
+    from godot_agent.godot.collision_planner import plan_game_collisions, format_collision_plan
+    configs = plan_game_collisions(entities)
+    return {
+        "configs": [{"entity": c.entity_type, "layer": c.layer, "bitmask": c.layer_bitmask,
+                      "mask_layers": c.mask_layers, "mask_bitmask": c.mask_bitmask, "gdscript": c.to_gdscript()}
+                     for c in configs],
+        "plan": format_collision_plan(configs),
+    }
+
+
+@mcp.tool()
+def analyze_dependencies(project_path: str = "") -> dict:
+    """Build project dependency graph (scenes → scripts → resources)."""
+    from godot_agent.godot.dependency_graph import build_dependency_graph
+    graph = build_dependency_graph(Path(project_path) if project_path else _root())
+    return {"summary": graph.format_summary(), "autoloads": graph.autoloads, "orphans": graph.orphans()}
+
+
+@mcp.tool()
+def suggest_patterns(project_path: str = "") -> dict:
+    """Suggest design patterns: object pool, component, state machine."""
+    from godot_agent.godot.pattern_advisor import analyze_project, format_advice
+    advice = analyze_project(Path(project_path) if project_path else _root())
+    return {"report": format_advice(advice), "count": len(advice)}
+
+
+@mcp.tool()
+def parse_scene(file_path: str) -> dict:
+    """Parse .tscn into structured data: nodes, resources, connections, node paths."""
+    from godot_agent.godot.scene_parser import parse_tscn
+    scene = parse_tscn(Path(file_path).read_text(errors="replace"))
+    return {
+        "nodes": [{"name": n.name, "type": n.type, "parent": n.parent, "properties": n.properties} for n in scene.nodes],
+        "ext_resources": [{"type": r.type, "path": r.path, "id": r.id} for r in scene.ext_resources],
+        "connections": [{"signal": c.signal, "from": c.from_node, "to": c.to_node, "method": c.method} for c in scene.connections],
+        "node_paths": scene.node_paths(),
+    }
+
+
+@mcp.tool()
+def project_info(project_path: str = "") -> dict:
+    """Read project.godot: name, version, autoloads, resolution, renderer."""
+    from godot_agent.godot.project import parse_project_godot
+    proj = parse_project_godot((Path(project_path) if project_path else _root()) / "project.godot")
+    return {"name": proj.name, "version": proj.version, "main_scene": proj.main_scene,
+            "resolution": f"{proj.viewport_width}x{proj.viewport_height}", "autoloads": proj.autoloads}
+
+
+@mcp.tool()
+def godot_knowledge(topic: str) -> dict:
+    """Query Godot 4.4 Playbook. Topics: collision, physics, signal, animation, ui, input, performance, resource, autoload, shader, etc."""
+    from godot_agent.prompts.knowledge_selector import select_sections
+    sections = select_sections(topic, max_sections=3)
+    return {"sections": [{"title": t, "content": c} for t, c in sections]}
+
+
+@mcp.tool()
+def validate_resources(file_path: str, project_path: str = "") -> dict:
+    """Check all ext_resource paths in a .tscn exist on disk."""
+    from godot_agent.godot.resource_validator import validate_resources as _validate
+    issues = _validate(Path(file_path), project_root=Path(project_path) if project_path else _root())
+    return {"valid": len(issues) == 0, "missing": issues}
+
+
+# ═══════════════════════════════════════════════════════════════════
+# WRITE TOOLS (modify files with format protection)
+# ═══════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+def write_scene(file_path: str, content: str) -> dict:
+    """Write a .tscn file with automatic format validation and fix.
+
+    Validates the content before writing. Auto-fixes sub_resource ordering and load_steps count.
+    Use this instead of writing .tscn files directly to prevent format errors.
+    """
+    from godot_agent.godot.tscn_validator import validate_and_fix
+    fixed_text, issues = validate_and_fix(content)
+    errors = [i for i in issues if i.severity == "error"]
+    if errors:
+        return {"written": False, "errors": [str(e) for e in errors]}
+    Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+    Path(file_path).write_text(fixed_text, encoding="utf-8")
+    return {"written": True, "path": file_path, "auto_fixed": fixed_text != content,
+            "warnings": [str(i) for i in issues if i.severity == "warning"]}
+
+
+@mcp.tool()
+def add_scene_node(file_path: str, parent: str, name: str, node_type: str,
+                   properties: dict[str, str] | None = None) -> dict:
+    """Add a node to an existing .tscn scene file.
+
+    Args:
+        file_path: Path to .tscn file
+        parent: Parent node path ("." for root's child, "NodeName" for deeper)
+        name: New node name (PascalCase)
+        node_type: Godot node type (Node2D, Sprite2D, Area2D, Label, etc.)
+        properties: Optional property dict (e.g., {"position": "Vector2(100, 200)"})
+    """
+    from godot_agent.godot.scene_writer import add_node
+    from godot_agent.godot.tscn_validator import validate_and_fix
+    text = Path(file_path).read_text(errors="replace")
+    new_text = add_node(text, parent=parent, name=name, type=node_type, properties=properties)
+    fixed, issues = validate_and_fix(new_text)
+    Path(file_path).write_text(fixed, encoding="utf-8")
+    return {"added": True, "node": f"{name} ({node_type})", "parent": parent,
+            "warnings": [str(i) for i in issues if i.severity == "warning"]}
+
+
+@mcp.tool()
+def set_scene_property(file_path: str, node_name: str, key: str, value: str) -> dict:
+    """Set or update a property on a node in a .tscn file.
+
+    Args:
+        file_path: Path to .tscn file
+        node_name: Name of the node to modify
+        key: Property name (e.g., "position", "text", "color", "visible")
+        value: Property value as Godot string (e.g., "Vector2(10, 20)", '"Hello"', "true")
+    """
+    from godot_agent.godot.scene_writer import set_node_property
+    text = Path(file_path).read_text(errors="replace")
+    new_text = set_node_property(text, node_name=node_name, key=key, value=value)
+    Path(file_path).write_text(new_text, encoding="utf-8")
+    return {"set": True, "node": node_name, "property": f"{key} = {value}"}
+
+
+@mcp.tool()
+def add_signal_connection(file_path: str, signal_name: str, from_node: str,
+                          to_node: str, method: str) -> dict:
+    """Add a signal connection to a .tscn file.
+
+    Args:
+        signal_name: Signal name (e.g., "pressed", "body_entered", "timeout")
+        from_node: Source node path
+        to_node: Target node path
+        method: Handler method name (e.g., "_on_button_pressed")
+    """
+    from godot_agent.godot.scene_writer import add_connection
+    text = Path(file_path).read_text(errors="replace")
+    new_text = add_connection(text, signal_name=signal_name, from_node=from_node,
+                              to_node=to_node, method=method)
+    Path(file_path).write_text(new_text, encoding="utf-8")
+    return {"connected": True, "signal": signal_name, "from": from_node, "to": to_node, "method": method}
+
+
+@mcp.tool()
+def write_script(file_path: str, content: str, lint: bool = True) -> dict:
+    """Write a GDScript file with optional lint validation.
+
+    Use this instead of writing .gd files directly. Runs the linter and returns issues.
+    """
+    Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+    Path(file_path).write_text(content, encoding="utf-8")
+    result = {"written": True, "path": file_path}
+    if lint:
+        from godot_agent.godot.gdscript_linter import lint_gdscript
+        issues = lint_gdscript(content, filename=Path(file_path).name)
+        result["lint_errors"] = sum(1 for i in issues if i.severity == "error")
+        result["lint_warnings"] = sum(1 for i in issues if i.severity == "warning")
+        if issues:
+            result["lint_issues"] = [str(i) for i in issues[:10]]
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════
+# EXECUTION TOOLS (run Godot, take screenshots)
+# ═══════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def run_gut_tests(test_script: str = "", project_path: str = "") -> dict:
+    """Run GUT tests in headless mode. Returns pass/fail results.
+
+    Args:
+        test_script: Specific test script (e.g., "res://tests/test_battle.gd"). Empty = run all.
+        project_path: Godot project root. Empty = use configured root.
+    """
+    import asyncio
+    from godot_agent.tools.godot_cli import build_gut_command, parse_godot_output
+    root = project_path or str(_root())
+    cmd = build_gut_command(_godot_path(), test_script or None)
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, cwd=root)
+    stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
+    output = stdout.decode(errors="replace") + "\n" + stderr.decode(errors="replace")
+    report = parse_godot_output(output)
+    return {
+        "exit_code": proc.returncode or 0,
+        "passed": proc.returncode == 0,
+        "errors": [{"file": e.file, "line": e.line, "message": e.message} for e in report.errors],
+        "output_tail": output[-500:],
+    }
+
+
+@mcp.tool()
+async def screenshot_scene(scene_path: str, output_path: str = "", delay_ms: int = 1000,
+                           project_path: str = "") -> dict:
+    """Take a screenshot of a Godot scene using headless rendering.
+
+    Args:
+        scene_path: res:// path to the scene (e.g., "res://scenes/main.tscn")
+        output_path: Where to save PNG. Empty = temp file.
+        delay_ms: Wait time before capture (ms). Default 1000.
+    """
+    import asyncio
+    import tempfile
+    from godot_agent.tools.godot_cli import build_screenshot_script
+    from godot_agent.llm.vision import encode_image
+
+    root = project_path or str(_root())
+    if not output_path:
+        output_path = str(Path(tempfile.mkdtemp()) / "screenshot.png")
+
+    script = build_screenshot_script(scene_path, output_path, delay_ms)
+    script_path = str(Path(tempfile.mkdtemp()) / "capture.gd")
+    Path(script_path).write_text(script)
+
+    proc = await asyncio.create_subprocess_exec(
+        _godot_path(), "--headless", "-s", script_path,
+        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, cwd=root)
+    await asyncio.wait_for(proc.communicate(), timeout=30)
+
+    if not Path(output_path).exists():
+        return {"success": False, "error": "Screenshot not created. Scene may have failed to load."}
+
+    b64 = encode_image(output_path)
+    return {"success": True, "path": output_path, "image_base64": b64}
+
+
+@mcp.tool()
+async def run_scene(scene_path: str = "", project_path: str = "", timeout_seconds: int = 5) -> dict:
+    """Run a Godot scene briefly to verify it loads without errors.
+
+    Args:
+        scene_path: res:// path. Empty = main scene from project.godot.
+        timeout_seconds: How long to let it run before stopping (default 5).
+    """
+    import asyncio
+    root = project_path or str(_root())
+    cmd = [_godot_path(), "--headless"]
+    if scene_path:
+        cmd.extend(["--scene", scene_path])
+    cmd.append("--quit-after")
+    cmd.append(str(timeout_seconds))
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, cwd=root)
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout_seconds + 10)
+        output = stdout.decode(errors="replace") + "\n" + stderr.decode(errors="replace")
+    except asyncio.TimeoutError:
+        proc.kill()
+        output = "Timed out"
+
+    from godot_agent.runtime.error_loop import parse_godot_output
+    errors = parse_godot_output(output)
+    return {
+        "loaded": not any(e.level == "ERROR" for e in errors),
+        "errors": [{"file": e.file, "line": e.line, "message": e.message} for e in errors if e.level == "ERROR"],
+        "exit_code": proc.returncode,
+    }
+
+
+# ═══════════════════════════════════════════════════════════════════
+# SPRITE GENERATION
+# ═══════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def generate_sprite(
+    subject: str, output_path: str, size: int = 32, style: str = "pixel_modern",
+    facing: str = "front", category: str = "character", extra: str = "",
+) -> dict:
+    """Generate pixel art sprite with AI. Pipeline: generate → chroma key → crop → resize.
+
+    Args:
+        subject: What to draw (e.g., "fire mage", "health potion", "slime enemy")
+        output_path: Where to save PNG
+        size: Pixel size (8/16/24/32/48/64/128)
+        style: pixel_8bit, pixel_16bit, pixel_modern, chibi, minimal
+        facing: front, left, right, back
+        category: character, enemy, boss, item, projectile, ui_icon, effect
+    """
+    from godot_agent.tools.image_gen import GenerateSpriteTool
+    tool = GenerateSpriteTool()
+    result = await tool.execute(tool.Input(
+        subject=subject, output_path=output_path, size=size,
+        style=style, facing=facing, category=category, extra=extra))
+    if result.error:
+        return {"error": result.error}
+    return {"path": result.output.path, "width": result.output.width,
+            "height": result.output.height, "prompt_used": result.output.prompt_used}
+
+
+def run_mcp_server(project_path: str | None = None) -> None:
+    """Entry point: god-code mcp [--project PATH]"""
+    if project_path:
+        set_mcp_project_root(Path(project_path))
+    mcp.run(transport="stdio")

{god_code-0.5.5 → god_code-0.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "god-code"
-version = "0.5.5"
+version = "0.6.1"
 description = "AI coding agent specialized for Godot game development"
 requires-python = ">=3.9"
 license = {text = "GPL-3.0-or-later"}
@@ -29,8 +29,8 @@ dev = [
 god-code = "godot_agent.cli:main"
 
 [project.urls]
-Homepage = "https://github.com/chuisiufai/god-code"
-Repository = "https://github.com/chuisiufai/god-code"
+Homepage = "https://github.com/888wing/god-code"
+Repository = "https://github.com/888wing/god-code"
 
 [tool.hatch.build.targets.wheel]
 packages = ["godot_agent"]

god_code-0.6.1/skills/god-code-setup/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: god-code-setup
+description: Install and configure God Code — the AI coding agent for Godot 4.4 game development. Use when the user wants to set up god-code, configure MCP server for Claude Code, or start a Godot project with AI assistance. Triggers on keywords like god-code, godot agent, godot mcp, godot ai, setup godot tools.
+---
+
+# God Code Setup
+
+Automated installation and MCP server configuration for God Code — the Godot 4.4 AI development toolkit.
+
+## What This Does
+
+1. Installs god-code from PyPI (with MCP support)
+2. Configures MCP server so Claude Code gets 12 Godot tools
+3. Verifies everything works
+
+## Step 1: Install
+
+```bash
+pip install god-code[mcp]
+```
+
+If pip fails on macOS (externally-managed-environment):
+```bash
+pip install --user god-code[mcp]
+```
+
+Verify:
+```bash
+god-code --version
+```
+
+## Step 2: Configure API Key (if not already set)
+
+Run the setup wizard:
+```bash
+god-code setup
+```
+
+Or set manually:
+```bash
+mkdir -p ~/.config/god-code
+cat > ~/.config/god-code/config.json << 'EOF'
+{
+  "api_key": "YOUR_API_KEY_HERE",
+  "model": "gpt-5.4",
+  "godot_path": "/Applications/Godot.app/Contents/MacOS/Godot"
+}
+EOF
+chmod 600 ~/.config/god-code/config.json
+```
+
+## Step 3: Configure MCP Server for Claude Code
+
+Add god-code as an MCP server so Claude Code gets Godot tools directly:
+
+```bash
+# Find the Claude Code config location
+CONFIG_DIR="${HOME}/.claude"
+mkdir -p "$CONFIG_DIR"
+
+# Check if settings file exists, create or update
+SETTINGS_FILE="$CONFIG_DIR/settings.json"
+```
+
+The MCP server config that needs to be added:
+
+```json
+{
+  "mcpServers": {
+    "god-code": {
+      "command": "god-code",
+      "args": ["mcp", "--project", "."]
+    }
+  }
+}
+```
+
+For project-specific setup, the `--project` arg should point to the Godot project root.
+
+## Step 4: Verify MCP Connection
+
+After configuring, Claude Code will have these tools available:
+
+| Tool | Description |
+|------|-------------|
+| `validate_project` | Run Godot headless validation |
+| `validate_tscn` | Check .tscn format + auto-fix |
+| `lint_script` | GDScript quality checks |
+| `check_consistency` | Cross-file consistency |
+| `plan_collision` | Standard collision layers |
+| `analyze_dependencies` | Project dependency graph |
+| `suggest_patterns` | Design pattern suggestions |
+| `parse_scene` | Parse .tscn structure |
+| `project_info` | Read project.godot |
+| `godot_knowledge` | Query Godot Playbook |
+| `generate_sprite` | AI pixel art generation |
+| `validate_resources` | Check res:// paths |
+
+## Usage After Setup
+
+### As CLI (interactive chat):
+```bash
+god-code
+cd ~/Projects/my-godot-game
+# Start chatting with the agent
+```
+
+### As MCP Server (Claude Code uses tools directly):
+Claude Code automatically calls god-code tools when working on Godot projects. No extra commands needed.
+
+### Key CLI Commands:
+- `/mode [apply|plan|explain|review|fix]` — change interaction mode
+- `/provider [name]` — switch LLM provider
+- `/settings` — view/change all settings
+- `/usage` — token usage and cost
+
+## Troubleshooting
+
+**god-code not found**: Make sure pip installed to a directory in your PATH. Try `python3 -m pip install --user god-code[mcp]`.
+
+**MCP tools not appearing**: Restart Claude Code after adding the MCP config. Check `god-code mcp --help` works.
+
+**Godot validation fails**: Set the correct Godot path in config: `god-code setup` or `/set godot_path /path/to/godot`.