#3407 ai-autocomplete: fix autocompletion

Signed-off-by: Patrizio Bekerle <[email protected]>

Author: pbek

src/services/openaiservice.cpp

@@ -26,6 +26,9 @@
 #include "scriptingservice.h"
 #include "services/settingsservice.h"
 
+// Forward declaration to avoid circular dependency
+class QOwnNotesMarkdownTextEdit;
+
 using namespace std;
 
 QT_USE_NAMESPACE
@@ -34,11 +37,59 @@ OpenAiService::OpenAiService(QObject* parent) : QObject(parent) {
     initializeBackends();
     initializeCompleter(parent);
 
+    // Set up the global autocomplete callback that routes to the active editor
+    // This is done once here instead of in each widget to avoid widgets overwriting each other
+    setAutocompleteCallback([](const QString& result) {
+        qDebug() << "*** GLOBAL AUTOCOMPLETE CALLBACK RECEIVED, result length:" << result.length();
+        // Forward declaration to avoid circular dependency
+        class QOwnNotesMarkdownTextEdit;
+
+        // Get the active editor using QMetaObject since we can't include the header
+        QObject* activeEditorObj = nullptr;
+        QMetaObject::invokeMethod(
+            nullptr,
+            []() -> QObject* {
+                // Access the static method through the class name
+                // We need to get QOwnNotesMarkdownTextEdit::getActiveEditorForAutocomplete()
+                // but we can't call it directly due to circular includes
+                // So we'll use a different approach - store it in QApplication
+                return qApp->property("activeAutocompleteEditor").value<QObject*>();
+            },
+            Qt::DirectConnection, Q_RETURN_ARG(QObject*, activeEditorObj));
+
+        if (!activeEditorObj) {
+            // Try to get from application property
+            activeEditorObj = qApp->property("activeAutocompleteEditor").value<QObject*>();
+        }
+
+        if (activeEditorObj) {
+            qDebug() << "*** Calling onAiAutocompleteCompleted on active editor:"
+                     << activeEditorObj;
+            QMetaObject::invokeMethod(activeEditorObj, "onAiAutocompleteCompleted",
+                                      Qt::DirectConnection, Q_ARG(QString, result));
+        } else {
+            qDebug() << "*** No active editor found in callback!";
+        }
+    });
+
     QObject::connect(_completer, &OpenAiCompleter::completed, this, [this](const QString& result) {
         qDebug() << "'result': " << result;
-        qDebug() << "OpenAiService - emitting autocompleteCompleted signal";
-        emit autocompleteCompleted(result);
-        qDebug() << "OpenAiService - autocompleteCompleted signal emitted";
+        qDebug() << "OpenAiService - processing autocomplete result";
+        qDebug() << "OpenAiService - this pointer:" << this;
+        qDebug() << "OpenAiService - Number of signal receivers:"
+                 << receivers(SIGNAL(autocompleteCompleted(QString)));
+        qDebug() << "OpenAiService - Has callback:" << (_autocompleteCallback != nullptr);
+
+        // Try callback first (direct call to active editor)
+        if (_autocompleteCallback) {
+            qDebug() << "OpenAiService - Calling autocomplete callback directly";
+            _autocompleteCallback(result);
+        } else {
+            qDebug() << "OpenAiService - No callback, emitting signal";
+            emit autocompleteCompleted(result);
+        }
+
+        qDebug() << "OpenAiService - autocomplete processing completed";
     });
     QObject::connect(_completer, &OpenAiCompleter::errorOccurred, this,
                      [this](const QString& errorString) {
@@ -86,9 +137,36 @@ void OpenAiService::deleteInstance() {
 
 void OpenAiService::initializeBackends() {
     _backendModels.clear();
-    _backendModels[QStringLiteral("openai")] =
-        QStringList{"gpt-4o",     "chatgpt-4o-latest", "gpt-4o-mini",   "o1-mini",
-                    "o1-preview", "gpt-4-turbo",       "gpt-3.5-turbo", "gpt-4"};
+    _backendModels[QStringLiteral("openai")] = QStringList{"gpt-5.1",
+                                                           "gpt-5",
+                                                           "gpt-5-mini",
+                                                           "gpt-5-nano",
+                                                           "gpt-5.1-chat-latest",
+                                                           "gpt-5-chat-latest",
+                                                           "gpt-5.1-codex-max",
+                                                           "gpt-5.1-codex",
+                                                           "gpt-5-codex",
+                                                           "gpt-5-pro",
+                                                           "gpt-4.1",
+                                                           "gpt-4.1-mini",
+                                                           "gpt-4.1-nano",
+                                                           "gpt-4o",
+                                                           "gpt-4o-2024-05-13",
+                                                           "gpt-4o-mini",
+                                                           "o1",
+                                                           "o1-pro",
+                                                           "o3-pro",
+                                                           "o3",
+                                                           "o3-deep-research",
+                                                           "o4-mini",
+                                                           "o4-mini-deep-research",
+                                                           "o3-mini",
+                                                           "o1-mini",
+                                                           "gpt-5.1-codex-mini",
+                                                           "codex-mini-latest",
+                                                           "gpt-5-search-api",
+                                                           "gpt-4o-mini-search-preview",
+                                                           "gpt-4o-search-preview"};
     _backendModels[QStringLiteral("groq")] =
         QStringList{"llama-3.1-8b-instant",
                     "deepseek-r1-distill-llama-70b",
@@ -99,9 +177,6 @@ void OpenAiService::initializeBackends() {
                     "groq/compound-mini",
                     "meta-llama/llama-4-maverick-17b-128e-instruct",
                     "meta-llama/llama-4-scout-17b-16e-instruct",
-                    "meta-llama/llama-guard-4-12b",
-                    "meta-llama/llama-prompt-guard-2-86m",
-                    "meta-llama/llama-prompt-guard-2-22m",
                     "moonshotai/kimi-k2-instruct",
                     "moonshotai/kimi-k2-instruct-0905",
                     "openai/gpt-oss-120b",
@@ -243,8 +318,10 @@ QString OpenAiService::getModelId() {
     // If not set yet try to read the settings
     if (this->_modelId.isEmpty()) {
         SettingsService settings;
-        this->_modelId =
-            settings.value(getCurrentModelSettingsKey(), _backendModels[getBackendId()]).toString();
+        // Get the first model as default if no model is set
+        const QStringList& models = getModelsForCurrentBackend();
+        QString defaultModel = models.isEmpty() ? QLatin1String("") : models.first();
+        this->_modelId = settings.value(getCurrentModelSettingsKey(), defaultModel).toString();
     }
 
     // If still not set get the first of the models
@@ -310,6 +387,13 @@ QString OpenAiService::complete(const QString& prompt) {
     return _completer->completeSync(prompt);
 }
 
+void OpenAiService::setAutocompleteCallback(AutocompleteCallback callback) {
+    qDebug() << __func__
+             << " - Setting autocomplete callback, was:" << (_autocompleteCallback != nullptr)
+             << "now:" << (callback != nullptr);
+    _autocompleteCallback = callback;
+}
+
 OpenAiCompleter::OpenAiCompleter(QString apiKey, QString modelId, QString apiBaseUrl,
                                  QObject* parent)
     : QObject(parent),

src/services/openaiservice.h

@@ -18,6 +18,7 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QObject>
+#include <functional>
 
 #include "services/settingsservice.h"
 
@@ -71,9 +72,13 @@ class OpenAiService : public QObject {
     QMap<QString, QString> getBackendNames();
     QString getApiBaseUrlForBackend(const QString& backendId);
 
+    // Callback for autocomplete results (avoids circular dependency)
+    using AutocompleteCallback = std::function<void(const QString&)>;
+    void setAutocompleteCallback(AutocompleteCallback callback);
+
    signals:
-    void autocompleteCompleted(QString result);
-    void autocompleteErrorOccurred(QString errorString);
+    void autocompleteCompleted(const QString& result);
+    void autocompleteErrorOccurred(const QString& errorString);
 
    private:
     QMap<QString, QStringList> _backendModels;
@@ -89,5 +94,6 @@ class OpenAiService : public QObject {
     static QString getApiKeySettingsKeyForBackend(const QString& backendId);
     void initializeCompleter(QObject* parent);
     QString getApiBaseUrlForCurrentBackend();
+    AutocompleteCallback _autocompleteCallback;
     QString getApiKeyForCurrentBackend();
 };

src/widgets/qownnotesmarkdowntextedit.cpp

@@ -28,6 +28,9 @@
 #include "services/settingsservice.h"
 #include "utils/urlhandler.h"
 
+// Initialize static member
+QOwnNotesMarkdownTextEdit *QOwnNotesMarkdownTextEdit::_activeAutocompleteEditor = nullptr;
+
 QOwnNotesMarkdownTextEdit::QOwnNotesMarkdownTextEdit(QWidget *parent)
     : QMarkdownTextEdit(parent, false) {
     // We need to set the internal variable to true, because we start with a highlighter
@@ -47,20 +50,32 @@ QOwnNotesMarkdownTextEdit::QOwnNotesMarkdownTextEdit(QWidget *parent)
     connect(_aiAutocompleteTimer, &QTimer::timeout, this,
             &QOwnNotesMarkdownTextEdit::requestAiAutocomplete);
 
-    // Connect to OpenAI service signals for all widgets
-    qDebug() << __func__ << " - Connecting AI autocomplete signals for widget:" << objectName()
-             << "parent:" << (parent ? parent->objectName() : "null");
-    qDebug() << __func__ << " - OpenAiService instance:" << OpenAiService::instance();
-    qDebug() << __func__ << " - this instance:" << this;
-
-    // Use old-style SIGNAL/SLOT macros for better compatibility
-    bool conn1 = connect(OpenAiService::instance(), SIGNAL(autocompleteCompleted(QString)), this,
-                         SLOT(onAiAutocompleteCompleted(QString)), Qt::QueuedConnection);
-    bool conn2 = connect(OpenAiService::instance(), SIGNAL(autocompleteErrorOccurred(QString)),
-                         this, SLOT(onAiAutocompleteTimeout(QString)), Qt::QueuedConnection);
+    // NOTE: Callback registration is now done globally in OpenAiService constructor
+    // We just need to register this editor as active if it's a note editor
+    if (!parent || parent->objectName() != QStringLiteral("LogWidget")) {
+        qDebug() << __func__ << " - Registering as active editor";
+        registerAsActiveEditor();
+    } else {
+        qDebug() << __func__ << " - Skipping registration for non-editor widget:" << objectName();
+    }
 
-    qDebug() << __func__ << " - AI autocomplete signals connected, conn1:" << conn1
+    // Use DirectConnection to ensure signal is delivered immediately before widget can be destroyed
+    // This prevents the "0 receivers" problem when widgets are recreated
+    bool conn1 = connect(
+        OpenAiService::instance(), &OpenAiService::autocompleteCompleted, this,
+        [this](const QString &result) {
+            qDebug() << "*** LAMBDA RECEIVED autocompleteCompleted signal for widget:" << this
+                     << objectName();
+            this->onAiAutocompleteCompleted(result);
+        },
+        Qt::DirectConnection);
+    bool conn2 = connect(OpenAiService::instance(), &OpenAiService::autocompleteErrorOccurred, this,
+                         &QOwnNotesMarkdownTextEdit::onAiAutocompleteTimeout, Qt::DirectConnection);
+
+    qDebug() << __func__
+             << " - AI autocomplete signals connected (DirectConnection), conn1:" << conn1
              << "conn2:" << conn2;
+    qDebug() << __func__ << " - Connected to OpenAiService instance:" << OpenAiService::instance();
 
     // Test: Call the slot directly to verify it exists
     qDebug() << __func__ << " - Testing slot by calling it directly...";
@@ -1313,8 +1328,15 @@ void QOwnNotesMarkdownTextEdit::requestAiAutocomplete() {
  * Shows the AI autocomplete suggestion
  */
 void QOwnNotesMarkdownTextEdit::showAiAutocompleteSuggestion(const QString &suggestion) {
+    qDebug() << "=== showAiAutocompleteSuggestion CALLED ===" << this;
+    qDebug() << __func__ << " - Widget:" << objectName();
+
     SettingsService settings;
-    if (!settings.value(QStringLiteral("ai/autocompleteEnabled")).toBool()) {
+    bool enabled = settings.value(QStringLiteral("ai/autocompleteEnabled")).toBool();
+    qDebug() << __func__ << " - ai/autocompleteEnabled setting:" << enabled;
+
+    if (!enabled) {
+        qDebug() << __func__ << " - autocomplete not enabled in settings, returning";
         return;
     }
 
@@ -1339,13 +1361,16 @@ void QOwnNotesMarkdownTextEdit::showAiAutocompleteSuggestion(const QString &sugg
     _aiAutocompleteSuggestion = suggestion;
     _isInsertingAiSuggestion = true;
 
-    qDebug() << __func__ << " - inserting suggestion";
+    qDebug() << __func__ << " - inserting suggestion text...";
 
     // Insert the suggestion with a gray color format
     QTextCursor cursor = textCursor();
     cursor.beginEditBlock();
 
-    // Store the format
+    // Store the original format to restore it later
+    QTextCharFormat originalFormat = cursor.charFormat();
+
+    // Create the suggestion format
     QTextCharFormat format;
     format.setForeground(QColor(128, 128, 128));    // Gray color
     format.setFontItalic(true);
@@ -1357,10 +1382,14 @@ void QOwnNotesMarkdownTextEdit::showAiAutocompleteSuggestion(const QString &sugg
     cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor,
                         _aiAutocompleteSuggestion.length());
 
+    // Reset the character format to the original to prevent the italic format
+    // from affecting subsequent text
+    cursor.setCharFormat(originalFormat);
+
     cursor.endEditBlock();
     setTextCursor(cursor);
 
-    qDebug() << __func__ << " - suggestion inserted and selected";
+    qDebug() << __func__ << " - suggestion inserted and selected successfully!";
 
     _isInsertingAiSuggestion = false;
 }
@@ -1424,12 +1453,18 @@ void QOwnNotesMarkdownTextEdit::acceptAiAutocompleteSuggestion() {
  * Called when AI autocomplete is completed
  */
 void QOwnNotesMarkdownTextEdit::onAiAutocompleteCompleted(const QString &result) {
+    qDebug() << "=== onAiAutocompleteCompleted CALLED ===" << this;
+    qDebug() << __func__ << " - Widget:" << objectName()
+             << "Parent:" << (parent() ? parent()->objectName() : "null");
     qDebug() << __func__ << " - 'result': " << result;
 
     if (result.isEmpty()) {
+        qDebug() << __func__ << " - result is empty, returning";
         return;
     }
 
+    qDebug() << __func__ << " - Processing result, length:" << result.length();
+
     // Extract the first line or first sentence as suggestion
     QString suggestion = result.trimmed();
 
@@ -1450,7 +1485,9 @@ void QOwnNotesMarkdownTextEdit::onAiAutocompleteCompleted(const QString &result)
     qDebug() << __func__ << " - 'cursor position': " << textCursor().position();
     qDebug() << __func__ << " - '_aiAutocompletePosition': " << _aiAutocompletePosition;
 
+    qDebug() << __func__ << " - Calling showAiAutocompleteSuggestion...";
     showAiAutocompleteSuggestion(suggestion);
+    qDebug() << __func__ << " - showAiAutocompleteSuggestion returned";
 }
 
 /**
@@ -1489,3 +1526,53 @@ void QOwnNotesMarkdownTextEdit::keyPressEvent(QKeyEvent *e) {
     // Call parent implementation
     QMarkdownTextEdit::keyPressEvent(e);
 }
+
+/**
+ * Override focusInEvent to register this editor as active when it receives focus
+ */
+void QOwnNotesMarkdownTextEdit::focusInEvent(QFocusEvent *e) {
+    // Register as the active editor for autocomplete when receiving focus
+    // Skip for log widgets
+    if (objectName() != QStringLiteral("logTextEdit")) {
+        qDebug() << __func__ << " - Registering as active editor:" << this << objectName();
+        registerAsActiveEditor();
+    }
+
+    // Call parent implementation
+    QMarkdownTextEdit::focusInEvent(e);
+}
+
+/**
+ * Register this editor as the active one for AI autocomplete
+ */
+void QOwnNotesMarkdownTextEdit::registerAsActiveEditor() {
+    qDebug() << __func__ << " - Registering editor:" << this << objectName();
+    _activeAutocompleteEditor = this;
+    // Also store in QApplication property for access from OpenAiService callback
+    qApp->setProperty("activeAutocompleteEditor", QVariant::fromValue<QObject *>(this));
+}
+
+/**
+ * Unregister this editor from receiving AI autocomplete
+ */
+void QOwnNotesMarkdownTextEdit::unregisterAsActiveEditor() {
+    qDebug() << __func__ << " - Unregistering editor:" << this << objectName();
+    if (_activeAutocompleteEditor == this) {
+        _activeAutocompleteEditor = nullptr;
+        // Also clear QApplication property
+        qApp->setProperty("activeAutocompleteEditor", QVariant::fromValue<QObject *>(nullptr));
+    }
+}
+
+/**
+ * Get the currently active editor for AI autocomplete
+ */
+QOwnNotesMarkdownTextEdit *QOwnNotesMarkdownTextEdit::getActiveEditorForAutocomplete() {
+    return _activeAutocompleteEditor;
+}
+
+QOwnNotesMarkdownTextEdit::~QOwnNotesMarkdownTextEdit() {
+    qDebug() << "*** QOwnNotesMarkdownTextEdit DESTROYED ***" << this << objectName();
+    // Unregister if this was the active editor
+    unregisterAsActiveEditor();
+}