godot-input-map-auditor 0.1.0__tar.gz

godot_input_map_auditor-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Godot Input Map Auditor contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

godot_input_map_auditor-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: godot-input-map-auditor
+Version: 0.1.0
+Summary: Audit Godot input maps for device coverage, duplicate bindings, and generated references.
+Author: Godot Input Map Auditor contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-input-map-auditor
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,input,touch,gamepad,ci,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Godot Input Map Auditor
+
+Audit Godot input actions for keyboard, mouse, gamepad, and touch readiness, then generate input reference docs and strongly named GDScript constants.
+
+This is a small CI-friendly tool for projects where input coverage can drift across desktop, controller, and mobile targets.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-input-map-auditor
+```
+
+## Quick Start
+
+```powershell
+godot-input-audit C:\Projects\MyGame --require keyboard,touch
+godot-input-audit . --write-docs docs\INPUT_REFERENCE.md
+godot-input-audit . --generate-gd scripts\generated\input_actions.gd
+godot-input-audit . --format json --output input-report.json
+```
+
+Run against the sample project:
+
+```powershell
+godot-input-audit examples\tiny-godot-project --fail-on none
+```
+
+## What It Checks
+
+- Parses the `[input]` section in `project.godot`.
+- Classifies `InputEventKey`, mouse, joypad, and screen-touch event classes.
+- Reports actions missing required device families.
+- Reports duplicate normalized bindings across actions.
+- Generates `INPUT_REFERENCE.md`.
+- Generates optional `InputActions` GDScript constants.
+
+## Documentation
+
+- [Device classification](docs/DEVICE_RULES.md)
+- [Rule reference](docs/RULE_REFERENCE.md)
+- [Generated output](docs/GENERATED_OUTPUT.md)
+- [Touch readiness](docs/TOUCH_READINESS.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-input-audit examples\tiny-godot-project --require keyboard --fail-on none
+```
+
+Examples and generated docs use generic action names so the repository can be published safely.

godot_input_map_auditor-0.1.0/README.md

@@ -0,0 +1,59 @@
+# Godot Input Map Auditor
+
+Audit Godot input actions for keyboard, mouse, gamepad, and touch readiness, then generate input reference docs and strongly named GDScript constants.
+
+This is a small CI-friendly tool for projects where input coverage can drift across desktop, controller, and mobile targets.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-input-map-auditor
+```
+
+## Quick Start
+
+```powershell
+godot-input-audit C:\Projects\MyGame --require keyboard,touch
+godot-input-audit . --write-docs docs\INPUT_REFERENCE.md
+godot-input-audit . --generate-gd scripts\generated\input_actions.gd
+godot-input-audit . --format json --output input-report.json
+```
+
+Run against the sample project:
+
+```powershell
+godot-input-audit examples\tiny-godot-project --fail-on none
+```
+
+## What It Checks
+
+- Parses the `[input]` section in `project.godot`.
+- Classifies `InputEventKey`, mouse, joypad, and screen-touch event classes.
+- Reports actions missing required device families.
+- Reports duplicate normalized bindings across actions.
+- Generates `INPUT_REFERENCE.md`.
+- Generates optional `InputActions` GDScript constants.
+
+## Documentation
+
+- [Device classification](docs/DEVICE_RULES.md)
+- [Rule reference](docs/RULE_REFERENCE.md)
+- [Generated output](docs/GENERATED_OUTPUT.md)
+- [Touch readiness](docs/TOUCH_READINESS.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-input-audit examples\tiny-godot-project --require keyboard --fail-on none
+```
+
+Examples and generated docs use generic action names so the repository can be published safely.

