graphify gdscript

    1

    Map Godot project architectures and trace signal connections across scenes and scripts using a local knowledge graph.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    graphify gdscript

    Example session with this skill installed

    /graphify-gdscript trace "health_changed"

    • Read your context and instructions
    • Compiled the graphify gdscript

    I have traced the health_changed signal across the project. It is declared in the HealthComponent, emitted during damage calculation, and connected to the UI overlay via the Game.tscn scene file.

    Signal Trace: health_changed

    RelationSourceTargetContext
    declares_signalscripts/components/health.gd:L5health_changedsignal health_changed(old, new)
    emitsscripts/components/health.gd:L42health_changedhealth_changed.emit(prev, current)
    connects_toscenes/entities/player.tscn:L112scripts/ui/health_bar.gd:L15Signal bound in Scene Tree to _on_health_changed
    connects_toscenes/main/game.tscn:L405scripts/managers/sfx_manager.gd:L88Connected via inspector to play hit sounds
    callsscripts/ui/health_bar.gd:L16update_visuals()Callback logic execution

    Gaps

    • The graph did not find any dynamic connections via connect() calls in the LevelManager script, which may exist but are not statically reachable.

    Next steps

    1. If you need to refactor the signal arguments, start with the declaration in scripts/components/health.gd:L5.
    2. Update the callback signature in scripts/ui/health_bar.gd:L15 to match.
    3. Run gdscript_rebuild_graph after saving changes to verify connections.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Godot projects often become a tangled web of scene tree dependencies, signal connections, and autoload singletons that standard grep searches fail to map. This skill parses your project into a comprehensive knowledge graph, revealing the hidden links between .tscn files and .gd scripts that lead to "spaghetti" architecture.

    What it does

    • Signal Tracing maps every declaration, emission, and connection, including those hidden inside scene files.
    • Autoload Analysis resolves singleton calls to their underlying scripts and tracks global state usage.
    • Pathfinding calculates the shortest connection between two arbitrary symbols to explain how systems interact.
    • Token Optimization generates high-context subgraphs for LLM queries, reducing token usage compared to repo-wide searches.
    • Architecture Auditing identifies "god nodes" and tightly coupled communities within your game logic.

    How it works

    1. Run /graphify-gdscript to perform an AST-based scan of your project files and build the local graph database.
    2. Use query "<question>" to retrieve a cited subgraph that answers specific architectural or logic questions.
    3. Use trace "<signal>" to find every instance of a signal across both scripts and scene files.
    4. Execute path "<A>" "<B>" to see the exact chain of calls or references linking two parts of your codebase.

    Frameworks & tools

    Built for Godot 3.x and 4.x projects. It requires the graphify-gdscript Python CLI tool and can integrate with an MCP server for tool-calling environments.

    Why this beats prompting it yourself

    Standard LLMs struggle with Godot's multi-file nature, often missing signal connections defined in .tscn binary/text formats. This skill uses a local AST parser to provide ground-truth citations, ensuring the agent doesn't hallucinate node paths or invisible connections.

    Use cases

    • Debugging why a signal isn't triggering a specific callback in a complex UI scene.
    • Mapping the dependencies of a legacy Autoload before refactoring it into a resource-based system.
    • Explaining the initialization order and node references of a deeply nested player scene.
    • Generating a token-efficient architecture report for a new developer onboarding to the project.

    Known limitations

    Cannot track dynamic connect() calls made with string-based names or node paths constructed via runtime string manipulation. Requires a local Python environment.

    Cannot track dynamic connect() calls or node paths built at runtime via strings. Requires local Python 3.9+ and the graphify-gdscript CLI installed on PATH.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    • Free with an Agensi account

    Requires

    Python

    Permissions

    Read Files
    Write Files
    Network Access
    Listed3 days ago

    What's inside

    Frequently Asked Questions

    Unlike a standard text search, this skill parses both .gd scripts and .tscn files to map signals connected via the editor, which are invisible to traditional grep tools. It builds a local knowledge graph that allows the AI to see the actual structure of your scene tree and resource dependencies.

    Yes, the tool is designed to support both Godot 3.x and 4.x projects, handling the syntax differences in GDScript and the variations in scene file formats between the two versions.

    You will receive the AI agent skill configuration, access to the local AST parser (Python CLI), and documentation for setting up the MCP server to bridge your local project data with the AI environment.

    No, the skill builds and queries a local graph database on your machine; your source code is not uploaded to a third-party server, though the AI agent will process the specific subgraphs you query.

    The skill cannot track dynamic connections where the signal name or node path is constructed using runtime string manipulation (e.g., `connect("signal_" + name, ...)`), as these do not exist in the static files.

    This skill is designed for tool-calling environments and works best with agents that support the Model Context Protocol (MCP) or custom tool execution, allowing it to interface directly with the local Python CLI.

    New in Game Development