Skip to content

AlgorithMagic/GoToolCenter

BranchesTags

Repository files navigation

GoTool Center

OpenSSF Best Practices CI Fuzzing Dependabot License: MIT

GoTool Center is a Godot 4 editor toolchain for analyzing, organizing, and maintaining Godot projects from inside the editor.

It is built as a Godot editor plugin with a GDScript UI and a C++ GDExtension backend. The goal is to provide one project-aware workspace for project scans, health checks, dependency visibility, diagnostics, resource review, JSON/data tooling, and optional external integrations.

Status: early development / pre-1.0
APIs, UI layout, database schema, feature names, and internal architecture may change before a stable release.

Contents

Section Description
Project Intent What GoTool Center is meant to solve.
Obtain GoTool Center How to get the software from GitHub or releases.
Installation End-user installation instructions.
Current Status Current feature progress and stability.
Planned Final Workflow How GoTool Center is intended to work when complete.
Feature Overview Planned and active feature areas.
Architecture Editor UI, GDScript services, GDExtension backend, and SQLite storage.
External Interface Reference Current input/output interfaces exposed by the project.
Repository Layout High-level file and directory structure.
Technology Stack Languages, frameworks, libraries, and tools used.
Requirements End-user and developer requirements.
Development Workflow Local setup, validation, and style checks.
Build Instructions Native build commands by platform.
Feedback Bug reports, enhancement requests, and security reports.
Contributing Pull request process and contribution standards.
CI, Fuzzing, and OpenSSF Readiness Security, supply-chain, CI, and OpenSSF-related metadata.
Dependency Pinning Pinned versions and dependency update policy.
Database and Configuration Local SQLite and settings paths.
Generated Files Ignored generated files and local artifacts.
Security Security-sensitive areas and vulnerability reporting.
License MIT license and third-party license note.

Project Intent

GoTool Center is intended to help Godot developers understand and maintain growing projects.

It is designed to answer questions such as:

  • What files, scenes, scripts, resources, and dependencies exist in this project?
  • Which references are missing, duplicated, oversized, unused, or misconfigured?
  • What project-health issues should be fixed first?
  • Which JSON/data files can be inspected, validated, converted, or migrated?
  • What maintenance work should happen before export or release?

GoTool Center does not replace Godot’s editor. It adds a project maintenance workspace beside the existing editor tools.

Obtain GoTool Center

From GitHub

Repository:

https://github.com/AlgorithMagic/GoToolCenter

Clone with submodules:

git clone --recurse-submodules https://github.com/AlgorithMagic/GoToolCenter.git
cd GoToolCenter

If already cloned:

git submodule update --init --recursive

From Releases

Stable packaged releases are still in progress. When releases are available, download the release package for your platform from the repository’s GitHub Releases page.

Expected release contents:

Item Purpose
addons/gotool_center/ Godot editor plugin folder.
bin/.gdextension GDExtension descriptor.
Native platform binary C++ backend library for the target OS/architecture.
GDScript services Scanner, configuration, and editor orchestration.
Scenes and UI scripts Main GoTool Center editor interface.

Installation

Install From a Release

  1. Download the GoTool Center release package for your platform.
  2. Copy the add-on folder into your Godot project:
res://addons/gotool_center/
  1. Confirm the native binary exists in:
res://addons/gotool_center/bin/
  1. Open the project in Godot.
  2. Enable the plugin:
Project > Project Settings > Plugins > GoTool Center > Enable
  1. Open the GoTool Center main-screen tab.
  2. Run setup validation.
  3. Run a project scan.

Manual Install From Repository

git clone --recurse-submodules https://github.com/AlgorithMagic/GoToolCenter.git
cd GoToolCenter

Build the native library for your platform, then copy:

project/addons/gotool_center/

into your target project as:

your_project/addons/gotool_center/

Current Status

Area State Progress
Editor plugin shell In progress 45%
Tabbed editor UI In progress 35%
C++ GDExtension backend In progress 35%
Shared project context In progress 45%
SQLite project database In progress 40%
Project scanner In progress 35%
Configuration backend In progress 45%
Basic database viewing In progress 25%
Project analysis Planned 15%
Project health scoring Planned 10%
JSON tools Planned 5%
Resource management Planned 10%
Asset management Planned 5%
Diagnostics dashboard Planned 20%
Release packaging In progress 35%

Progress percentages are rough development indicators, not release guarantees.

Planned Final Workflow