godot_input_map_auditor-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "godot-input-map-auditor"
+version = "0.1.0"
+description = "Audit Godot input maps for device coverage, duplicate bindings, and generated references."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Godot Input Map Auditor contributors" }]
+keywords = ["godot", "input", "touch", "gamepad", "ci", "gamedev"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Utilities"
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-input-map-auditor"
+Issues = "https://github.com/NonniGB/godot-production-toolkit/issues"
+
+[project.scripts]
+godot-input-audit = "godot_input_auditor.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

godot_input_map_auditor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

godot_input_map_auditor-0.1.0/src/godot_input_auditor/__init__.py

@@ -0,0 +1,3 @@
+"""Godot input map audit tooling."""
+
+__version__ = "0.1.0"

godot_input_map_auditor-0.1.0/src/godot_input_auditor/__main__.py

@@ -0,0 +1,5 @@
+from .cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()

godot_input_map_auditor-0.1.0/src/godot_input_auditor/audit.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+from .models import Finding, InputAction
+
+
+def evaluate_actions(actions: list[InputAction], required_devices: set[str]) -> list[Finding]:
+    findings: list[Finding] = []
+    if not actions:
+        return [
+            Finding(
+                rule_id="input_map_empty",
+                severity="warning",
+                action=None,
+                message="No input actions were found in the [input] section.",
+            )
+        ]
+
+    for action in actions:
+        if not action.events:
+            findings.append(
+                Finding(
+                    rule_id="action_has_no_events",
+                    severity="warning",
+                    action=action.name,
+                    message=f"Input action '{action.name}' has no bound events.",
+                )
+            )
+        missing = sorted(required_devices - action.devices)
+        if missing:
+            findings.append(
+                Finding(
+                    rule_id="missing_required_device",
+                    severity="error",
+                    action=action.name,
+                    message=f"Input action '{action.name}' is missing required device(s): {', '.join(missing)}.",
+                )
+            )
+
+    findings.extend(_duplicate_binding_findings(actions))
+    return findings
+
+
+def _duplicate_binding_findings(actions: list[InputAction]) -> list[Finding]:
+    by_signature: dict[str, list[str]] = defaultdict(list)
+    for action in actions:
+        for event in action.events:
+            if event.signature:
+                by_signature[event.signature].append(action.name)
+
+    findings: list[Finding] = []
+    for signature, action_names in sorted(by_signature.items()):
+        unique_names = sorted(set(action_names))
+        if len(unique_names) > 1:
+            findings.append(
+                Finding(
+                    rule_id="duplicate_binding",
+                    severity="warning",
+                    action=None,
+                    message=(
+                        f"Binding '{signature}' is used by multiple actions: "
+                        f"{', '.join(unique_names)}."
+                    ),
+                )
+            )
+    return findings

godot_input_map_auditor-0.1.0/src/godot_input_auditor/cli.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .audit import evaluate_actions
+from .input_parser import parse_input_map
+from .models import Finding
+from .reporting import (
+    render_gdscript_constants,
+    render_json_report,
+    render_markdown_reference,
+    render_sarif_report,
+    render_text_report,
+)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    project = Path(args.project)
+    project_file = project if project.name == "project.godot" else project / "project.godot"
+
+    if not project_file.exists():
+        actions = []
+        findings = [
+            Finding(
+                rule_id="missing_project_godot",
+                severity="error",
+                action=None,
+                message="project.godot was not found.",
+            )
+        ]
+    else:
+        actions = parse_input_map(project_file.read_text(encoding="utf-8"))
+        findings = evaluate_actions(actions, required_devices=_parse_required(args.require))
+
+    if args.write_docs:
+        path = Path(args.write_docs)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_markdown_reference(actions), encoding="utf-8")
+
+    if args.generate_gd:
+        path = Path(args.generate_gd)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(render_gdscript_constants(actions), encoding="utf-8")
+
+    if args.format == "json":
+        rendered = render_json_report(actions, findings)
+    elif args.format == "sarif":
+        rendered = render_sarif_report(actions, findings)
+    else:
+        rendered = render_text_report(actions, findings)
+    if args.output:
+        output = Path(args.output)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(rendered + "\n", encoding="utf-8")
+    else:
+        print(rendered)
+
+    return _exit_code(findings, args.fail_on)
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="godot-input-audit",
+        description="Audit Godot input actions for device coverage and duplicate bindings.",
+    )
+    parser.add_argument("--version", action="version", version="godot-input-audit 0.1.0")
+    parser.add_argument("project", help="Godot project directory or project.godot file.")
+    parser.add_argument(
+        "--require",
+        default="",
+        help="Comma-separated device families every action should support, e.g. keyboard,touch.",
+    )
+    parser.add_argument("--format", choices=["text", "json", "sarif"], default="text")
+    parser.add_argument("--output", help="Write report to a file instead of stdout.")
+    parser.add_argument("--write-docs", help="Write Markdown input reference.")
+    parser.add_argument("--generate-gd", help="Write GDScript constants file.")
+    parser.add_argument("--fail-on", choices=["warning", "error", "none"], default="warning")
+    return parser
+
+
+def _parse_required(raw: str) -> set[str]:
+    return {part.strip() for part in raw.split(",") if part.strip()}
+
+
+def _exit_code(findings: list[Finding], fail_on: str) -> int:
+    if fail_on == "none":
+        return 0
+    severities = {finding.severity for finding in findings}
+    if fail_on == "error":
+        return 1 if "error" in severities else 0
+    return 1 if ("error" in severities or "warning" in severities) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

