prrevers 1.1.0__py3-none-any.whl

prrevers/__init__.py

@@ -0,0 +1,118 @@
+"""PRRevers — AI-ассистированный тулз реверс-инжиниринга для гейм-девов.
+
+Top-level пакет. Большинство пользователей взаимодействует с проектом
+через CLI (``prrevers``) или MCP-сервер. Публичный API поверхность
+намеренно мала на текущем этапе проекта; полный список — в
+docs/architecture.ru.md § «Публичный API».
+
+Экспорт публичных имён ленивый (PEP 562 ``__getattr__``): ``import prrevers``
+не тянет rich/pydantic, поэтому ``prrevers version`` и импорт метаданных
+остаются дешёвыми. Первое обращение к ``prrevers.detect`` и др. подгружает
+соответствующий подмодуль.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover — только для тайпчекера
+    # Имена объявлены для mypy и перечислены в ``__all__``; в рантайме их
+    # поставляет ``__getattr__`` ниже (PEP 562).
+    from prrevers.cache import Cache
+    from prrevers.citation import Citation
+    from prrevers.compare import ComparisonOutcome
+    from prrevers.detectors import detect
+    from prrevers.extractors import extract
+    from prrevers.llm import LLMBackend
+    from prrevers.models import (
+        AnalysisRequest,
+        AnalysisResult,
+        ComparisonDimension,
+        ComparisonResult,
+        DesignDocDiff,
+        DetectionResult,
+        Engine,
+        ExtractionResult,
+        GameArtifact,
+        GameProfile,
+        Platform,
+        Verdict,
+    )
+    from prrevers.pipeline import (
+        PipelineConfig,
+        PipelineResult,
+        run_pipeline,
+    )
+    from prrevers.session import Session
+
+__version__ = "1.1.0"
+
+#: Модуль и атрибут для каждого лениво экспортируемого публичного имени.
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    "detect": ("prrevers.detectors", "detect"),
+    "extract": ("prrevers.extractors", "extract"),
+    "run_pipeline": ("prrevers.pipeline", "run_pipeline"),
+    "PipelineConfig": ("prrevers.pipeline", "PipelineConfig"),
+    "PipelineResult": ("prrevers.pipeline", "PipelineResult"),
+    "Cache": ("prrevers.cache", "Cache"),
+    "Citation": ("prrevers.citation", "Citation"),
+    "LLMBackend": ("prrevers.llm", "LLMBackend"),
+    "Session": ("prrevers.session", "Session"),
+    "GameArtifact": ("prrevers.models", "GameArtifact"),
+    "AnalysisRequest": ("prrevers.models", "AnalysisRequest"),
+    "AnalysisResult": ("prrevers.models", "AnalysisResult"),
+    "DetectionResult": ("prrevers.models", "DetectionResult"),
+    "ExtractionResult": ("prrevers.models", "ExtractionResult"),
+    "Verdict": ("prrevers.models", "Verdict"),
+    "Platform": ("prrevers.models", "Platform"),
+    "Engine": ("prrevers.models", "Engine"),
+    "GameProfile": ("prrevers.models", "GameProfile"),
+    "ComparisonResult": ("prrevers.models", "ComparisonResult"),
+    "ComparisonDimension": ("prrevers.models", "ComparisonDimension"),
+    "DesignDocDiff": ("prrevers.models", "DesignDocDiff"),
+    "run_compare": ("prrevers.compare", "run_compare"),
+    "ComparisonOutcome": ("prrevers.compare", "ComparisonOutcome"),
+}
+
+__all__ = [
+    "__version__",
+    "AnalysisRequest",
+    "AnalysisResult",
+    "Cache",
+    "Citation",
+    "ComparisonDimension",
+    "ComparisonOutcome",
+    "ComparisonResult",
+    "DetectionResult",
+    "DesignDocDiff",
+    "Engine",
+    "ExtractionResult",
+    "GameArtifact",
+    "GameProfile",
+    "LLMBackend",
+    "PipelineConfig",
+    "PipelineResult",
+    "Platform",
+    "Session",
+    "run_compare",
+    "Verdict",
+    "detect",
+    "extract",
+    "run_pipeline",
+]
+
+
+def __getattr__(name: str) -> Any:
+    """Лениво импортировать и вернуть публичное имя (PEP 562)."""
+    try:
+        module_name, attr = _LAZY_EXPORTS[name]
+    except KeyError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+    import importlib
+
+    module = importlib.import_module(module_name)
+    return getattr(module, attr)
+
+
+def __dir__() -> list[str]:
+    return sorted(__all__)

prrevers/adapters/__init__.py

@@ -0,0 +1,302 @@
+"""Адаптеры движков: плагинная per-engine логика экстракции.
+
+В v0.0.1 ``detect_engine`` был гигантской цепочкой ``if/elif`` по движкам
+(Unity Mono / Unity IL2CPP / Unreal / Godot / GameMaker). Добавление нового
+движка означало правку ядра. Этот модуль заменяет этот паттерн плагинной
+архитектурой.
+
+Каждый адаптер — небольшой класс, который знает всё про ОДИН движок:
+
+- ``detect(source, container)`` — похож ли файл на наш движок?
+- ``extract_code(artifact, work_dir)`` — вытащить код (делегирует во
+  внешние тулзы через :class:`~prrevers.extractors.Extractor`).
+- ``extract_assets(artifact, work_dir)`` — вытащить ассеты.
+- ``recognize_mechanics(artifact)`` — вернуть список вероятных точек
+  входа в механики (имена классов, символы), на которых анализатору
+  сфокусироваться. Встроенные адаптеры его НЕ переопределяют: хардкод
+  «типичных имён классов» в реальных (часто обфусцированных) играх —
+  шум, а не сигнал; пусть анализатор исследует сам.
+
+Дискавери
+---------
+Адаптеры регистрируются через entry-point группу ``prrevers.adapters``
+в ``pyproject.toml``. Функция :func:`registry` лениво загружает их
+при первом обращении. Внешние пакеты могут добавлять новые движки без
+правки исходников PRRevers.
+
+Это тот же паттерн, что в ``pytest`` (plugins), ``mkdocs`` (themes)
+и ``sphinx`` (extensions). Стандартный способ сделать Python-проект
+расширяемым без форка.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from importlib.metadata import entry_points
+from pathlib import Path
+from typing import Any
+
+from prrevers.models import (
+    DetectionConfidence,
+    DetectionResult,
+    Engine,
+    ExtractionResult,
+    GameArtifact,
+    Platform,
+)
+
+__all__ = [
+    "AdapterRegistry",
+    "DetectionHint",
+    "EngineAdapter",
+    "registry",
+]
+
+
+@dataclass
+class DetectionHint:
+    """Один кусок evidence, который адаптер использует, чтобы распознать свой движок.
+
+    Адаптер возвращает список подсказок; ``detect_engine`` мержит их в
+    единый :class:`DetectionResult`. Подсказки человекочитаемы, чтобы
+    пользователь видел, *почему* движок был идентифицирован.
+
+    Поле ``engine`` позволяет одному адаптеру (напр. Unity) репортить
+    разные sub-движки (Mono vs IL2CPP) в зависимости от того, что найдено.
+    """
+
+    confidence: DetectionConfidence
+    message: str
+    engine: Engine = Engine.UNKNOWN
+    """Движок для репорта. По умолчанию ``UNKNOWN`` — вызывающий подставит
+    поле ``engine`` самого адаптера. Переопределите, когда один адаптер
+    обрабатывает несколько sub-движков (напр. Unity IL2CPP vs Mono)."""
+
+    extra: dict[str, Any] | None = None
+
+
+class EngineAdapter(ABC):
+    """Плагинная per-engine логика экстракции.
+
+    Один адаптер на движок. Подклассы устанавливают ``engine`` (значение
+    enum, который они обрабатывают) и реализуют ``detect`` + опциональные
+    методы экстракции.
+
+    Базовый класс намеренно минимален. Методы экстракции по умолчанию
+    бросают ``NotImplementedError``, потому что не каждый адаптер
+    поддерживает каждую операцию (напр. stub-адаптер для нового движка
+    может детектить, но ещё не экстрактить).
+    """
+
+    engine: Engine = Engine.UNKNOWN
+    """Движок, который этот адаптер обрабатывает. Устанавливается на подклассе."""
+
+    display_name: str = ""
+    """Человекочитаемое отображаемое имя; fallback на значение enum."""
+
+    @abstractmethod
+    def detect(
+        self,
+        source: Path,
+        container: DetectionResult,
+        platform: Platform,
+    ) -> DetectionHint | None:
+        """Инспектировать ``source`` и вернуть подсказку, если это наш движок.
+
+        Возвращает ``None``, когда этот адаптер уверен, что файл — НЕ его
+        движок. Возвращает :class:`DetectionHint` (с HIGH для совпадения
+        magic-bytes, MEDIUM для эвристик, LOW для догадок), когда это
+        может быть он.
+        """
+        raise NotImplementedError
+
+    def extract_code(
+        self, artifact: GameArtifact, work_dir: Path
+    ) -> ExtractionResult:  # pragma: no cover — abstract-ish
+        raise NotImplementedError(
+            f"адаптер для {self.engine} ещё не реализует extract_code",
+        )
+
+    def extract_assets(
+        self, artifact: GameArtifact, work_dir: Path
+    ) -> ExtractionResult:  # pragma: no cover — abstract-ish
+        raise NotImplementedError(
+            f"адаптер для {self.engine} ещё не реализует extract_assets",
+        )
+
+    def recognize_mechanics(self, artifact: GameArtifact) -> list[str]:
+        """Вернуть вероятные имена точек входа (классы, символы) для анализа.
+
+        Анализатор использует их как стартовый scope. Возврат пустого
+        списка (по умолчанию) означает «нет шорткатов — пусть LLM
+        исследует свободно».
+        """
+        return []
+
+
+class AdapterRegistry:
+    """Реестр плагинов для :class:`EngineAdapter` инстансов.
+
+    Загружает адаптеры из entry-point группы ``prrevers.adapters`` при
+    первом обращении. Адаптеры также можно регистрировать вручную
+    (для тестов).
+    """
+
+    ENTRY_POINT_GROUP = "prrevers.adapters"
+
+    def __init__(self) -> None:
+        self._adapters: dict[Engine, EngineAdapter] = {}
+        self._loaded = False
+
+    def register(self, adapter: EngineAdapter) -> None:
+        """Зарегистрировать адаптер вручную (минуя entry points)."""
+        if adapter.engine == Engine.UNKNOWN:
+            raise ValueError("адаптер обязан установить non-UNKNOWN engine")
+        self._adapters[adapter.engine] = adapter
+
+    def get(self, engine: Engine) -> EngineAdapter | None:
+        """Вернуть адаптер для ``engine`` или ``None``, если не зарегистрирован."""
+        self._ensure_loaded()
+        return self._adapters.get(engine)
+
+    def all(self) -> list[EngineAdapter]:
+        """Вернуть все зарегистрированные адаптеры."""
+        self._ensure_loaded()
+        return list(self._adapters.values())
+
+    def detect_engine(
+        self,
+        source: Path,
+        container: DetectionResult,
+        platform: Platform,
+    ) -> DetectionResult:
+        """Запустить ``detect`` каждого адаптера и выбрать сильнейшую подсказку.
+
+        Evidence сохраняет ВЕСЬ трейл, не только победителя: сообщение
+        победителя идёт первым, за ним — строки ``[<engine>] <msg>``
+        отклонённых подсказок. Так пользователь видит, почему победил
+        именно этот движок и что говорили конкуренты (те самые
+        «почему не Unreal» — без этого трейла провал детекции
+        необъясним).
+        """
+        self._ensure_loaded()
+        best_hint: DetectionHint | None = None
+        best_engine = Engine.UNKNOWN
+        best_adapter_engine = Engine.UNKNOWN
+        rejected: list[tuple[Engine, DetectionHint]] = []
+        for engine, adapter in self._adapters.items():
+            hint = adapter.detect(source, container, platform)
+            if hint is None:
+                continue
+            if best_hint is None or _stronger(hint.confidence, best_hint.confidence):
+                if best_hint is not None:
+                    rejected.append((best_adapter_engine, best_hint))
+                best_hint = hint
+                best_adapter_engine = engine
+                best_engine = hint.engine if hint.engine != Engine.UNKNOWN else engine
+            else:
+                rejected.append((engine, hint))
+
+        if best_hint is None:
+            return DetectionResult(
+                kind=container.kind,
+                engine=Engine.UNKNOWN,
+                confidence=DetectionConfidence.NONE,
+                evidence=["ни один адаптер не распознал этот движок"],
+            )
+
+        evidence = [best_hint.message]
+        for engine, hint in rejected:
+            evidence.append(
+                f"отклонено [{engine.value}, {hint.confidence.value}]: {hint.message}",
+            )
+
+        extras: dict[str, Any] = dict(best_hint.extra or {})
+        extras["adapter_engine"] = best_adapter_engine.value
+        return DetectionResult(
+            kind=container.kind,
+            engine=best_engine,
+            confidence=best_hint.confidence,
+            evidence=evidence,
+            extra=extras,
+        )
+
+    def _ensure_loaded(self) -> None:
+        if self._loaded:
+            return
+        self._loaded = True
+        # Загружаем встроенные адаптеры явно. Entry points пробуем
+        # потом, чтобы сторонние пакеты могли переопределять встроенные.
+        _load_builtin_adapters(self)
+        _load_entry_point_adapters(self)
+
+
+_CONFIDENCE_ORDER = {
+    DetectionConfidence.NONE: 0,
+    DetectionConfidence.LOW: 1,
+    DetectionConfidence.MEDIUM: 2,
+    DetectionConfidence.HIGH: 3,
+}
+
+
+def _stronger(a: DetectionConfidence, b: DetectionConfidence) -> bool:
+    return _CONFIDENCE_ORDER[a] > _CONFIDENCE_ORDER[b]
+
+
+def _load_builtin_adapters(reg: AdapterRegistry) -> None:
+    """Регистрируем адаптеры, поставляемые с PRRevers."""
+    from prrevers.adapters.custom import CustomEngineAdapter
+    from prrevers.adapters.gamemaker import GameMakerAdapter
+    from prrevers.adapters.godot import GodotAdapter
+    from prrevers.adapters.unity import UnityAdapter
+    from prrevers.adapters.unreal import UnrealAdapter
+    from prrevers.adapters.web import WebAdapter
+
+    for adapter_cls in (
+        UnityAdapter,
+        UnrealAdapter,
+        GodotAdapter,
+        GameMakerAdapter,
+        WebAdapter,
+        CustomEngineAdapter,
+    ):
+        instance = adapter_cls()
+        if instance.engine not in reg._adapters:
+            reg.register(instance)
+
+
+def _load_entry_point_adapters(reg: AdapterRegistry) -> None:
+    """Загружаем сторонние адаптеры, зарегистрированные через entry points.
+
+    На Python ≥ 3.10 ``entry_points(group=...)`` — современный API. На
+    более старых версиях ``entry_points()`` возвращал dict-like объект.
+    Мы ветвимся на TypeError, чтобы обработать оба, и трактуем legacy-ветку
+    как untyped — mypy видит только современную сигнатуру и путается
+    в legacy-fallback.
+    """
+    try:
+        eps = entry_points(group=AdapterRegistry.ENTRY_POINT_GROUP)
+    except TypeError:  # pragma: no cover — py < 3.10 only
+        legacy: Any = entry_points()
+        eps = legacy.get(AdapterRegistry.ENTRY_POINT_GROUP, [])
+    for ep in eps:
+        try:
+            adapter_cls = ep.load()
+        except Exception:
+            continue
+        if not isinstance(adapter_cls, type) or not issubclass(adapter_cls, EngineAdapter):
+            continue
+        instance = adapter_cls()
+        if instance.engine not in reg._adapters:
+            reg.register(instance)
+
+
+# Module-level singleton. Тесты могут сконструировать свой AdapterRegistry
+# и передать явно; production-код использует этот.
+_REGISTRY = AdapterRegistry()
+
+
+def registry() -> AdapterRegistry:
+    """Вернуть process-wide singleton реестра адаптеров."""
+    return _REGISTRY

