-

Author: aiekick

3rdparty/imguipack

@@ -28,7 +28,7 @@ limitations under the License.
 // no imguipack/glad/glfw. The host owns all UI. The only host objects a plugin borrows are
 // forwarded by pointer/interface at instantiation (ez::Log via init(), IDatasModel via load(),
 // IScriptDebugHost via enableDebug()). This is what lets LogToGraph build fully static. The host
-// settings-dialog interface (ISettings) is NOT here anymore — it moved to src/systems/ISettings.h
+// settings-dialog interface (ISettings) is NOT here anymore — it moved to src/settings/ISettings.h
 // since plugins no longer provide settings.
 #include "IScriptDebugger.h"
 
@@ -142,6 +142,8 @@ typedef std::shared_ptr<IDatasModel> IDatasModelPtr;
 typedef std::weak_ptr<IDatasModel> IDatasModelWeak;
 
 struct ScriptingDatas {
+    std::string filename;
+    std::string filepath;
     std::string buffer;
 };
 typedef std::string ScriptingModuleName;
@@ -160,16 +162,23 @@ struct ScriptingModule : public PluginModule, public IScriptDebugger {
         (void)aOutErrors;
         return false;
     }
-    // will call the start function from script and return errors
-    virtual bool callScriptStart(ErrorContainer& vOutErrors) = 0;
+    // will call the start function from script with a filepath and return errors
+    virtual bool callScriptStart(const ScriptingDatas& vOutDatas, ErrorContainer& vOutErrors) = 0;
     // will call the exec function from script with a buffer and return errors
     virtual bool callScriptExec(const ScriptingDatas& vOutDatas, ErrorContainer& vErrors) = 0;
-    // will call the end function from script and return errors
-    virtual bool callScriptEnd(ErrorContainer& vOutErrors) = 0;
+    // will call the end function from script with a filepath and return errors
+    virtual bool callScriptEnd(const ScriptingDatas& vOutDatas, ErrorContainer& vOutErrors) = 0;
     // will set the row index
     virtual void setRowIndex(int32_t vRowIndex) = 0;
     // will set the row count
     virtual void setRowCount(int32_t vRowCount) = 0;
+    // pushes the in-memory project script source into the plugin's completion state so user-defined
+    // globals (top-level `function foo(...)`, `helpers = {...}`, etc.) surface in autocomplete next
+    // to the stdlib + `ltg` bindings. default no-op so non-Lua plugins compile unchanged. safe to
+    // call frequently (host calls it on every edit transaction): the implementation should be cheap
+    // and side-effect-free regardless of what the user code contains (sandbox the execution so a
+    // mid-edit script can't open files / spam logs / etc.).
+    virtual void setProjectScriptCode(const std::string& /*aCode*/) {}
     // introspects the plugin's live scripting state and returns the members of `aTarget` (a global
     // table or sol2 usertype). default no-op so non-Lua plugins compile unchanged. consumed by the
     // host's autocompletion popup; called from the UI thread, fast (one Lua table walk).

apis/LtgPluginApi.h

@@ -219,12 +219,12 @@ bool Module::compileScript(const Ltg::ScriptFilePathName& vFilePathName, Ltg::Er
         }
         sol::function startFile = (*m_luaPtr)["startFile"];
         if (!startFile.valid()) {
-            LogVarLightError("Lua: %s", "the lua function startFile() is missing");
+            LogVarLightError("Lua: %s", "the lua function startFile(filepath) is missing");
             res = false;
         }
         sol::function endFile = (*m_luaPtr)["endFile"];
         if (!endFile.valid()) {
-            LogVarLightError("Lua: %s", "the lua function endFile() is missing");
+            LogVarLightError("Lua: %s", "the lua function endFile(filepath) is missing");
             res = false;
         }
         return res;
@@ -254,12 +254,12 @@ bool Module::compileScriptCode(const std::string& aCode, Ltg::ErrorContainer& vO
         }
         sol::function startFile = (*m_luaPtr)["startFile"];
         if (!startFile.valid()) {
-            LogVarLightError("Lua: %s", "the lua function startFile() is missing");
+            LogVarLightError("Lua: %s", "the lua function startFile(filepath) is missing");
             res = false;
         }
         sol::function endFile = (*m_luaPtr)["endFile"];
         if (!endFile.valid()) {
-            LogVarLightError("Lua: %s", "the lua function endFile() is missing");
+            LogVarLightError("Lua: %s", "the lua function endFile(filepath) is missing");
             res = false;
         }
         return res;
@@ -365,6 +365,115 @@ void Module::m_iterateLuaTable(lua_State* apLua, int aTableIndex, std::vector<Lt
     }
 }
 
+void Module::setProjectScriptCode(const std::string& aCode) {
+    // Push the in-memory project script into the completion state so user globals (top-level
+    // `function parse(...)`, `helpers = { ... }`, etc.) surface alongside the stdlib + `ltg`
+    // bindings. Strategy: load the chunk, set its env to a fresh sandbox table pre-populated
+    // with safe stdlib pointers + a no-op `ltg` stub, pcall it under that env, then steal the
+    // sandbox keys back into _G of the completion state. Anything the user code does that the
+    // sandbox doesn't allow (io.open, os.exit, print, ...) raises a runtime error inside the
+    // pcall and is swallowed — the partial sandbox state is still useful.
+    m_ensureCompletionState();
+    lua_State* L = m_completionLuaPtr->lua_state();
+    const int topBefore = lua_gettop(L);
+
+    // 1) wipe globals introduced by the previous push, so removed top-level definitions stop
+    //    appearing in autocomplete. bindings (math, string, ltg, ...) live in _G too but are
+    //    NOT in m_completionUserGlobals so they are preserved.
+    for (const auto& key : m_completionUserGlobals) {
+        lua_pushnil(L);
+        lua_setglobal(L, key.c_str());
+    }
+    m_completionUserGlobals.clear();
+
+    if (aCode.empty()) {
+        lua_settop(L, topBefore);
+        return;
+    }
+
+    // 2) build a fresh sandbox table holding only side-effect-free pointers. ltg is replaced
+    //    by a metatable-driven stub that returns a no-op closure for any key access, so
+    //    `ltg:logInfo("x")` / `ltg:addSignalTag(...)` at top level of the user script don't
+    //    spam the host's console / Messaging pane during autocomplete refresh.
+    lua_newtable(L);
+    const int sandboxIdx = lua_gettop(L);
+    // clang-format off
+    static const char* const kSafeStdlib[] = {
+        "math", "string", "table",
+        "tostring", "tonumber", "pairs", "ipairs", "type", "select", "next", "unpack",
+        "rawget", "rawset", "rawequal", "setmetatable", "getmetatable",
+        "assert", "error", "pcall", "xpcall",
+    };
+    // clang-format on
+    for (const char* const name : kSafeStdlib) {
+        lua_getglobal(L, name);
+        if (lua_isnil(L, -1)) {
+            lua_pop(L, 1);
+        } else {
+            lua_setfield(L, sandboxIdx, name);
+        }
+    }
+    // ltg stub built via a Lua chunk so we don't need a second C-binding registration:
+    // setmetatable({}, { __index = function() return function() end end })
+    static const char* const kLtgStubChunk =
+        "local noop = function() end "
+        "return setmetatable({}, { __index = function(_, _) return noop end })";
+    if (luaL_loadstring(L, kLtgStubChunk) == 0 && lua_pcall(L, 0, 1, 0) == 0) {
+        lua_setfield(L, sandboxIdx, "ltg");
+    } else {
+        lua_pop(L, 1);  // pop error message or failed chunk
+    }
+
+    // 3) snapshot binding key names so the copy-back step doesn't shadow the real bindings
+    //    living in _G (notably: the real `ltg` is the LuaDatasModel userdata used by
+    //    getCompletionEntries("ltg"), not the no-op stub we just put in the sandbox).
+    std::unordered_set<std::string> bindingKeys;
+    lua_pushnil(L);
+    while (lua_next(L, sandboxIdx) != 0) {
+        if (lua_type(L, -2) == LUA_TSTRING) {
+            bindingKeys.insert(std::string(lua_tostring(L, -2)));
+        }
+        lua_pop(L, 1);  // pop value, keep key for next iter
+    }
+
+    // 4) load + setfenv + exec. parse error -> bail (the user is mid-edit, previous globals
+    //    have already been wiped above so autocomplete shows only the stdlib until the next
+    //    syntactically-valid edit). runtime error -> swallow, keep partial sandbox state.
+    if (luaL_loadbuffer(L, aCode.data(), aCode.size(), "<project script completion>") != 0) {
+        lua_pop(L, 1);  // pop error message
+        lua_settop(L, topBefore);
+        return;
+    }
+    lua_pushvalue(L, sandboxIdx);
+    if (lua_setfenv(L, -2) == 0) {
+        // chunk isn't a function/userdata/thread — should be impossible after a successful
+        // loadbuffer, but bail safely if the runtime ever changes.
+        lua_settop(L, topBefore);
+        return;
+    }
+    if (lua_pcall(L, 0, 0, 0) != 0) {
+        lua_pop(L, 1);  // pop error message
+    }
+
+    // 5) copy sandbox keys into _G, skipping pre-populated bindings. Track names so the next
+    //    push can wipe them. Functions, tables, numbers, strings — all welcome; the completion
+    //    iterator filters by type at query time.
+    lua_pushnil(L);
+    while (lua_next(L, sandboxIdx) != 0) {
+        if (lua_type(L, -2) == LUA_TSTRING) {
+            std::string key(lua_tostring(L, -2));
+            if (bindingKeys.find(key) == bindingKeys.end()) {
+                lua_pushvalue(L, -1);  // dup value
+                lua_setglobal(L, key.c_str());
+                m_completionUserGlobals.insert(std::move(key));
+            }
+        }
+        lua_pop(L, 1);  // pop value, keep key for next iter
+    }
+
+    lua_settop(L, topBefore);
+}
+
 void Module::getCompletionEntries(const std::string& aTarget, std::vector<Ltg::CompletionEntry>& aoEntries) {
     if (aTarget.empty()) {
         return;
@@ -375,9 +484,37 @@ void Module::getCompletionEntries(const std::string& aTarget, std::vector<Ltg::C
 
     lua_getglobal(L, aTarget.c_str());
     const int targetType = lua_type(L, -1);
+    const int targetIdx = lua_gettop(L);
     if (targetType == LUA_TTABLE) {
-        // plain table (Lua stdlib namespace, user table) — iterate directly
-        m_iterateLuaTable(L, lua_gettop(L), aoEntries);
+        // plain table (Lua stdlib namespace, user table, class instance, ...) — iterate the
+        // direct keys first (e.g. instance fields `self.prefix`, `self.count`).
+        m_iterateLuaTable(L, targetIdx, aoEntries);
+        // then hop one level through the metatable's __index to surface inherited methods.
+        // This is the standard Lua OOP idiom: `Logger.__index = Logger` + `setmetatable(self, Logger)`
+        // means `log:info()` resolves to `Logger.info`. Without this hop, `log:` autocomplete
+        // would only see direct instance fields and miss every method on the class table.
+        if (lua_getmetatable(L, targetIdx) != 0) {
+            lua_getfield(L, -1, "__index");
+            if (lua_type(L, -1) == LUA_TTABLE) {
+                std::vector<Ltg::CompletionEntry> hopEntries;
+                m_iterateLuaTable(L, lua_gettop(L), hopEntries);
+                // dedup against direct fields — closer scopes win (a shadowing field on the
+                // instance should hide the metatable's same-named method in the popup).
+                for (auto& entry : hopEntries) {
+                    bool present = false;
+                    for (const auto& existing : aoEntries) {
+                        if (existing.name == entry.name) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
+                        aoEntries.push_back(std::move(entry));
+                    }
+                }
+            }
+            lua_pop(L, 2);  // __index + metatable
+        }
     } else if (targetType == LUA_TUSERDATA) {
         // sol2 usertype — methods are stored in the metatable's __index field, hop through it
         if (lua_getmetatable(L, -1) != 0) {
@@ -457,13 +594,13 @@ void Module::getSignatureInfo(const std::string& aTarget, const std::string& aFu
     // not in the catalog — leave aoSignature empty, the host won't open the tooltip
 }
 
-bool Module::callScriptStart(Ltg::ErrorContainer& vOutErrors) {
+bool Module::callScriptStart(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorContainer& vOutErrors) {
     sol::protected_function startFile = (*m_luaPtr)["startFile"];
     if (!startFile.valid()) {
-        LogVarLightError("Lua: %s", "the lua function startFile() is missing");
+        LogVarLightError("Lua: %s", "the lua function startFile(filepath) is missing");
         return false;
     }
-    sol::protected_function_result result = startFile();
+    sol::protected_function_result result = startFile(vOutDatas.filename, vOutDatas.filepath);
     if (!result.valid()) {
         sol::error solErr = result;
         Ltg::ScriptingError err;
@@ -493,13 +630,13 @@ bool Module::callScriptExec(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorCont
     return true;
 }
 
-bool Module::callScriptEnd(Ltg::ErrorContainer& vOutErrors) {
+bool Module::callScriptEnd(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorContainer& vOutErrors) {
     sol::protected_function endFile = (*m_luaPtr)["endFile"];
     if (!endFile.valid()) {
-        LogVarLightError("%s", "the lua function endFile() is missing");
+        LogVarLightError("%s", "the lua function endFile(filepath) is missing");
         return false;
     }
-    sol::protected_function_result result = endFile();
+    sol::protected_function_result result = endFile(vOutDatas.filename, vOutDatas.filepath);
     if (!result.valid()) {
         sol::error solErr = result;
         Ltg::ScriptingError err;

plugins/LuaScripting/src/modules/Module.cpp

@@ -8,6 +8,7 @@
 #include <atomic>
 #include <cstdint>
 #include <unordered_map>
+#include <unordered_set>
 
 namespace sol {
 class state;
@@ -51,13 +52,14 @@ class Module : public Ltg::ScriptingModule {
     void unload() final;
     bool compileScript(const Ltg::ScriptFilePathName& vFilePathName, Ltg::ErrorContainer& vOutErrors) final;
     bool compileScriptCode(const std::string& aCode, Ltg::ErrorContainer& vOutErrors) final;
-    bool callScriptStart(Ltg::ErrorContainer& vOutErrors) final;
+    bool callScriptStart(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorContainer& vOutErrors) final;
     bool callScriptExec(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorContainer& vErrors) final;
-    bool callScriptEnd(Ltg::ErrorContainer& vOutErrors) final;
+    bool callScriptEnd(const Ltg::ScriptingDatas& vOutDatas, Ltg::ErrorContainer& vOutErrors) final;
 
     void setRowIndex(int32_t vRowIndex) final;
     void setRowCount(int32_t vRowCount) final;
 
+    void setProjectScriptCode(const std::string& aCode) final;
     void getCompletionEntries(const std::string& aTarget, std::vector<Ltg::CompletionEntry>& aoEntries) final;
     void getSignatureInfo(const std::string& aTarget, const std::string& aFunctionName, Ltg::SignatureInfo& aoSignature) final;
 
@@ -81,4 +83,8 @@ class Module : public Ltg::ScriptingModule {
 
     void m_ensureCompletionState();  // lazy init of m_completionLuaPtr on first getCompletionEntries call
     static void m_iterateLuaTable(lua_State* apLua, int aTableIndex, std::vector<Ltg::CompletionEntry>& aoEntries);
+
+    // keys we currently expose as user globals in the completion state's _G — wiped before each
+    // setProjectScriptCode refresh so removed top-level definitions stop appearing in autocomplete.
+    std::unordered_set<std::string> m_completionUserGlobals;
 };

plugins/LuaScripting/src/modules/Module.h

@@ -8,8 +8,9 @@
 #include <frontend/MainFrontend.h>
 #include <project/ProjectFile.h>
 #include <systems/PluginManager.h>
-#include <systems/SettingsDialog.h>
-#include <systems/AppSettings.h>
+#include <settings/SettingsDialog.h>
+#include <settings/AppSettings.h>
+#include <settings/DebugSettings.h>
 #include <systems/TranslationHelper.h>
 #include <models/log/LogEngine.h>
 #include <models/script/ScriptingEngine.h>
@@ -100,6 +101,7 @@ void App::m_InitSingletons() {
     TranslationHelper::initSingleton();
     // app-level settings — shared_ptr because SettingsDialog stores it as weak_ptr<ISettings>
     AppSettings::initSingleton();
+    DebugSettings::initSingleton();
     // models (shared_ptr based)
     ProjectFile::initSingleton();
     LogEngine::initSingleton();
@@ -164,6 +166,7 @@ void App::m_UnitSingletons() {
     LogEngine::unitSingleton();
     ProjectFile::unitSingleton();
     // app-level settings
+    DebugSettings::unitSingleton();
     AppSettings::unitSingleton();
     // managers
     TranslationHelper::unitSingleton();

src/App.cpp

@@ -32,8 +32,8 @@
 
 #include <panes/misc/ConsolePane.h>
 
-#include <systems/SettingsDialog.h>
-#include <systems/AppSettings.h>
+#include <settings/SettingsDialog.h>
+#include <settings/AppSettings.h>
 
 // we include the cpp just for embedded fonts
 #include <fonts/fontIcons.cpp>

src/backend/MainBackend.cpp

@@ -1,6 +1,7 @@
 #include "CodeEditor.h"
 #include <ezlibs/ezTools.hpp>
 #include <models/script/ScriptingEngine.h>
+#include <settings/DebugSettings.h>
 
 #include <filesystem>
 #include <fstream>
@@ -264,6 +265,10 @@ bool CodeEditor::IsModified() const {
     return m_Editor.GetUndoIndex() != static_cast<size_t>(m_UndoIndexInDisk);
 }
 
+size_t CodeEditor::GetUndoIndex() const {
+    return m_Editor.GetUndoIndex();
+}
+
 void CodeEditor::MarkSaved() {
     m_UndoIndexInDisk = static_cast<int>(m_Editor.GetUndoIndex());
 }
@@ -440,11 +445,11 @@ void CodeEditor::m_OnCharacterTyped(ImWchar aCharacter, int aLine, int aColumn)
         m_Editor.CloseCompletionPopup();
         m_OnCompletionCancelled();
         // fall through — a non-ident char may also be a `(` that triggers the signature
-    } else if (aCharacter == '.' || aCharacter == ':') {
+    } else if ((aCharacter == '.' || aCharacter == ':') && DebugSettings::ref()->isAutoCompletionEnabled()) {
         // === completion trigger: `.` or `:` after a known catalog key ======================
         // `aColumn` is the cursor RIGHT AFTER the trigger char. The identifier we want is to
         // the LEFT of the trigger, so we look one column further back (the trigger itself
-        // is at column - 1).
+        // is at column - 1). gated by DebugSettings — when off, no popup ever opens.
         const std::string target = m_ExtractTokenAt(aLine, aColumn - 2);
         if (target.empty()) {
             return;
@@ -466,8 +471,8 @@ void CodeEditor::m_OnCharacterTyped(ImWchar aCharacter, int aLine, int aColumn)
     // === signature trigger: `(` when no tooltip is currently open ==========================
     // we skip the trigger when the signature is already open: the first block above already
     // bumped the paren depth (nested call), and a nested signature tooltip would compete for
-    // screen space with no clean UI to disambiguate.
-    if (aCharacter == '(' && !m_Editor.IsSignatureTooltipOpen()) {
+    // screen space with no clean UI to disambiguate. gated by DebugSettings.
+    if (aCharacter == '(' && !m_Editor.IsSignatureTooltipOpen() && DebugSettings::ref()->isSignatureHelpEnabled()) {
         std::string target;
         std::string funcName;
         if (m_ExtractCallTargetAt(aLine, aColumn - 1, target, funcName)) {

src/frontend/Components/CodeEditor.cpp

@@ -83,6 +83,7 @@ class CodeEditor {
     std::string GetCode() const;
     bool IsModified() const;  // true if edited since the last SetCode / MarkSaved
     void MarkSaved();
+    size_t GetUndoIndex() const;  // monotonic edit counter — used to drive completion refresh on edit
 
     void ClearErrorMarkers();
     void AddErrorMarker(const size_t& vErrorLine, const std::string& vErrorMsg);