In its final form, GoTool Center is intended to work like this:

  1. Enable GoTool Center in a Godot project.
  2. Validate plugin paths, settings, native libraries, and database availability.
  3. Scan the project.
  4. Store indexed project metadata in a local SQLite database.
  5. Review files, scenes, scripts, resources, dependencies, and diagnostics.
  6. Inspect project health and prioritized maintenance suggestions.
  7. Use focused tool tabs for analysis, JSON/data conversion, resource cleanup, asset review, and diagnostics.
  8. Export reports or apply safe maintenance actions where supported.

Feature Overview

Feature Intended Behavior Current State
GoTool Setup Validate configuration, paths, backend status, and setup state. Partial
Project Analysis Analyze structure, dependencies, coupling, and maintainability signals. Planned
Project Health Provide health summaries, scoring, and prioritized fixes. Planned
JSON Tools Inspect, validate, convert, and migrate JSON data. Planned
Resource Management Review resources, dependencies, missing references, and cleanup opportunities. Planned
Asset Management Inspect textures, audio, meshes, imports, and asset metadata. Planned
Diagnostics Aggregate issues with severity, source, and suggested actions. Partial
Configure GoTool Manage settings, feature flags, paths, and backend options. Partial
SQLite Storage Store scan results and project metadata locally. Partial
External Integrations Optional SQL/database/tool integrations. Planned

Architecture

Godot Editor UI
    ↓
GDScript Services
    ↓
C++ GDExtension Backend
    ↓
SQLite Project Metadata

Editor Plugin

project/addons/gotool_center/

Key files:

project/addons/gotool_center/plugin.cfg
project/addons/gotool_center/gotool.gd
project/addons/gotool_center/window_asset/go_tool_center.tscn
project/addons/gotool_center/window_asset/go_tool_center.gd

Responsibilities:

  • editor plugin lifecycle
  • main-screen UI registration
  • tool tab presentation
  • service orchestration
  • safe cleanup on plugin disable/reload

GDScript Services

project/addons/gotool_center/services/

Current services:

go_tool_configuration_schema.gd
go_tool_configuration_service.gd
go_tool_project_scanner.gd

Responsibilities:

  • configuration defaults
  • settings loading/saving
  • migration and validation
  • feature flags
  • project scanning
  • lightweight metadata extraction
  • editor-facing coordination

C++ GDExtension Backend

src/

Current native classes:

Class Purpose
GodotProjectContext Shared project context, paths, scan state, reports, and service references.
GoToolProjectDatabase SQLite-backed project metadata database.

Native registration:

src/shared/register_types.cpp
src/shared/register_types.h

GDExtension entry symbol:

gotool_center_library_init

External Interface Reference

This section documents the current external interfaces produced by GoTool Center. These interfaces are expected to change before 1.0.0.

Godot Editor Plugin Interface

Interface Input Output / Behavior
Plugin enable User enables res://addons/gotool_center/plugin.cfg in Godot’s plugin settings. GoTool Center registers a main-screen editor plugin tab.
Plugin disable User disables the plugin. Editor UI and project services are cleaned up.
Main-screen tab User opens the GoTool Center editor tab. Tabbed UI is shown inside the Godot editor.
Setup validation User runs setup/configuration validation. Validation messages, warnings, and backend availability state are shown.
Project scan User starts a scan from the UI. Project files are scanned and metadata is stored in SQLite.
Database view User requests database rows from the UI. A table/tree view displays indexed file rows and summary counts.

Add-on Package Interface

Expected installed path:

res://addons/gotool_center/

Required input files:

plugin.cfg
gotool.gd
bin/.gdextension
services/*.gd
window_asset/*.gd
window_asset/*.tscn

Expected native binary output location:

res://addons/gotool_center/bin/

Expected native binary names:

libgotool_center.windows.template_debug.x86_64.dll
libgotool_center.windows.template_release.x86_64.dll
libgotool_center.linux.template_debug.x86_64.so
libgotool_center.linux.template_release.x86_64.so
libgotool_center.macos.template_debug.universal.dylib
libgotool_center.macos.template_release.universal.dylib

Scanner Service Interface

Current service:

res://addons/gotool_center/services/go_tool_project_scanner.gd

Primary method:

scan_project(project_root_path: String, addon_root_path: String, project_database_service: Object) -> Dictionary

Inputs:

Input Type Description
project_root_path String Godot project root path, usually res://.
addon_root_path String GoTool Center add-on path, usually res://addons/gotool_center.
project_database_service Object Database service instance exposing expected insert/query methods.

Output dictionary:

Key Type Description
success bool Whether the scan completed successfully.
scan_session_id int Database scan session identifier, or -1 on failure.
file_count int Number of indexed files.
resource_count int Number of indexed resources.
scene_count int Number of indexed scenes.
script_count int Number of indexed scripts.
dependency_count int Number of indexed dependencies.
diagnostic_count int Number of emitted diagnostics.
error_message String Empty on success, otherwise a human-readable error.

Configuration Service Interface

Current service:

res://addons/gotool_center/services/go_tool_configuration_service.gd

Important methods:

Method Input Output
load_settings() none Dictionary of loaded settings.
save_settings(settings: Dictionary) settings dictionary bool success state.
get_settings() none Current settings dictionary.
get_setting(key: StringName, default_value: Variant) setting key and fallback Setting value or fallback.
set_setting(key: StringName, value: Variant) setting key and value bool success state.
reset_settings(reset_scope: StringName) user, project, validation_cache, or all bool success state.
validate_settings() none Validation report dictionary.
validate_native_dependencies() none Native backend availability report.
get_feature_flags() none Feature-flag dictionary.
needs_migration() none bool migration-needed state.
migrate_settings() none Migration report dictionary.

Default configuration inputs:

Setting Default
Project root path res://
Add-on root path res://addons/gotool_center
Database path user://gotool_center/gotool_center.sqlite3
User settings path user://gotool_center/settings.cfg

Native GDExtension Interface

GDExtension descriptor:

res://addons/gotool_center/bin/.gdextension

Entry symbol:

gotool_center_library_init

Compatibility minimum:

4.6

Current registered classes:

Class Input Output / Behavior
GodotProjectContext Project paths, scan state, service references, reports. Exposes shared context to editor UI and services.
GoToolProjectDatabase Database path, scan rows, query parameters. Stores and returns project scan metadata through SQLite.

Database Service Interface

Current native class:

GoToolProjectDatabase

Key method groups:

Method Group Input Output
Open/close Database path Open state or close completion.
Schema none Schema initialization/migration success.
Scan sessions Project path, add-on path, scan state Scan session ID and stored scan lifecycle state.
Insert rows Dictionaries for files, resources, scenes, scripts, dependencies, diagnostics Inserted row IDs or success state.
Query rows Project path, filter text, limit, offset, file ID Arrays/dictionaries of project metadata.
Maintenance none or SQL text for explain query plan Integrity results, query plan rows, or maintenance success state.
Error reporting none Last error code and last error message.

Database Output Location

Default SQLite database:

user://gotool_center/gotool_center.sqlite3

This database is local editor-tooling state. It is not intended as a multiplayer, server, or high-write-concurrency database.

Repository Layout

.
├── .clusterfuzzlite/                  # Fuzzing support
├── .github/
│   ├── dependabot.yml                 # Dependabot update configuration
│   └── workflows/                     # CI, build, security, release workflows
├── docs/                              # Project documentation
├── fuzz/                              # Fuzz targets
├── godot-cpp/                         # godot-cpp submodule
├── project/                           # Godot editor-plugin test project
│   ├── project.godot
│   └── addons/gotool_center/
│       ├── plugin.cfg
│       ├── gotool.gd
│       ├── bin/.gdextension
│       ├── services/
│       └── window_asset/
├── src/
│   ├── shared/                        # Context and GDExtension registration
│   └── project/                       # SQLite project database backend
├── thirdparty/sqlite/                 # Vendored SQLite amalgamation
├── LICENSE
├── SECURITY.md
└── SConstruct

Technology Stack

Category Technology Usage
Engine Godot 4.6.x Editor host and plugin runtime.
Native integration GDExtension Native backend without engine recompilation.
C++ bindings godot-cpp GDExtension C++ API.
UI and services GDScript Editor UI, scanner, configuration service.
Backend C++ Project context and SQLite database service.
Database SQLite 3.51.3 Local project metadata storage.
Build system SCons 4.4.0 Native library builds.
Formatting clang-format 20.1.8, gdtoolkit 4.5.0 CI style checks.
Security tooling Gitleaks, OSV, CodeQL, Grype, zizmor, OpenSSF Scorecard Secret, dependency, static, workflow, and supply-chain scanning.
Fuzzing ClusterFuzzLite Code-change and scheduled C++ fuzzing.
Dependency updates Dependabot Weekly checks for GitHub Actions, Git submodules, and Docker dependencies.

Requirements

End Users

  • Godot 4.6.x
  • A supported desktop platform:
    • Windows x86_64
    • Linux x86_64
    • macOS universal
  • GoTool Center add-on files
  • Matching native GDExtension binary for the target platform

Developers

  • Git
  • Python 3.12
  • SCons 4.4.0
  • Godot 4.6.x
  • Initialized godot-cpp submodule
  • Platform compiler:
    • Windows: Visual Studio 2022 MSVC
    • Linux: GCC or Clang
    • macOS: Apple Clang / Xcode command line tools

Development Workflow

Clone

git clone --recurse-submodules https://github.com/AlgorithMagic/GoToolCenter.git
cd GoToolCenter

If already cloned:

git submodule update --init --recursive

Install Tools

python -m pip install "scons==4.4.0"
python -m pip install "clang-format==20.1.8"
python -m pip install "gdtoolkit==4.5.0"

Open the Godot Project

godot --path project

Validate Locally

In Godot:

  1. Confirm the plugin loads.
  2. Confirm the GoTool Center main-screen tab appears.
  3. Run setup validation.
  4. Confirm the native backend is detected.
  5. Run a project scan.
  6. View database rows.
  7. Check editor output for warnings or errors.

Run Style Checks

cp godot-cpp/.clang-format .clang-format
clang-format --dry-run --Werror src/**/*.h src/**/*.cpp
gdformat --check project/addons/gotool_center