godot_input_map_auditor-0.1.0/src/godot_input_auditor/input_parser.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import re
+
+from .models import InputAction, InputEvent
+
+SECTION_RE = re.compile(r"^\[([^\]]+)\]$")
+EVENT_RE = re.compile(r"Object\((InputEvent[A-Za-z0-9_]+)(.*?)\)", re.DOTALL)
+
+
+def parse_input_map(project_godot_content: str) -> list[InputAction]:
+    actions: list[InputAction] = []
+    in_input_section = False
+    current_name: str | None = None
+    current_lines: list[str] = []
+    brace_depth = 0
+
+    for raw_line in project_godot_content.splitlines():
+        line = raw_line.strip()
+        section = SECTION_RE.match(line)
+        if section:
+            if current_name is not None:
+                actions.append(_parse_action(current_name, "\n".join(current_lines)))
+                current_name = None
+                current_lines = []
+                brace_depth = 0
+            in_input_section = section.group(1) == "input"
+            continue
+
+        if not in_input_section or not line or line.startswith(";") or line.startswith("#"):
+            continue
+
+        if current_name is None:
+            if "=" not in line:
+                continue
+            name, rest = line.split("=", 1)
+            current_name = name.strip().strip('"')
+            current_lines = [rest]
+            brace_depth = rest.count("{") - rest.count("}")
+            if brace_depth <= 0:
+                actions.append(_parse_action(current_name, "\n".join(current_lines)))
+                current_name = None
+                current_lines = []
+            continue
+
+        current_lines.append(line)
+        brace_depth += line.count("{") - line.count("}")
+        if brace_depth <= 0:
+            actions.append(_parse_action(current_name, "\n".join(current_lines)))
+            current_name = None
+            current_lines = []
+            brace_depth = 0
+
+    if current_name is not None:
+        actions.append(_parse_action(current_name, "\n".join(current_lines)))
+
+    return actions
+
+
+def _parse_action(name: str, body: str) -> InputAction:
+    events = []
+    for match in EVENT_RE.finditer(body):
+        event_type = match.group(1)
+        event_body = match.group(2)
+        device = _classify_event(event_type)
+        events.append(InputEvent(event_type=event_type, device=device, signature=_signature(event_type, event_body)))
+    return InputAction(name=name, events=events)
+
+
+def _classify_event(event_type: str) -> str:
+    if event_type == "InputEventKey":
+        return "keyboard"
+    if event_type in {"InputEventMouseButton", "InputEventMouseMotion"}:
+        return "mouse"
+    if event_type in {"InputEventJoypadButton", "InputEventJoypadMotion"}:
+        return "gamepad"
+    if event_type in {"InputEventScreenTouch", "InputEventScreenDrag", "InputEventGesture"}:
+        return "touch"
+    return "unknown"
+
+
+def _signature(event_type: str, event_body: str) -> str:
+    if event_type == "InputEventKey":
+        return f"keyboard:key:{_field(event_body, 'physical_keycode') or _field(event_body, 'keycode')}"
+    if event_type == "InputEventMouseButton":
+        return f"mouse:button:{_field(event_body, 'button_index')}"
+    if event_type == "InputEventJoypadButton":
+        return f"gamepad:button:{_field(event_body, 'button_index')}"
+    if event_type == "InputEventJoypadMotion":
+        return f"gamepad:axis:{_field(event_body, 'axis')}"
+    if event_type in {"InputEventScreenTouch", "InputEventScreenDrag", "InputEventGesture"}:
+        return f"touch:index:{_field(event_body, 'index') or 'any'}"
+    return f"{event_type}:{' '.join(event_body.split())}"
+
+
+def _field(event_body: str, name: str) -> str:
+    match = re.search(rf'"{re.escape(name)}"\s*:\s*([^,\)]+)', event_body)
+    if not match:
+        return ""
+    return match.group(1).strip().strip('"')

