Startup diagnostics: verify runtime / DLL / versions are ready.

Checks that the .NET runtime (CoreCLR) is loaded, the bundled ICSharpCode.Decompiler.dll is present in lib/, and returns version info for all components.

The asm_search_dirs field shows which directories the decompiler searches automatically for dependency resolution — typically the lib/ folder. The target DLL's own directory is also always searched.

Example::

check_env()
# Returns: {"python_version": "3.14.3", "decompiler_version": "9.0.0.7889", ...}

Returns: EnvInfo: Python version, .NET runtime version, decompiler version, and library directory status.

Decompile a whole .NET type to C# source (with comments).

The decompiler automatically resolves dependencies from the target DLL's own directory and the bundled lib/ folder, so asm_paths is almost never needed for typical Unity/Godot games.

Tip: use list_types first to discover available types, then pass the exact namespace.TypeName here.

Examples::

# Decompile an entire class
decompile_type(
    dll="Backend/GameData.dll",
    type_name="GameData.Domains.Character.Character",
)

# Decompile an enum
decompile_type(
    dll="Backend/GameData.dll",
    type_name="GameData.Domains.Combat.CombatCharacterStateType",
)

Args: dll (str): Absolute path to the assembly (.dll or .exe). type_name (str): Fully-qualified type name, case-sensitive, e.g. GameData.Domains.Taiwu.TaiwuDomain. asm_paths (list[str] | None): Extra directories for dependency resolution. The DLL's own folder and the bundled lib/ are searched automatically, so this can almost always be None. Only needed when a referenced assembly lives outside those paths.

Returns: DecompileResult: The decompiled C# source plus type/dll metadata.

Raises: DllNotFoundError: dll does not exist or is not readable. TypeNotFoundError: type_name was not found (check spelling/case). DecompilationFailedError: Decompiler encountered an internal error.

Decompile a single member (method/field/property/event/ctor) to C#.

Lighter than decompile_type — use this when you only need one method or property from a large type.

Tip: run get_type_summary first to see available member names.

Examples::

# Decompile a method
decompile_member(
    dll="Backend/GameData.dll",
    type_name="GameData.Domains.Character.Character",
    member_name="ChangeHealth",
)

# Decompile a constructor
decompile_member(
    dll="Managed/Assembly-CSharp.dll",
    type_name="Game.Views.Combat.ViewCombat",
    member_name=".ctor",
)

# Decompile a property getter
decompile_member(
    dll="Backend/GameData.dll",
    type_name="GameData.Domains.Combat.CombatCharacter",
    member_name="get_Name",
)

Args: dll (str): Absolute path to the assembly. type_name (str): Fully-qualified owning type name (case-sensitive). member_name (str): Simple member name, e.g. ToString, ChangeHealth, .ctor (constructor), get_Name. asm_paths (list[str] | None): Extra directories for dependency resolution. Almost always None — see decompile_type.

Returns: MemberDecompileResult: The member's C# source plus metadata.

Raises: DllNotFoundError: dll does not exist. TypeNotFoundError: type_name not found. MemberNotFoundError: member_name not found on the type. DecompilationFailedError: Internal decompiler error.

List types in an assembly, optionally filtered by namespace prefix.

The namespace filter is a prefix match: "GameData.Domains" matches GameData.Domains.Character, GameData.Domains.Combat, etc. Pass "" (default) to list all types — but beware that large games (e.g. Unity Assembly-CSharp.dll) may have 5000+ types.

Recommended exploration flow::

1. list_namespaces(dll)         → see available namespaces
2. list_types(dll, namespace="Foo")  → see types in that namespace
3. get_type_summary(dll, "Foo.Bar")  → inspect a type's members
4. decompile_type(dll, "Foo.Bar")    → get full C# source

Examples::

# All types in a DLL (may be large)
list_types(dll="Backend/GameData.dll")

# Only types under a specific namespace
list_types(
    dll="Backend/GameData.dll",
    namespace="GameData.Domains.Combat.Ai",
)

Args: dll (str): Absolute path to the assembly (.dll or .exe). namespace (str): Namespace prefix filter. "" lists all types. asm_paths (list[str] | None): Extra dependency dirs (almost never needed — see decompile_type).

Returns: TypeListResult: Matching types (name, namespace, base type, member counts) with total/filtered counts.

Raises: DllNotFoundError: dll does not exist or is not readable.

List distinct namespaces in an assembly with their type counts.

Use this as the first step when exploring an unknown game/mod DLL: it shows you what high-level modules exist (e.g. GameData.Domains.Combat, Game.Views.Building) and how many types each contains.

Example::

list_namespaces(dll="Backend/GameData.dll")
# Returns: [{"name": "GameData.Domains.Combat", "count": 177}, ...]

Args: dll (str): Absolute path to the assembly to inspect. asm_paths (list[str] | None): Extra dependency dirs (almost never needed — see decompile_type).

Returns: NamespaceListResult: Namespaces (sorted by name) and total type count.

Raises: DllNotFoundError: dll does not exist or is not readable.

Get a detailed member summary of a single type (public members only).

Shows all public methods, fields, properties, and events with their signatures. Use this to find the exact member name before calling decompile_member.

Example::

get_type_summary(
    dll="Backend/GameData.dll",
    type_name="GameData.Domains.Character.Character",
)
# Returns all ~800 public methods with their signatures

Args: dll (str): Absolute path to the assembly to inspect. type_name (str): Fully-qualified type name (case-sensitive), e.g. GameData.Domains.Character.Character. asm_paths (list[str] | None): Extra dependency dirs (almost never needed — see decompile_type).

Returns: TypeSummary: Base type, attributes, and public member lists (methods/fields/properties/events).

Raises: DllNotFoundError: dll does not exist. TypeNotFoundError: type_name not found (check spelling/case).

Search for symbols by name across one or more assemblies.

Matching is case-insensitive substring on the symbol name. You can search a single DLL or multiple at once — useful when you're not sure which assembly contains a type (e.g. ["GameData.dll", "Assembly-CSharp.dll"]).

Examples::

# Search all symbol kinds for "MakeLove" in one DLL
search_symbol(
    dlls=["Backend/GameData.dll"],
    query="MakeLove",
)

# Search only types named "Combat*" across multiple DLLs
search_symbol(
    dlls=[
        "Backend/GameData.dll",
        "Managed/Assembly-CSharp.dll",
    ],
    query="Combat",
    kind="type",
)

# Search only methods containing "ChangeHealth"
search_symbol(
    dlls=["Backend/GameData.dll"],
    query="ChangeHealth",
    kind="method",
)

Args: dlls (list[str]): One or more assembly paths to search. query (str): Case-insensitive substring to match against symbol names. kind (str): Category filter. One of: - "any" (default) — all categories - "type" — only type names - "method" — only method names - "field" — only field names - "property" — only property names - "event" — only event names asm_paths (list[str] | None): Extra dependency dirs (almost never needed — see decompile_type).

Returns: SearchResult: All matches across all DLLs (with owning type info for member matches).

Raises: InvalidArgumentError: If kind is not a valid category. DllNotFoundError: If any DLL in dlls does not exist.