Refactor tools and update CESDK submodule

- Consolidated memory tools into MemoryTool, ScanTool, AssemblyTool
- Use static CESDK.CESDK for cleaner syntax
- Update CESDK submodule with LuaExecutor and improved class APIs
- Add UI counter reset in reset_memory_scan
- Update copilot instructions for CESDK.Synchronize()

Author: Snufxander

.github/copilot-instructions.md

@@ -4,6 +4,13 @@
 
 Cheat Engine MCP Server — a C# plugin that exposes Cheat Engine functionality as MCP tools over SSE (Server-Sent Events) using the official [Model Context Protocol C# SDK](https://github.com/modelcontextprotocol/csharp-sdk).
 
+## Cheat Engine Lua API Reference
+
+The full CE Lua API documentation is at `C:\Program Files\Cheat Engine\celua.txt`. Always consult this file when:
+- Adding new CESDK wrapper methods or tools
+- Verifying correct Lua function names, parameters, and return types
+- Understanding CE object models (MemScan, FoundList, AddressList, MemoryRecord, etc.)
+
 ## Build and Test
 
 ```bash
@@ -31,25 +38,21 @@ Deploy: copy `ce-mcp.dll` from `bin/` to Cheat Engine plugins directory, enable
 
 All tools use `[McpServerToolType]` on the class and `[McpServerTool]` + `[Description]` on methods. Tools are static classes with static methods. Each returns anonymous objects with `success` boolean and either result data or `error` message.
 
-- **ProcessTool** — List processes, open by ID/name, get current process
-- **LuaExecutionTool** — Execute Lua scripts in CE with stack management
-- **MemoryReadTool** — Read memory (bytes, int32, int64, float, string)
-- **MemoryWriteTool** — Write memory values
-- **AOBScanTool** — Array of Bytes pattern scanning
-- **DisassembleTool** — Disassemble instructions at address
-- **AddressTool** — Resolve address expressions
+- **ProcessTool** — Process and thread management (list/open/get processes, list threads)
+- **MemoryTool** — Memory read and write (bytes, int8/16/32/64, float, double, string)
+- **ScanTool** — Memory scanning (AOB pattern scan, value scan with first/next, reset)
+- **AssemblyTool** — Disassembly and address resolution
+- **AddressListTool** — Cheat table CRUD operations (get/add/update/delete/clear records)
+- **LuaExecutionTool** — Execute arbitrary Lua scripts in CE with stack management
 - **ConversionTool** — String format conversion (MD5, ANSI/UTF8)
-- **ThreadListTool** — List process threads
-- **MemScanTool** — Memory value scanning with first/next scan pattern
-- **AddressListTool** — Cheat table CRUD operations
 
 ### SDK Layer (`CESDK/`)
 
-Git submodule — C# wrapper around Cheat Engine's Lua API. Key classes: `LuaEngine`, `MemoryAccess`, `Process`, `AOBScanner`, `Disassembler`, `MemScan`, `AddressList`.
+Git submodule — C# wrapper around Cheat Engine's Lua API. Key classes: `MemoryAccess`, `Process`, `AOBScanner`, `Disassembler`, `AddressResolver`, `MemScan`, `FoundList`, `AddressList`, `ThreadList`, `Converter`, `Speedhack`, `Debugger`, `SymbolWaiter`.
 
 ### Views (`src/Views/`)
 
-- **ConfigWindow.cs** — WPF config window (code-only, no XAML). Supports dark/light theme via `ThemeHelper`.
+- **ConfigWindow.xaml/.cs** — WPF config window. Supports dark/light theme via `ThemeHelper`.
 
 ## Adding New Tools
 
@@ -58,6 +61,7 @@ Git submodule — C# wrapper around Cheat Engine's Lua API. Key classes: `LuaEng
 3. Use `[Description]` on parameters for schema generation
 4. Return anonymous objects: `new { success = true, ... }` or `new { success = false, error = "..." }`
 5. Register in `McpServer.cs` via `.WithTools<Tools.YourTool>()`
+6. Consult `C:\Program Files\Cheat Engine\celua.txt` for correct Lua function signatures
 
 Example:
 ```csharp
@@ -80,26 +84,27 @@ public static class MyTool
 ## Code Style
 
 - C# with nullable reference types enabled, `TreatWarningsAsErrors`
-- Target: `net9.0-windows`, WPF enabled, x64 platform
+- Target: `net10.0-windows`, WPF enabled, x64 platform
 - Tools use static classes/methods, not instance-based
 - Wrap CE SDK calls in try-catch, always return structured response objects
 - Use proper Lua stack management (`GetTop`, `Pop`) when interacting with Lua
 
 ## Important Notes
 
 - **Lua stack**: Always clean up with `lua.Pop()` calls after reading values
-- **CE thread safety**: Use `CESDK.CESDK.Synchronize()` for operations that must run on CE's main thread (e.g., AddressList operations)
+- **CE thread safety**: Use `CESDK.Synchronize()` for operations that must run on CE's main thread (e.g., AddressList operations)
 - **Memory scanning**: Requires scan → `WaitTillDone()` → `foundList.Initialize()` sequence
 - **Dark mode**: UI adapts via Windows registry check (`ThemeHelper.IsInDarkMode()`)
 - Default server: `http://127.0.0.1:6300` with MCP SSE at `/sse`
+- **CE Lua API docs**: `C:\Program Files\Cheat Engine\celua.txt` — the authoritative reference for all CE Lua functions, objects, and their parameters
 
 ## CESDK Submodule
 
 The `CESDK/` directory is a git submodule providing the Cheat Engine SDK wrapper library:
 
 - **Core**: `CESDK.cs`, `CheatEnginePlugin.cs`, `PluginContext.cs`
-- **Lua**: `LuaEngine.cs` (high-level), `LuaNative.cs` (low-level C API)
-- **Memory**: `MemoryScanner.cs`, `ScanConfiguration.cs`, `ScanResults.cs`
-- **System**: `SystemInfo.cs`, `CEInterop.cs`
+- **Lua**: `LuaNative.cs` (low-level C API bindings)
+- **Classes**: `MemoryAccess`, `Process`, `AOBScanner`, `Disassembler`, `AddressResolver`, `MemScan`, `FoundList`, `AddressList`, `ThreadList`, `Converter`, `Speedhack`, `Debugger`, `SymbolWaiter`, `LuaLogger`
+- **Utils**: `LuaUtils.cs` (helper functions for Lua stack operations)
 
 Plugin pattern: inherit `CheatEnginePlugin`, implement `Name`/`OnEnable()`/`OnDisable()`, access Lua via `PluginContext.Lua`.

CESDK

@@ -38,15 +38,12 @@ public void Start(string baseUrl)
             .WithHttpTransport()
             .WithTools<Tools.ProcessTool>()
             .WithTools<Tools.LuaExecutionTool>()
-            .WithTools<Tools.MemoryReadTool>()
-            .WithTools<Tools.MemoryWriteTool>()
-            .WithTools<Tools.AobScanTool>()
-            .WithTools<Tools.DisassembleTool>()
-            .WithTools<Tools.AddressTool>()
+            .WithTools<Tools.MemoryTool>()
+            .WithTools<Tools.ScanTool>()
+            .WithTools<Tools.AssemblyTool>()
             .WithTools<Tools.ConversionTool>()
-            .WithTools<Tools.ThreadListTool>()
-            .WithTools<Tools.MemScanTool>()
-            .WithTools<Tools.AddressListTool>();
+            .WithTools<Tools.AddressListTool>()
+            .WithResources<Resources.ProcessResources>();
 
             builder.Logging.ClearProviders(); // Disable logging
             builder.WebHost.UseUrls(baseUrl);

src/McpServer.cs

@@ -0,0 +1,92 @@
+using System;
+using System.ComponentModel;
+using CESDK.Classes;
+using ModelContextProtocol.Server;
+
+namespace Resources
+{
+    /// <summary>
+    /// Process-related MCP resources. Resources represent readable state/data, unlike tools which perform actions.
+    /// </summary>
+    [McpServerResourceType]
+    public class ProcessResources
+    {
+        private ProcessResources() { }
+
+        [McpServerResource(
+            UriTemplate = "process://current",
+            Title = "Current Process"),
+         Description("Get information about the currently attached Cheat Engine process")]
+        public static string GetCurrentProcess()
+        {
+            try
+            {
+                int processId = Process.GetOpenedProcessID();
+
+                if (processId == 0)
+                {
+                    return System.Text.Json.JsonSerializer.Serialize(new
+                    {
+                        processId = 0,
+                        isOpen = false,
+                        processName = "",
+                        message = "No process is currently attached to Cheat Engine"
+                    });
+                }
+
+                string processName = "Unknown";
+                try
+                {
+                    var processDict = Process.GetProcessList();
+                    if (processDict.TryGetValue(processId, out var name))
+                        processName = name;
+                }
+                catch
+                {
+                    // If process list fails, just return "Unknown"
+                }
+
+                return System.Text.Json.JsonSerializer.Serialize(new
+                {
+                    processId,
+                    isOpen = true,
+                    processName,
+                    message = $"Attached to process: {processName} (PID: {processId})"
+                });
+            }
+            catch (Exception ex)
+            {
+                return System.Text.Json.JsonSerializer.Serialize(new
+                {
+                    error = ex.Message
+                });
+            }
+        }
+        [McpServerResource(
+            UriTemplate = "process://threads",
+            Title = "Thread List"),
+         Description("Get all threads in the currently opened process")]
+        public static string GetThreadList()
+        {
+            try
+            {
+                var threadList = new ThreadList();
+                threadList.Refresh();
+                var threads = threadList.GetAllThreadIds();
+                return System.Text.Json.JsonSerializer.Serialize(new
+                {
+                    success = true,
+                    threads
+                });
+            }
+            catch (Exception ex)
+            {
+                return System.Text.Json.JsonSerializer.Serialize(new
+                {
+                    success = false,
+                    error = ex.Message
+                });
+            }
+        }
+    }
+}

src/Resources/ProcessResources.cs

@@ -3,6 +3,7 @@
 using System.ComponentModel;
 using CESDK.Classes;
 using ModelContextProtocol.Server;
+using static CESDK.CESDK;
 
 namespace Tools
 {
@@ -16,7 +17,7 @@ public static object GetAddressList()
         {
             try
             {
-                var records = CESDK.CESDK.Synchronize(() =>
+                var records = Synchronize(() =>
                 {
                     var al = new AddressList();
                     var result = new List<object>();
@@ -53,7 +54,7 @@ public static object AddMemoryRecord(
         {
             try
             {
-                var record = CESDK.CESDK.Synchronize(() =>
+                var record = Synchronize(() =>
                 {
                     var al = new AddressList();
                     var r = al.CreateMemoryRecord();
@@ -92,7 +93,7 @@ public static object UpdateMemoryRecord(
         {
             try
             {
-                var result = CESDK.CESDK.Synchronize(() =>
+                var result = Synchronize(() =>
                 {
                     var al = new AddressList();
                     var r = FindRecord(al, id, index, description);
@@ -140,7 +141,7 @@ public static object DeleteMemoryRecord(
         {
             try
             {
-                var found = CESDK.CESDK.Synchronize(() =>
+                var found = Synchronize(() =>
                 {
                     var al = new AddressList();
                     var r = FindRecord(al, id, index, description);
@@ -167,7 +168,7 @@ public static object ClearAddressList()
         {
             try
             {
-                CESDK.CESDK.Synchronize(() =>
+                Synchronize(() =>
                 {
                     var al = new AddressList();
                     al.Clear();

src/Tools/AOBScanTool.cs

@@ -5,10 +5,13 @@
 
 namespace Tools
 {
+    /// <summary>
+    /// Disassembly and address resolution tools.
+    /// </summary>
     [McpServerToolType]
-    public class DisassembleTool
+    public class AssemblyTool
     {
-        private DisassembleTool() { }
+        private AssemblyTool() { }
 
         [McpServerTool(Name = "disassemble"), Description("Disassemble instructions or get instruction size at a memory address")]
         public static object Disassemble(
@@ -20,7 +23,7 @@ public static object Disassemble(
                 if (string.IsNullOrWhiteSpace(address))
                     return new { success = false, error = "Address parameter is required" };
 
-                if (!ulong.TryParse(address.Replace("0x", ""), System.Globalization.NumberStyles.HexNumber, null, out ulong addr))
+                if (!TryParseAddress(address, out ulong addr))
                     return new { success = false, error = "Invalid address format" };
 
                 string result = requestType?.ToLower() switch
@@ -37,5 +40,28 @@ public static object Disassemble(
                 return new { success = false, error = ex.Message };
             }
         }
+
+        [McpServerTool(Name = "resolve_address"), Description("Resolve an address from a string expression (supports symbols, module+offset, etc.)")]
+        public static object ResolveAddress(
+            [Description("Address string expression to resolve")] string addressString,
+            [Description("Whether to resolve as local address")] bool local = false)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(addressString))
+                    return new { success = false, error = "Address string is required" };
+
+                var address = AddressResolver.GetAddressSafe(addressString, local);
+                return new { success = true, address = address.HasValue ? $"0x{address.Value:X}" : "0" };
+            }
+            catch (Exception ex)
+            {
+                return new { success = false, error = ex.Message };
+            }
+        }
+
+        private static bool TryParseAddress(string address, out ulong result) =>
+            ulong.TryParse(address.Replace("0x", "").Replace("0X", ""),
+                System.Globalization.NumberStyles.HexNumber, null, out result);
     }
 }