godot_input_map_auditor-0.1.0/src/godot_input_auditor/models.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class InputEvent:
+    event_type: str
+    device: str
+    signature: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {"event_type": self.event_type, "device": self.device, "signature": self.signature}
+
+
+@dataclass(frozen=True)
+class InputAction:
+    name: str
+    events: list[InputEvent] = field(default_factory=list)
+
+    @property
+    def devices(self) -> set[str]:
+        return {event.device for event in self.events if event.device != "unknown"}
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "name": self.name,
+            "devices": sorted(self.devices),
+            "events": [event.to_dict() for event in self.events],
+        }
+
+
+@dataclass(frozen=True)
+class Finding:
+    rule_id: str
+    severity: str
+    action: str | None
+    message: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "rule_id": self.rule_id,
+            "severity": self.severity,
+            "action": self.action,
+            "message": self.message,
+        }

godot_input_map_auditor-0.1.0/src/godot_input_auditor/reporting.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+import re
+
+from .models import Finding, InputAction
+
+
+def render_text_report(actions: list[InputAction], findings: list[Finding]) -> str:
+    lines = [
+        "Godot Input Map Auditor",
+        f"Scanned {len(actions)} action(s): {len(findings)} finding(s).",
+    ]
+    for action in actions:
+        devices = ", ".join(sorted(action.devices)) or "none"
+        lines.append(f"- {action.name}: {devices} ({len(action.events)} event(s))")
+    if findings:
+        for finding in findings:
+            lines.append(f"[{finding.severity.upper()}] {finding.rule_id}: {finding.message}")
+    else:
+        lines.append("No findings.")
+    return "\n".join(lines)
+
+
+def render_json_report(actions: list[InputAction], findings: list[Finding]) -> str:
+    payload = {
+        "tool": "godot-input-map-auditor",
+        "summary": {
+            "actions": len(actions),
+            "findings": len(findings),
+            "errors": sum(1 for finding in findings if finding.severity == "error"),
+            "warnings": sum(1 for finding in findings if finding.severity == "warning"),
+        },
+        "actions": [action.to_dict() for action in actions],
+        "findings": [finding.to_dict() for finding in findings],
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def render_sarif_report(actions: list[InputAction], findings: list[Finding]) -> str:
+    rules = {}
+    results = []
+    for finding in findings:
+        rules.setdefault(
+            finding.rule_id,
+            {
+                "id": finding.rule_id,
+                "name": finding.rule_id,
+                "shortDescription": {"text": finding.message},
+            },
+        )
+        results.append(
+            {
+                "ruleId": finding.rule_id,
+                "level": _sarif_level(finding.severity),
+                "message": {"text": finding.message},
+                "locations": [
+                    {
+                        "physicalLocation": {"artifactLocation": {"uri": "project.godot"}},
+                        "logicalLocations": [{"name": finding.action or "input"}],
+                    }
+                ],
+            }
+        )
+    payload = {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "godot-input-map-auditor",
+                        "rules": list(rules.values()),
+                    }
+                },
+                "results": results,
+            }
+        ],
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def render_markdown_reference(actions: list[InputAction]) -> str:
+    lines = [
+        "# Input Reference",
+        "",
+        "| Action | Devices | Events |",
+        "|---|---|---:|",
+    ]
+    for action in sorted(actions, key=lambda item: item.name):
+        devices = ", ".join(sorted(action.devices)) or "none"
+        lines.append(f"| {action.name} | {devices} | {len(action.events)} |")
+    if not actions:
+        lines.append("| none | none | 0 |")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def render_gdscript_constants(actions: list[InputAction]) -> str:
+    lines = [
+        "class_name InputActions",
+        "",
+        "# Generated by godot-input-map-auditor.",
+    ]
+    for action in sorted(actions, key=lambda item: item.name):
+        lines.append(f'const {_constant_name(action.name)} = "{action.name}"')
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _constant_name(action: str) -> str:
+    value = re.sub(r"[^A-Za-z0-9]+", "_", action).strip("_").upper()
+    if not value:
+        return "ACTION"
+    if value[0].isdigit():
+        return f"ACTION_{value}"
+    return value
+
+
+def _sarif_level(severity: str) -> str:
+    if severity == "error":
+        return "error"
+    if severity == "warning":
+        return "warning"
+    return "note"

godot_input_map_auditor-0.1.0/src/godot_input_map_auditor.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: godot-input-map-auditor
+Version: 0.1.0
+Summary: Audit Godot input maps for device coverage, duplicate bindings, and generated references.
+Author: Godot Input Map Auditor contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-input-map-auditor
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,input,touch,gamepad,ci,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Godot Input Map Auditor
+
+Audit Godot input actions for keyboard, mouse, gamepad, and touch readiness, then generate input reference docs and strongly named GDScript constants.
+
+This is a small CI-friendly tool for projects where input coverage can drift across desktop, controller, and mobile targets.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-input-map-auditor
+```
+
+## Quick Start
+
+```powershell
+godot-input-audit C:\Projects\MyGame --require keyboard,touch
+godot-input-audit . --write-docs docs\INPUT_REFERENCE.md
+godot-input-audit . --generate-gd scripts\generated\input_actions.gd
+godot-input-audit . --format json --output input-report.json
+```
+
+Run against the sample project:
+
+```powershell
+godot-input-audit examples\tiny-godot-project --fail-on none
+```
+
+## What It Checks
+
+- Parses the `[input]` section in `project.godot`.
+- Classifies `InputEventKey`, mouse, joypad, and screen-touch event classes.
+- Reports actions missing required device families.
+- Reports duplicate normalized bindings across actions.
+- Generates `INPUT_REFERENCE.md`.
+- Generates optional `InputActions` GDScript constants.
+
+## Documentation
+
+- [Device classification](docs/DEVICE_RULES.md)
+- [Rule reference](docs/RULE_REFERENCE.md)
+- [Generated output](docs/GENERATED_OUTPUT.md)
+- [Touch readiness](docs/TOUCH_READINESS.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-input-audit examples\tiny-godot-project --require keyboard --fail-on none
+```
+
+Examples and generated docs use generic action names so the repository can be published safely.

godot_input_map_auditor-0.1.0/src/godot_input_map_auditor.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/godot_input_auditor/__init__.py
+src/godot_input_auditor/__main__.py
+src/godot_input_auditor/audit.py
+src/godot_input_auditor/cli.py
+src/godot_input_auditor/input_parser.py
+src/godot_input_auditor/models.py
+src/godot_input_auditor/reporting.py
+src/godot_input_map_auditor.egg-info/PKG-INFO
+src/godot_input_map_auditor.egg-info/SOURCES.txt
+src/godot_input_map_auditor.egg-info/dependency_links.txt
+src/godot_input_map_auditor.egg-info/entry_points.txt
+src/godot_input_map_auditor.egg-info/top_level.txt
+tests/test_audit.py
+tests/test_cli.py
+tests/test_parser.py
+tests/test_reporting.py

godot_input_map_auditor-0.1.0/src/godot_input_map_auditor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

godot_input_map_auditor-0.1.0/src/godot_input_map_auditor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+godot-input-audit = godot_input_auditor.cli:entrypoint

godot_input_map_auditor-0.1.0/src/godot_input_map_auditor.egg-info/top_level.txt

@@ -0,0 +1 @@
+godot_input_auditor

godot_input_map_auditor-0.1.0/tests/test_audit.py

@@ -0,0 +1,40 @@
+import unittest
+
+from godot_input_auditor.audit import evaluate_actions
+from godot_input_auditor.models import InputAction, InputEvent
+
+
+class AuditTests(unittest.TestCase):
+    def test_missing_required_devices_are_reported(self) -> None:
+        action = InputAction(
+            name="confirm",
+            events=[InputEvent(event_type="InputEventKey", device="keyboard", signature="key:13")],
+        )
+
+        findings = evaluate_actions([action], required_devices={"keyboard", "touch"})
+
+        self.assertEqual(findings[0].rule_id, "missing_required_device")
+        self.assertIn("touch", findings[0].message)
+
+    def test_duplicate_bindings_are_reported(self) -> None:
+        actions = [
+            InputAction(
+                name="move_left",
+                events=[InputEvent(event_type="InputEventKey", device="keyboard", signature="key:65")],
+            ),
+            InputAction(
+                name="menu_left",
+                events=[InputEvent(event_type="InputEventKey", device="keyboard", signature="key:65")],
+            ),
+        ]
+
+        findings = evaluate_actions(actions, required_devices=set())
+
+        self.assertEqual(len(findings), 1)
+        self.assertEqual(findings[0].rule_id, "duplicate_binding")
+        self.assertIn("move_left", findings[0].message)
+        self.assertIn("menu_left", findings[0].message)
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_input_map_auditor-0.1.0/tests/test_cli.py

@@ -0,0 +1,80 @@
+from contextlib import redirect_stdout
+from io import StringIO
+import tempfile
+import unittest
+import json
+from pathlib import Path
+
+from godot_input_auditor.cli import main
+
+
+class CliTests(unittest.TestCase):
+    def test_cli_prints_version(self) -> None:
+        stdout = StringIO()
+
+        with self.assertRaises(SystemExit) as raised:
+            with redirect_stdout(stdout):
+                main(["--version"])
+
+        self.assertEqual(raised.exception.code, 0)
+        self.assertIn("godot-input-audit 0.1.0", stdout.getvalue())
+
+    def test_cli_generates_docs_and_constants(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            project = Path(tmp)
+            (project / "project.godot").write_text(
+                """
+[input]
+confirm={
+"events": [Object(InputEventKey,"physical_keycode":13)]
+}
+""",
+                encoding="utf-8",
+            )
+            docs = project / "docs" / "INPUT_REFERENCE.md"
+            constants = project / "scripts" / "generated" / "input_actions.gd"
+
+            exit_code = main(
+                [
+                    str(project),
+                    "--require",
+                    "keyboard,touch",
+                    "--write-docs",
+                    str(docs),
+                    "--generate-gd",
+                    str(constants),
+                ]
+            )
+
+            self.assertEqual(exit_code, 1)
+            self.assertIn("confirm", docs.read_text(encoding="utf-8"))
+            self.assertIn('CONFIRM = "confirm"', constants.read_text(encoding="utf-8"))
+
+    def test_cli_outputs_sarif_report(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            project = Path(tmp)
+            (project / "project.godot").write_text(
+                """
+[input]
+confirm={
+"events": [Object(InputEventKey,"physical_keycode":13)]
+}
+""",
+                encoding="utf-8",
+            )
+            stdout = StringIO()
+
+            with redirect_stdout(stdout):
+                exit_code = main([str(project), "--require", "keyboard,touch", "--format", "sarif", "--fail-on", "none"])
+
+            sarif = json.loads(stdout.getvalue())
+            self.assertEqual(exit_code, 0)
+            self.assertEqual(sarif["version"], "2.1.0")
+            driver = sarif["runs"][0]["tool"]["driver"]
+            self.assertEqual(driver["name"], "godot-input-map-auditor")
+            self.assertTrue(driver["rules"])
+            self.assertTrue(sarif["runs"][0]["results"])
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_input_map_auditor-0.1.0/tests/test_parser.py

@@ -0,0 +1,43 @@
+import unittest
+
+from godot_input_auditor.input_parser import parse_input_map
+
+
+PROJECT = """
+config_version=5
+
+[input]
+move_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"physical_keycode":65), Object(InputEventJoypadButton,"button_index":14)]
+}
+tap_select={
+"deadzone": 0.5,
+"events": [Object(InputEventScreenTouch,"index":0)]
+}
+zoom={
+"deadzone": 0.5,
+"events": [Object(InputEventMouseButton,"button_index":4)]
+}
+
+[rendering]
+renderer/rendering_method="mobile"
+"""
+
+
+class ParserTests(unittest.TestCase):
+    def test_parses_actions_and_classifies_device_families(self) -> None:
+        actions = parse_input_map(PROJECT)
+        by_name = {action.name: action for action in actions}
+
+        self.assertEqual(set(by_name), {"move_left", "tap_select", "zoom"})
+        self.assertEqual(by_name["move_left"].devices, {"keyboard", "gamepad"})
+        self.assertEqual(by_name["tap_select"].devices, {"touch"})
+        self.assertEqual(by_name["zoom"].devices, {"mouse"})
+
+    def test_returns_empty_list_when_input_section_missing(self) -> None:
+        self.assertEqual(parse_input_map("config_version=5\n"), [])
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_input_map_auditor-0.1.0/tests/test_reporting.py

@@ -0,0 +1,42 @@
+import json
+import unittest
+
+from godot_input_auditor.models import InputAction, InputEvent
+from godot_input_auditor.reporting import (
+    render_gdscript_constants,
+    render_json_report,
+    render_markdown_reference,
+)
+
+
+class ReportingTests(unittest.TestCase):
+    def test_markdown_reference_lists_actions_and_devices(self) -> None:
+        action = InputAction(
+            name="move_left",
+            events=[InputEvent(event_type="InputEventKey", device="keyboard", signature="key:65")],
+        )
+
+        markdown = render_markdown_reference([action])
+
+        self.assertIn("# Input Reference", markdown)
+        self.assertIn("| move_left | keyboard | 1 |", markdown)
+
+    def test_gdscript_constants_are_generated(self) -> None:
+        actions = [InputAction(name="move_left", events=[]), InputAction(name="ui_accept", events=[])]
+
+        gdscript = render_gdscript_constants(actions)
+
+        self.assertIn('const MOVE_LEFT = "move_left"', gdscript)
+        self.assertIn('const UI_ACCEPT = "ui_accept"', gdscript)
+
+    def test_json_report_contains_summary(self) -> None:
+        action = InputAction(name="tap", events=[InputEvent("InputEventScreenTouch", "touch", "touch:0")])
+
+        report = json.loads(render_json_report([action], []))
+
+        self.assertEqual(report["summary"]["actions"], 1)
+        self.assertEqual(report["actions"][0]["devices"], ["touch"])
+
+
+if __name__ == "__main__":
+    unittest.main()