Build Instructions

Run builds from the repository root.

Windows

scons platform=windows target=template_debug arch=x86_64
scons platform=windows target=template_release arch=x86_64

Linux

scons platform=linux target=template_debug arch=x86_64
scons platform=linux target=template_release arch=x86_64

macOS

scons platform=macos target=template_debug arch=universal
scons platform=macos target=template_release arch=universal

Native outputs are written to:

project/addons/gotool_center/bin/

Feedback

Feedback is handled through GitHub Issues.

Bug Reports

Use a bug report when GoTool Center crashes, fails to load, scans incorrectly, writes incorrect data, reports incorrect diagnostics, or behaves differently from documented behavior.

A useful bug report should include:

  • GoTool Center version, release, or commit hash
  • Godot version
  • operating system and CPU architecture
  • whether the build is template_debug or template_release
  • steps to reproduce
  • expected behavior
  • actual behavior
  • relevant editor output, logs, screenshots, or minimal project files
  • whether the native backend loaded successfully
  • whether the issue affects scanning, configuration, SQLite, UI, export, or GDExtension loading

Do not include private project files, secrets, credentials, or personal data unless they are fully redacted.

Enhancement Requests

Use an enhancement request for new features, workflow improvements, UI changes, scanner improvements, project-health metrics, JSON/data conversion features, diagnostics, or integrations.

A useful enhancement request should include:

  • the problem being solved
  • the user workflow affected
  • expected inputs
  • expected outputs
  • why existing behavior is insufficient
  • any relevant Godot project examples
  • compatibility or migration concerns

Security Reports

Do not open public issues for vulnerabilities.

See:

SECURITY.md

Contributing

GoTool Center uses pull requests for contributions.

Contribution Process

  1. Open or find an issue describing the change.
  2. Fork the repository.
  3. Create a focused branch from master.
  4. Make the smallest maintainable change that solves the root problem.
  5. Keep unrelated formatting, dependency updates, and feature work separate.
  6. Run local build and style checks.
  7. Update documentation for public behavior or API changes.
  8. Open a pull request against master.
  9. Describe the problem, solution, affected systems, testing performed, and any known limitations.
  10. Address review feedback before merge.

Acceptable Contributions

Acceptable contributions should:

  • be scoped to one fix, feature, or documentation update
  • preserve dependency pinning
  • keep editor-only and runtime behavior separated
  • avoid committing generated build outputs
  • avoid broad rewrites without prior discussion
  • validate external input and file paths
  • avoid unsafe native ownership or lifetime assumptions
  • include clear validation steps
  • update reference documentation when external interfaces change

Required Coding Standards

GDScript:

  • use explicit static typing
  • prefer var name: Type = value
  • avoid inferred declarations such as var name := value
  • keep EditorPlugin scripts focused on lifecycle, registration, and cleanup
  • move reusable logic into services or native classes
  • keep editor scripts @tool only when editor execution is required

C++:

  • use GDCLASS for Godot-exposed classes
  • bind exposed methods through _bind_methods()
  • use Godot-facing types at bound API boundaries
  • use Ref<T> for RefCounted and Resource ownership
  • avoid retaining raw Object or Node pointers unless lifetime is guaranteed
  • keep STL internal and out of bound Godot APIs
  • treat undefined behavior, dangling references, invalid casts, and memory corruption as unacceptable

Formatting:

cp godot-cpp/.clang-format .clang-format
clang-format --dry-run --Werror src/**/*.h src/**/*.cpp
gdformat --check project/addons/gotool_center

CI, Fuzzing, and OpenSSF Readiness

GoTool Center is structured to support OpenSSF Scorecard checks and supply-chain review.