prrevers/adapters/custom.py

@@ -0,0 +1,177 @@
+"""Адаптер кастомных движков: fingerprinting нативных бинарников (v0.7.0, п.4).
+
+«Кастомный C++ движок» — не безымянная тьма: у известных движков без
+собственного magic-формата есть СТРОКОВЫЕ маркеры в бинарнике — имена
+модулей, пути рантайма, неймспейсы. Адаптер сканирует бинарник
+потоково (чанки с перекрытием — маркер может лечь на границу) и
+сверяет с базой фингерпринтов.
+
+Честная шкала уверенности
+--------------------------
+
+- **HIGH** — два и более РАЗНЫХ маркера одного движка: совпадение двух
+  независимых строк случайно практически исключено (магия-эквивалент);
+- **MEDIUM** — один маркер: строка могла попасть в бинарник случайно
+  (например, упоминание в комментарии/ресурсе) — честно «похоже, но
+  не доказано»;
+- ничего не найдено — ``None`` (не наш движок — дорога остаётся за
+  UNKNOWN → нативный Ghidra-анализ пайплайна).
+
+``engine`` репортится как :attr:`Engine.CUSTOM
+<prrevers.models.Engine.CUSTOM>` — enum-значений на каждый движок нет
+и не будет (роадмап: «fingerprinting», не «поддержка Ren'Py»);
+фактическое имя движка едет в ``extra['engine_name']`` и в evidence.
+
+Экстракции для фингерпринтнутых движков в PRRevers пока нет (Ren'Py
+декомпилируется своим тулзом, RPG Maker — своим) — пайплайн честно
+отправляет их по нативной Ghidra-дороге (``_try_analyze_custom_native``
+принимает CUSTOM наравне с UNKNOWN), а имя движка попадает в вывод —
+пользователь видит, ЧТО искать дальше.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from prrevers.adapters import DetectionHint, EngineAdapter
+from prrevers.models import (
+    ArtifactKind,
+    DetectionConfidence,
+    DetectionResult,
+    Engine,
+    Platform,
+)
+
+__all__ = ["CustomEngineAdapter", "FINGERPRINTS"]
+
+#: Размер чанка чтения: 4 MiB — компромисс между числом syscall-ов и
+#: памятью (буфер чанка + перекрытие — константа при любом размере игры).
+_SCAN_CHUNK_BYTES = 4 * 1024 * 1024
+
+
+@dataclass(frozen=True)
+class _Fingerprint:
+    """Один известный кастомный движок и его строковые маркеры."""
+
+    name: str
+    markers: tuple[bytes, ...]
+
+
+#: База фингерпринтов: движки без magic-формата, чьи маркеры живут в
+#: нативном бинарнике. Маркеры специфичны (пути рантайма, имена модулей,
+#: неймспейсы) — коротких общих слов («game», «engine») здесь нет
+#: намеренно: ложные срабатывания хуже честного UNKNOWN.
+FINGERPRINTS: tuple[_Fingerprint, ...] = (
+    _Fingerprint(
+        name="Ren'Py",
+        markers=(b"Ren'Py", b"renpy/common/", b"renpy/display/"),
+    ),
+    _Fingerprint(
+        name="Cocos2d-x",
+        markers=(b"cocos2d-x", b"cocos2d::"),
+    ),
+    _Fingerprint(
+        name="MonoGame",
+        markers=(b"MonoGame", b"monogame"),
+    ),
+    _Fingerprint(
+        name="LÖVE (Love2D)",
+        markers=(b"love.filesystem", b"love.event", b"love.graphics"),
+    ),
+    _Fingerprint(
+        name="RPG Maker (RGSS)",
+        markers=(b"RGSS",),
+    ),
+    _Fingerprint(
+        name="Clickteam Fusion",
+        markers=(b"Clickteam",),
+    ),
+)
+
+#: Все маркеры одной плоскостью — для потокового сканирования.
+_ALL_MARKERS: tuple[bytes, ...] = tuple(marker for fp in FINGERPRINTS for marker in fp.markers)
+
+#: Самый длинный маркер: перекрытие чанков обязано его переживать.
+_MAX_MARKER_LEN = max(len(m) for m in _ALL_MARKERS)
+
+
+class CustomEngineAdapter(EngineAdapter):
+    """Детектит известные кастомные движки по строковым маркерам.
+
+    Сканирует только нативные бинарники (PE_EXE / PE_DLL / ELF_SO):
+    фингерпринты живущих в контейнерах движков покрываются своими
+    адаптерами (Unity / Godot / GameMaker / Web).
+    """
+
+    engine = Engine.CUSTOM
+    display_name = "Custom engine (fingerprinted)"
+
+    def detect(
+        self,
+        source: Path,
+        container: DetectionResult,
+        platform: Platform,
+    ) -> DetectionHint | None:
+        if container.kind not in {ArtifactKind.PE_EXE, ArtifactKind.PE_DLL, ArtifactKind.ELF_SO}:
+            return None
+
+        found = _scan_markers(source)
+        if not found:
+            return None
+
+        for fingerprint in FINGERPRINTS:
+            hits = [m for m in fingerprint.markers if m in found]
+            if not hits:
+                continue
+            shown = ", ".join(m.decode("ascii", errors="replace") for m in hits)
+            if len(hits) > 1:
+                return DetectionHint(
+                    confidence=DetectionConfidence.HIGH,
+                    message=(
+                        f"фингерпринт {fingerprint.name}: {len(hits)} независимых "
+                        f"маркера ({shown})"
+                    ),
+                    engine=Engine.CUSTOM,
+                    extra={"engine_name": fingerprint.name, "markers": shown},
+                )
+            return DetectionHint(
+                confidence=DetectionConfidence.MEDIUM,
+                message=f"фингерпринт {fingerprint.name}: один маркер ({shown})",
+                engine=Engine.CUSTOM,
+                extra={"engine_name": fingerprint.name, "markers": shown},
+            )
+        return None
+
+
+def _scan_markers(source: Path) -> frozenset[bytes]:
+    """Потоково найти маркеры в бинарнике (чанки с перекрытием).
+
+    Память — константа (один чанк + хвост перекрытия) при любом
+    размере игры: мультигигабайтные .exe читаются без разворачивания
+    в память (прецедент ``cache_key_from_path``). Маркер, лежащий на
+    границе чанков, не теряется: хвост длиной ``_MAX_MARKER_LEN - 1``
+    приписывается к следующему чанку.
+    """
+    found: set[bytes] = set()
+    pending = _ALL_MARKERS
+    try:
+        with source.open("rb") as fh:
+            tail = b""
+            while pending:
+                chunk = fh.read(_SCAN_CHUNK_BYTES)
+                if not chunk:
+                    break
+                data = tail + chunk if tail else chunk
+                for marker in pending:
+                    if marker in data:
+                        found.add(marker)
+                pending = tuple(m for m in pending if m not in found)
+                if len(data) >= _MAX_MARKER_LEN:
+                    tail = data[-(_MAX_MARKER_LEN - 1) :]
+    except OSError:
+        # Нечитаемый файл — не наш случай: пусть про неём говорят
+        # детектор контейнера и его honest-провал, а не пустой hint.
+        return frozenset()
+
+    return frozenset(found)

prrevers/adapters/gamemaker.py

@@ -0,0 +1,57 @@
+"""Адаптер GameMaker.
+
+Детектит GameMaker по расширению ``.win`` (Windows) или библиотеке
+``libYoYoGameRunner.so`` (Android). UndertaleModTool — канонический
+экстрактор; интеграция не реализована (не вошла ни в одну закрытую веху
+роадмапа — см. docs/ROADMAP.ru.md).
+"""
+
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path
+
+from prrevers.adapters import DetectionHint, EngineAdapter
+from prrevers.constants import GAMEMAKER_ANDROID_LIB, GAMEMAKER_WIN_SUFFIX
+from prrevers.models import (
+    ArtifactKind,
+    DetectionConfidence,
+    DetectionResult,
+    Engine,
+    Platform,
+)
+
+__all__ = ["GameMakerAdapter"]
+
+
+class GameMakerAdapter(EngineAdapter):
+    """Детектит GameMaker через .win суффикс или libYoYoGameRunner.so."""
+
+    engine = Engine.GAMEMAKER
+    display_name = "GameMaker"
+
+    def detect(
+        self,
+        source: Path,
+        container: DetectionResult,
+        platform: Platform,
+    ) -> DetectionHint | None:
+        suffix = source.suffix.lower()
+        if suffix == GAMEMAKER_WIN_SUFFIX:
+            return DetectionHint(
+                confidence=DetectionConfidence.HIGH,
+                message=f"суффикс {GAMEMAKER_WIN_SUFFIX} → GameMaker",
+            )
+
+        if container.kind == ArtifactKind.APK:
+            try:
+                with zipfile.ZipFile(source) as zf:
+                    names = set(zf.namelist())
+            except zipfile.BadZipFile:
+                return None
+            if any(GAMEMAKER_ANDROID_LIB in n for n in names):
+                return DetectionHint(
+                    confidence=DetectionConfidence.HIGH,
+                    message=f"APK содержит {GAMEMAKER_ANDROID_LIB}",
+                )
+        return None