Area Repository Evidence / Policy
Security policy SECURITY.md documents supported versions, private reporting, scope, response expectations, sensitive data handling, and disclosure policy.
License LICENSE declares MIT licensing.
CI tests ci.yml builds and validates the project on push, pull request, manual dispatch, and release tag workflows.
Fuzzing fuzz.yml runs ClusterFuzzLite code-change fuzzing on pull requests and batch fuzzing on schedule/manual dispatch.
Dependabot .github/dependabot.yml is configured for weekly update checks for GitHub Actions, Git submodules, and Docker dependencies.
SAST CodeQL analyzes C++ code.
Dependency scanning OSV and Dependency Review are used to detect vulnerable dependencies.
Secret scanning Gitleaks scans the repository for committed secrets.
Workflow linting actionlint validates GitHub Actions workflows.
Workflow security zizmor scans GitHub Actions security posture.
Pinned GitHub Actions CI enforces full 40-character SHA pins for external actions.
Token permissions Workflows use scoped permissions instead of broad defaults.
SBOM CI generates an SPDX SBOM.
Vulnerability scanning Grype scans repository contents and generated SBOM data.
Build provenance CI attests generated build artifacts.
Release automation Tagged v* releases publish native binaries after checks pass.
Maintained status Active development targets the master branch and current tagged releases.
Dependency pinning Build, formatting, scanning, and action dependencies are pinned.

OpenSSF-Related Repository Metadata

Field Value
Repository AlgorithMagic/GoToolCenter
Package URL pkg:github/AlgorithMagic/GoToolCenter
Proposed CPE 2.3 cpe:2.3:a:algorithmagic:gotool_center:*:*:*:*:*:godot:*:*
License MIT
Primary ecosystem Godot editor plugin / GDExtension
Primary languages GDScript, C++, C
Default branch master
Supported branch master / active development branch
Release tags v*

Maintainer Security Expectations

Maintainers should keep the following enabled or enforced where possible:

  • branch protection for the default branch
  • required pull request review before merge
  • required CI checks before merge
  • restricted workflow token permissions
  • Dependabot update checks
  • private vulnerability reporting when available
  • signed or attested release artifacts
  • no committed generated binaries unless release-packaging policy explicitly changes

Dependency Pinning

Dependency pinning is required for reproducible builds and supply-chain safety.

Dependency Pin
Godot 4.6.x target
GDExtension compatibility 4.6 minimum
godot-cpp repository submodule commit
SQLite 3.51.3
Python 3.12
SCons 4.4.0
clang-format 20.1.8
gdtoolkit 4.5.0
GitHub Actions full 40-character SHA pins

Rules:

  • Do not use floating versions in CI.
  • Do not use unpinned GitHub Actions.
  • Keep godot-cpp pinned through the submodule commit.
  • Keep vendored dependencies under thirdparty/.
  • Do not mix dependency updates with unrelated feature work.
  • Rebuild all supported native targets after dependency changes.

godot-cpp Compatibility Note

The project currently targets Godot/GDExtension 4.6, while .gitmodules points godot-cpp at branch 4.5.

Before a stable release, this should be reviewed and either updated to a Godot 4.6-compatible pin or documented as an intentional compatibility baseline.

Database and Configuration

Default database path:

user://gotool_center/gotool_center.sqlite3

SQLite source:

thirdparty/sqlite/sqlite3.c
thirdparty/sqlite/sqlite3.h

Project-scoped settings are stored under:

gotool_center/config/

User-scoped settings are stored at:

user://gotool_center/settings.cfg

Generated Files

Generated files and local artifacts are intentionally ignored.

Examples:

project/.godot/
.sconsign.dblite
.scons_cache/
*.os
*.obj
project/addons/gotool_center/bin/*.dll
project/addons/gotool_center/bin/*.so
project/addons/gotool_center/bin/*.dylib
project/addons/gotool_center/bin/*.lib
project/addons/gotool_center/bin/*.pdb
.vs/
.vscode/
build/
out/
cmake-build-*/

Native binaries should be regenerated locally or downloaded from CI/release artifacts.

Security

See:

SECURITY.md

Do not open public issues containing vulnerability details.

Security-sensitive areas include:

  • file parsing
  • path normalization
  • project scanning
  • configuration loading
  • database access
  • external tool integration
  • native C++ memory safety
  • GDExtension loading
  • unintended disclosure of local project data

License

GoTool Center is licensed under the MIT License.

See:

LICENSE

Third-party components remain under their own licenses, including Godot Engine, godot-cpp, SQLite, CI actions, and development tools.

About

No description, website, or topics provided.

Resources

Readme

License

MIT license

Security policy

Security policy
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages