refactor: Restructure project into sources/tests layout and dissolve PluginLLMCore

sources/completion/CodeHandler.cpp

@@ -0,0 +1,232 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// Copyright (C) 2025 Povilas Kanapickas <povilas@radix.lt>
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "completion/CodeHandler.hpp"
+#include <settings/CodeCompletionSettings.hpp>
+#include <QFileInfo>
+#include <QHash>
+
+namespace QodeAssist {
+
+struct LanguageProperties
+{
+    QString name;
+    QString commentStyle;
+    QVector<QString> namesFromModel;
+    QVector<QString> fileExtensions;
+};
+
+const QVector<LanguageProperties> customLanguagesFromSettings()
+{
+    QVector<LanguageProperties> customLanguages;
+
+    const QStringList customLanguagesList = Settings::codeCompletionSettings().customLanguages();
+    for (const QString &entry : customLanguagesList) {
+        if (entry.trimmed().isEmpty()) {
+            continue;
+        }
+
+        QStringList parts = entry.split(',');
+        if (parts.size() < 4) {
+            continue;
+        }
+
+        QString name = parts[0].trimmed();
+        QString commentStyle = parts[1].trimmed();
+        QStringList modelNamesList = parts[2].trimmed().split(' ', Qt::SkipEmptyParts);
+        QStringList extensionsList = parts[3].trimmed().split(' ', Qt::SkipEmptyParts);
+
+        if (!name.isEmpty() && !commentStyle.isEmpty() && !modelNamesList.isEmpty()
+            && !extensionsList.isEmpty()) {
+            QVector<QString> modelNames;
+            for (const auto &modelName : modelNamesList) {
+                modelNames.append(modelName);
+            }
+
+            QVector<QString> extensions;
+            for (const auto &ext : extensionsList) {
+                extensions.append(ext);
+            }
+
+            customLanguages.append({name, commentStyle, modelNames, extensions});
+        }
+    }
+
+    return customLanguages;
+}
+const QVector<LanguageProperties> &getKnownLanguages()
+{
+    static QVector<LanguageProperties> knownLanguages = {
+        {"python", "#", {"python", "py"}, {"py"}},
+        {"lua", "--", {"lua"}, {"lua"}},
+        {"js", "//", {"js", "javascript"}, {"js", "jsx"}},
+        {"ts", "//", {"ts", "typescript"}, {"ts", "tsx"}},
+        {"c-like", "//", {"c", "c++", "cpp"}, {"c", "h", "cpp", "hpp"}},
+        {"java", "//", {"java"}, {"java"}},
+        {"c#", "//", {"cs", "csharp"}, {"cs"}},
+        {"php", "//", {"php"}, {"php"}},
+        {"ruby", "#", {"rb", "ruby"}, {"rb"}},
+        {"go", "//", {"go"}, {"go"}},
+        {"swift", "//", {"swift"}, {"swift"}},
+        {"kotlin", "//", {"kt", "kotlin"}, {"kt", "kotlin"}},
+        {"scala", "//", {"scala"}, {"scala"}},
+        {"r", "#", {"r"}, {"r"}},
+        {"shell", "#", {"shell", "bash", "sh"}, {"sh", "bash"}},
+        {"perl", "#", {"pl", "perl"}, {"pl"}},
+        {"hs", "--", {"hs", "haskell"}, {"hs"}},
+        {"qml", "//", {"qml"}, {"qml"}},
+    };
+
+    knownLanguages.append(customLanguagesFromSettings());
+
+    return knownLanguages;
+}
+
+bool CodeHandler::hasCodeBlocks(const QString &text)
+{
+    QStringList lines = text.split('\n');
+
+    for (const QString &line : lines) {
+        if (line.trimmed().startsWith("```")) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static QHash<QString, QString> buildLanguageToCommentPrefixMap()
+{
+    QHash<QString, QString> result;
+    for (const auto &languageProps : getKnownLanguages()) {
+        result[languageProps.name] = languageProps.commentStyle;
+    }
+    return result;
+}
+
+static QHash<QString, QString> buildExtensionToLanguageMap()
+{
+    QHash<QString, QString> result;
+    for (const auto &languageProps : getKnownLanguages()) {
+        for (const auto &extension : languageProps.fileExtensions) {
+            result[extension] = languageProps.name;
+        }
+    }
+    return result;
+}
+
+static QHash<QString, QString> buildModelLanguageNameToLanguageMap()
+{
+    QHash<QString, QString> result;
+    for (const auto &languageProps : getKnownLanguages()) {
+        for (const auto &nameFromModel : languageProps.namesFromModel) {
+            result[nameFromModel] = languageProps.name;
+        }
+    }
+    return result;
+}
+
+QString CodeHandler::processText(QString text, QString currentFilePath)
+{
+    QString result;
+    QStringList lines = text.split('\n');
+    bool inCodeBlock = false;
+    QString pendingComments;
+
+    auto currentFileExtension = QFileInfo(currentFilePath).suffix();
+    auto currentLanguage = detectLanguageFromExtension(currentFileExtension);
+
+    auto addPendingCommentsIfAny = [&]() {
+        if (pendingComments.isEmpty()) {
+            return;
+        }
+        QStringList commentLines = pendingComments.split('\n');
+        QString commentPrefix = getCommentPrefix(currentLanguage);
+
+        for (const QString &commentLine : commentLines) {
+            if (!commentLine.trimmed().isEmpty()) {
+                result += commentPrefix + " " + commentLine.trimmed() + "\n";
+            } else {
+                result += "\n";
+            }
+        }
+        pendingComments.clear();
+    };
+
+    for (const QString &line : lines) {
+        if (line.trimmed().startsWith("```")) {
+            if (!inCodeBlock) {
+                auto lineLanguage = detectLanguageFromLine(line);
+                if (!lineLanguage.isEmpty()) {
+                    currentLanguage = lineLanguage;
+                }
+
+                addPendingCommentsIfAny();
+
+                if (lineLanguage.isEmpty()) {
+                    // language not detected, so add direct output from model, if any
+                    result += line.trimmed().mid(3) + "\n"; // add the remainder of line after ```
+                }
+            }
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+
+        if (inCodeBlock) {
+            result += line + "\n";
+        } else {
+            QString trimmed = line.trimmed();
+            if (!trimmed.isEmpty()) {
+                pendingComments += trimmed + "\n";
+            } else {
+                pendingComments += "\n";
+            }
+        }
+    }
+
+    addPendingCommentsIfAny();
+
+    return result;
+}
+
+QString CodeHandler::getCommentPrefix(const QString &language)
+{
+    static const auto commentPrefixes = buildLanguageToCommentPrefixMap();
+    return commentPrefixes.value(language, "//");
+}
+
+QString CodeHandler::detectLanguageFromLine(const QString &line)
+{
+    static const auto modelNameToLanguage = buildModelLanguageNameToLanguageMap();
+    return modelNameToLanguage.value(line.trimmed().mid(3).trimmed(), "");
+}
+
+QString CodeHandler::detectLanguageFromExtension(const QString &extension)
+{
+    static const auto extensionToLanguage = buildExtensionToLanguageMap();
+    return extensionToLanguage.value(extension.toLower(), "");
+}
+
+const QRegularExpression &CodeHandler::getFullCodeBlockRegex()
+{
+    static const QRegularExpression
+        regex(R"(```[\w\s]*\n([\s\S]*?)```)", QRegularExpression::MultilineOption);
+    return regex;
+}
+
+const QRegularExpression &CodeHandler::getPartialStartBlockRegex()
+{
+    static const QRegularExpression
+        regex(R"(```[\w\s]*\n([\s\S]*?)$)", QRegularExpression::MultilineOption);
+    return regex;
+}
+
+const QRegularExpression &CodeHandler::getPartialEndBlockRegex()
+{
+    static const QRegularExpression regex(R"(^([\s\S]*?)```)", QRegularExpression::MultilineOption);
+    return regex;
+}
+
+} // namespace QodeAssist

sources/completion/CodeHandler.hpp

@@ -0,0 +1,41 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QObject>
+#include <QRegularExpression>
+#include <QString>
+
+namespace QodeAssist {
+
+class CodeHandler
+{
+public:
+    static QString processText(QString text, QString currentFileName);
+
+    /**
+     * Detects language from line, or returns empty string if this was not possible
+     */
+    static QString detectLanguageFromLine(const QString &line);
+
+    /**
+     * Detects language file name, or returns empty string if this was not possible
+     */
+    static QString detectLanguageFromExtension(const QString &extension);
+
+    /**
+     * Detects if text contains code blocks, or returns false if this was not possible
+     */
+    static bool hasCodeBlocks(const QString &text);
+
+private:
+    static QString getCommentPrefix(const QString &language);
+
+    static const QRegularExpression &getFullCodeBlockRegex();
+    static const QRegularExpression &getPartialStartBlockRegex();
+    static const QRegularExpression &getPartialEndBlockRegex();
+};
+
+} // namespace QodeAssist

sources/completion/LLMClientInterface.cpp

@@ -0,0 +1,467 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "completion/LLMClientInterface.hpp"
+
+#include <LLMQore/BaseClient.hpp>
+#include <QJsonDocument>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+
+#include "completion/CodeHandler.hpp"
+#include "context/DocumentContextReader.hpp"
+#include "context/Utils.hpp"
+#include "logger/Logger.hpp"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
+#include "context/RulesLoader.hpp"
+
+namespace QodeAssist {
+
+LLMClientInterface::LLMClientInterface(
+    const Settings::GeneralSettings &generalSettings,
+    const Settings::CodeCompletionSettings &completeSettings,
+    Providers::IProviderRegistry &providerRegistry,
+    Templates::IPromptProvider *promptProvider,
+    Context::IDocumentReader &documentReader,
+    IRequestPerformanceLogger &performanceLogger)
+    : m_generalSettings(generalSettings)
+    , m_completeSettings(completeSettings)
+    , m_providerRegistry(providerRegistry)
+    , m_promptProvider(promptProvider)
+    , m_documentReader(documentReader)
+    , m_performanceLogger(performanceLogger)
+    , m_contextManager(new Context::ContextManager(this))
+{
+}
+
+LLMClientInterface::~LLMClientInterface()
+{
+    handleCancelRequest();
+}
+
+Utils::FilePath LLMClientInterface::serverDeviceTemplate() const
+{
+    return "QodeAssist";
+}
+
+void LLMClientInterface::startImpl()
+{
+    emit started();
+}
+
+void LLMClientInterface::handleFullResponse(const QString &requestId, const QString &fullText)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    const RequestContext &ctx = it.value();
+    sendCompletionToClient(fullText, ctx.originalRequest, true);
+
+    m_activeRequests.erase(it);
+    m_performanceLogger.endTimeMeasurement(requestId);
+}
+
+void LLMClientInterface::handleRequestFinalized(
+    const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info)
+{
+    if (!m_activeRequests.contains(requestId) || !info.usage)
+        return;
+
+    const auto &u = *info.usage;
+    LOG_MESSAGE(QString("Completion usage [%1]: prompt=%2 completion=%3 cached=%4 reasoning=%5")
+                    .arg(requestId)
+                    .arg(u.promptTokens)
+                    .arg(u.completionTokens)
+                    .arg(u.cachedPromptTokens)
+                    .arg(u.reasoningTokens));
+}
+
+void LLMClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    const RequestContext &ctx = it.value();
+
+    LOG_MESSAGE(QString("Request %1 failed: %2").arg(requestId, error));
+
+    // Send LSP error response to client
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response[LanguageServerProtocol::idKey] = ctx.originalRequest["id"];
+
+    QJsonObject errorObject;
+    errorObject["code"] = -32603; // Internal error code
+    errorObject["message"] = error;
+    response["error"] = errorObject;
+    
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+    
+    m_activeRequests.erase(it);
+    m_performanceLogger.endTimeMeasurement(requestId);
+}
+
+void LLMClientInterface::sendData(const QByteArray &data)
+{
+    QJsonDocument doc = QJsonDocument::fromJson(data);
+    if (!doc.isObject())
+        return;
+
+    QJsonObject request = doc.object();
+    QString method = request["method"].toString();
+
+    if (method == "initialize") {
+        handleInitialize(request);
+    } else if (method == "initialized") {
+        // TODO make initilizied handler
+    } else if (method == "shutdown") {
+        handleShutdown(request);
+    } else if (method == "textDocument/didOpen") {
+        handleTextDocumentDidOpen(request);
+    } else if (method == "getCompletionsCycling") {
+        handleCompletion(request);
+    } else if (method == "$/cancelRequest") {
+        handleCancelRequest();
+    } else if (method == "exit") {
+        // TODO make exit handler
+    } else {
+        LOG_MESSAGE(QString("Unknown method: %1").arg(method));
+    }
+}
+
+void LLMClientInterface::handleCancelRequest()
+{
+    QSet<Providers::Provider *> providers;
+    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
+        if (it.value().provider) {
+            providers.insert(it.value().provider);
+        }
+    }
+
+    for (auto *provider : providers) {
+        disconnect(provider->client(), nullptr, this, nullptr);
+    }
+
+    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
+        const RequestContext &ctx = it.value();
+        if (ctx.provider) {
+            ctx.provider->cancelRequest(it.key());
+        }
+    }
+
+    m_activeRequests.clear();
+
+    LOG_MESSAGE("All requests cancelled and state cleared");
+}
+
+void LLMClientInterface::handleInitialize(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["id"] = request["id"];
+
+    QJsonObject result;
+    QJsonObject capabilities;
+    capabilities["textDocumentSync"] = 1;
+    capabilities["completionProvider"] = QJsonObject{{"resolveProvider", false}};
+    capabilities["hoverProvider"] = true;
+    result["capabilities"] = capabilities;
+
+    QJsonObject serverInfo;
+    serverInfo["name"] = "QodeAssist LSP Server";
+    serverInfo["version"] = "0.1";
+    result["serverInfo"] = serverInfo;
+
+    response["result"] = result;
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleShutdown(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["id"] = request["id"];
+    response["result"] = QJsonValue();
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleTextDocumentDidOpen(const QJsonObject &request) {}
+
+void LLMClientInterface::handleInitialized(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["method"] = "initialized";
+    response["params"] = QJsonObject();
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleExit(const QJsonObject &request)
+{
+    emit finished();
+}
+
+void LLMClientInterface::sendErrorResponse(const QJsonObject &request, const QString &errorMessage)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response[LanguageServerProtocol::idKey] = request["id"];
+    
+    QJsonObject errorObject;
+    errorObject["code"] = -32603; // Internal error code
+    errorObject["message"] = errorMessage;
+    response["error"] = errorObject;
+    
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+    
+    // End performance measurement if it was started
+    QString requestId = request["id"].toString();
+    m_performanceLogger.endTimeMeasurement(requestId);
+}
+
+void LLMClientInterface::handleCompletion(const QJsonObject &request)
+{
+    auto filePath = Context::extractFilePathFromRequest(request);
+    auto documentInfo = m_documentReader.readDocument(filePath);
+    if (!documentInfo.document) {
+        QString error = QString("Document is not available: %1").arg(filePath);
+        LOG_MESSAGE("Error: " + error);
+        sendErrorResponse(request, error);
+        return;
+    }
+
+    auto updatedContext = prepareContext(request, documentInfo);
+
+    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
+
+    const auto providerName = !isPreset1Active ? m_generalSettings.ccProvider()
+                                               : m_generalSettings.ccPreset1Provider();
+    const auto modelName = !isPreset1Active ? m_generalSettings.ccModel()
+                                            : m_generalSettings.ccPreset1Model();
+    const auto url = !isPreset1Active ? m_generalSettings.ccUrl()
+                                      : m_generalSettings.ccPreset1Url();
+
+    const auto provider = m_providerRegistry.getProviderByName(providerName);
+
+    if (!provider) {
+        QString error = QString("No provider found with name: %1").arg(providerName);
+        LOG_MESSAGE(error);
+        sendErrorResponse(request, error);
+        return;
+    }
+
+    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
+                                         : m_generalSettings.ccPreset1Template();
+
+    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
+
+    if (!promptTemplate) {
+        QString error = QString("No template found with name: %1").arg(templateName);
+        LOG_MESSAGE(error);
+        sendErrorResponse(request, error);
+        return;
+    }
+
+    QJsonObject payload{{"model", modelName}, {"stream", true}};
+
+    const auto stopWords = QJsonArray::fromStringList(promptTemplate->stopWords());
+    if (!stopWords.isEmpty())
+        payload["stop"] = stopWords;
+
+    QString systemPrompt;
+    if (m_completeSettings.useSystemPrompt())
+        systemPrompt.append(
+            m_completeSettings.useUserMessageTemplateForCC()
+                    && promptTemplate->type() == Templates::TemplateType::Chat
+                ? m_completeSettings.systemPromptForNonFimModels()
+                : m_completeSettings.systemPrompt());
+
+    auto project = Context::RulesLoader::getActiveProject();
+    if (project) {
+        QString projectRules
+            = Context::RulesLoader::loadRulesForProject(project, Context::RulesContext::Completions);
+
+        if (!projectRules.isEmpty()) {
+            systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
+            LOG_MESSAGE("Loaded project rules for completion");
+        }
+    }
+
+    if (updatedContext.fileContext.has_value())
+        systemPrompt.append(updatedContext.fileContext.value());
+
+    if (m_completeSettings.useOpenFilesContext()) {
+        if (provider->providerID() == Providers::ProviderID::LlamaCpp) {
+            for (const auto openedFilePath : m_contextManager->openedFiles({filePath})) {
+                if (!updatedContext.filesMetadata) {
+                    updatedContext.filesMetadata = QList<LLMCore::FileMetadata>();
+                }
+                updatedContext.filesMetadata->append({openedFilePath.first, openedFilePath.second});
+            }
+        } else {
+            systemPrompt.append(m_contextManager->openedFilesContext({filePath}));
+        }
+    }
+
+    updatedContext.systemPrompt = systemPrompt;
+
+    if (promptTemplate->type() == Templates::TemplateType::Chat) {
+        QString userMessage;
+        if (m_completeSettings.useUserMessageTemplateForCC()) {
+            userMessage = m_completeSettings.processMessageToFIM(
+                updatedContext.prefix.value_or(""), updatedContext.suffix.value_or(""));
+        } else {
+            userMessage = updatedContext.prefix.value_or("") + updatedContext.suffix.value_or("");
+        }
+
+        // TODO refactor add message
+        QVector<LLMCore::Message> messages;
+        messages.append({"user", userMessage});
+        updatedContext.history = messages;
+    }
+
+    provider->prepareRequest(
+        payload,
+        promptTemplate,
+        updatedContext,
+        LLMCore::RequestType::CodeCompletion,
+        false,
+        false);
+
+    connect(
+        provider->client(),
+        &::LLMQore::BaseClient::requestCompleted,
+        this,
+        &LLMClientInterface::handleFullResponse,
+        Qt::UniqueConnection);
+    connect(
+        provider->client(),
+        &::LLMQore::BaseClient::requestFinalized,
+        this,
+        &LLMClientInterface::handleRequestFinalized,
+        Qt::UniqueConnection);
+    connect(
+        provider->client(),
+        &::LLMQore::BaseClient::requestFailed,
+        this,
+        &LLMClientInterface::handleRequestFailed,
+        Qt::UniqueConnection);
+
+    provider->client()->setTransferTimeout(
+        static_cast<int>(m_generalSettings.requestTimeout() * 1000));
+
+    auto requestId
+        = provider->sendRequest(QUrl(url), payload, resolveEndpoint(promptTemplate, isPreset1Active));
+    m_activeRequests[requestId] = {request, provider};
+    m_performanceLogger.startTimeMeasurement(requestId);
+}
+
+LLMCore::ContextData LLMClientInterface::prepareContext(
+    const QJsonObject &request, const Context::DocumentInfo &documentInfo)
+{
+    QJsonObject params = request["params"].toObject();
+    QJsonObject doc = params["doc"].toObject();
+    QJsonObject position = doc["position"].toObject();
+    int cursorPosition = position["character"].toInt();
+    int lineNumber = position["line"].toInt();
+
+    Context::DocumentContextReader
+        reader(documentInfo.document, documentInfo.mimeType, documentInfo.filePath);
+    return reader.prepareContext(lineNumber, cursorPosition, m_completeSettings);
+}
+
+QString LLMClientInterface::resolveEndpoint(
+    Templates::PromptTemplate *promptTemplate, bool isLanguageSpecify) const
+{
+    const QString custom = isLanguageSpecify ? m_generalSettings.ccPreset1CustomEndpoint()
+                                             : m_generalSettings.ccCustomEndpoint();
+    return !custom.isEmpty() ? custom : promptTemplate->endpoint();
+}
+
+Context::ContextManager *LLMClientInterface::contextManager() const
+{
+    return m_contextManager;
+}
+
+void LLMClientInterface::sendCompletionToClient(
+    const QString &completion, const QJsonObject &request, bool isComplete)
+{
+    auto filePath = Context::extractFilePathFromRequest(request);
+    auto documentInfo = m_documentReader.readDocument(filePath);
+    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
+
+    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
+                                         : m_generalSettings.ccPreset1Template();
+
+    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
+
+    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response[LanguageServerProtocol::idKey] = request["id"];
+
+    QJsonObject result;
+    QJsonArray completions;
+    QJsonObject completionItem;
+
+    LOG_MESSAGE(QString("Completions before filter: \n%1").arg(completion));
+
+    QString outputHandler = m_completeSettings.modelOutputHandler.stringValue();
+    QString processedCompletion;
+
+    if (outputHandler == "Raw text") {
+        processedCompletion = completion;
+    } else if (outputHandler == "Force processing") {
+        processedCompletion = CodeHandler::processText(completion,
+                                                       Context::extractFilePathFromRequest(request));
+    } else { // "Auto"
+        processedCompletion = CodeHandler::hasCodeBlocks(completion)
+                                  ? CodeHandler::processText(completion,
+                                                             Context::extractFilePathFromRequest(
+                                                                 request))
+                                  : completion;
+    }
+
+    if (processedCompletion.endsWith('\n')) {
+        QString withoutTrailing = processedCompletion.chopped(1);
+        if (!withoutTrailing.contains('\n')) {
+            LOG_MESSAGE(QString("Removed trailing newline from single-line completion"));
+            processedCompletion = withoutTrailing;
+        }
+    }
+
+    completionItem[LanguageServerProtocol::textKey] = processedCompletion;
+    
+    QJsonObject range;
+    range["start"] = position;
+    range["end"] = position;
+    
+    completionItem[LanguageServerProtocol::rangeKey] = range;
+    completionItem[LanguageServerProtocol::positionKey] = position;
+    completions.append(completionItem);
+    result["completions"] = completions;
+    result[LanguageServerProtocol::isIncompleteKey] = !isComplete;
+    response[LanguageServerProtocol::resultKey] = result;
+
+    LOG_MESSAGE(
+        QString("Completions: \n%1")
+            .arg(QString::fromUtf8(QJsonDocument(completions).toJson(QJsonDocument::Indented))));
+
+    LOG_MESSAGE(
+        QString("Full response: \n%1")
+            .arg(QString::fromUtf8(QJsonDocument(response).toJson(QJsonDocument::Indented))));
+
+    QString requestId = request["id"].toString();
+    m_performanceLogger.endTimeMeasurement(requestId);
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+} // namespace QodeAssist

sources/completion/LLMClientInterface.hpp

@@ -0,0 +1,93 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <LLMQore/BaseClient.hpp>
+#include <languageclient/languageclientinterface.h>
+#include <texteditor/texteditor.h>
+
+#include <context/ContextManager.hpp>
+#include <context/IDocumentReader.hpp>
+#include <context/ProgrammingLanguage.hpp>
+#include "llmcore/ContextData.hpp"
+#include "templates/IPromptProvider.hpp"
+#include "providers/IProviderRegistry.hpp"
+#include <logger/IRequestPerformanceLogger.hpp>
+#include <settings/CodeCompletionSettings.hpp>
+#include <settings/GeneralSettings.hpp>
+
+class QNetworkReply;
+class QNetworkAccessManager;
+
+namespace QodeAssist {
+
+class LLMClientInterface : public LanguageClient::BaseClientInterface
+{
+    Q_OBJECT
+
+public:
+    LLMClientInterface(
+        const Settings::GeneralSettings &generalSettings,
+        const Settings::CodeCompletionSettings &completeSettings,
+        Providers::IProviderRegistry &providerRegistry,
+        Templates::IPromptProvider *promptProvider,
+        Context::IDocumentReader &documentReader,
+        IRequestPerformanceLogger &performanceLogger);
+    ~LLMClientInterface() override;
+
+    Utils::FilePath serverDeviceTemplate() const override;
+
+    void sendCompletionToClient(
+        const QString &completion, const QJsonObject &request, bool isComplete);
+
+    void handleCompletion(const QJsonObject &request);
+
+    // exposed for tests
+    void sendData(const QByteArray &data) override;
+
+    Context::ContextManager *contextManager() const;
+
+protected:
+    void startImpl() override;
+
+private slots:
+    void handleFullResponse(const QString &requestId, const QString &fullText);
+    void handleRequestFinalized(
+        const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info);
+    void handleRequestFailed(const QString &requestId, const QString &error);
+
+private:
+    void handleInitialize(const QJsonObject &request);
+    void handleShutdown(const QJsonObject &request);
+    void handleTextDocumentDidOpen(const QJsonObject &request);
+    void handleInitialized(const QJsonObject &request);
+    void handleExit(const QJsonObject &request);
+    void handleCancelRequest();
+    void sendErrorResponse(const QJsonObject &request, const QString &errorMessage);
+
+    struct RequestContext
+    {
+        QJsonObject originalRequest;
+        Providers::Provider *provider;
+    };
+
+    LLMCore::ContextData prepareContext(
+        const QJsonObject &request, const Context::DocumentInfo &documentInfo);
+
+    QString resolveEndpoint(
+        Templates::PromptTemplate *promptTemplate, bool isLanguageSpecify) const;
+
+    const Settings::CodeCompletionSettings &m_completeSettings;
+    const Settings::GeneralSettings &m_generalSettings;
+    Templates::IPromptProvider *m_promptProvider = nullptr;
+    Providers::IProviderRegistry &m_providerRegistry;
+    Context::IDocumentReader &m_documentReader;
+    IRequestPerformanceLogger &m_performanceLogger;
+    QElapsedTimer m_completionTimer;
+    Context::ContextManager *m_contextManager;
+    QHash<QString, RequestContext> m_activeRequests;
+};
+
+} // namespace QodeAssist

sources/completion/LLMSuggestion.cpp

@@ -0,0 +1,223 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "completion/LLMSuggestion.hpp"
+#include <texteditor/texteditor.h>
+#include <utils/stringutils.h>
+#include <utils/tooltip/tooltip.h>
+
+namespace QodeAssist {
+
+static bool isClosingTail(const QString &s, int from)
+{
+    static const QString closeChars = QStringLiteral("(){}[];,");
+    for (int i = from; i < s.size(); ++i) {
+        const QChar c = s.at(i);
+        if (!c.isSpace() && !closeChars.contains(c))
+            return false;
+    }
+    return true;
+}
+
+int LLMSuggestion::calculateReplaceLength(const QString &suggestion, const QString &rightText)
+{
+    if (rightText.isEmpty())
+        return 0;
+
+    const int maxN = qMin(suggestion.size(), rightText.size());
+    int lcp = 0;
+    while (lcp < maxN && suggestion.at(lcp) == rightText.at(lcp))
+        ++lcp;
+
+    if (lcp > 0) {
+        if (isClosingTail(rightText, lcp))
+            return rightText.size();
+        return lcp;
+    }
+
+    if (!isClosingTail(rightText, 0))
+        return 0;
+
+    static const QString closeChars = QStringLiteral("(){}[];,");
+    int i = suggestion.size() - 1;
+    while (i >= 0 && suggestion.at(i).isSpace())
+        --i;
+    if (i >= 0 && closeChars.contains(suggestion.at(i)) && rightText.contains(suggestion.at(i)))
+        return rightText.size();
+
+    return 0;
+}
+
+LLMSuggestion::LLMSuggestion(
+    const QList<Data> &suggestions, QTextDocument *sourceDocument, int currentCompletion)
+    : TextEditor::CyclicSuggestion(suggestions, sourceDocument, currentCompletion)
+{
+    const auto &data = suggestions[currentCompletion];
+
+    int startPos = data.range.begin.toPositionInDocument(sourceDocument);
+
+    startPos = qBound(0, startPos, sourceDocument->characterCount());
+
+    QTextCursor cursor(sourceDocument);
+    cursor.setPosition(startPos);
+    QTextBlock block = cursor.block();
+    QString blockText = block.text();
+
+    int cursorPositionInBlock = cursor.positionInBlock();
+    QString leftText = blockText.left(cursorPositionInBlock);
+    QString rightText = blockText.mid(cursorPositionInBlock);
+
+    QString suggestionText = data.text;
+
+    if (!suggestionText.contains('\n')) {
+        int replaceLength = calculateReplaceLength(suggestionText, rightText);
+        QString remainingRightText = (replaceLength > 0) ? rightText.mid(replaceLength) : rightText;
+
+        QString displayText = leftText + suggestionText + remainingRightText;
+        replacementDocument()->setPlainText(displayText);
+    } else {
+        int firstLineEnd = suggestionText.indexOf('\n');
+        QString firstLine = suggestionText.left(firstLineEnd);
+        QString restOfCompletion = suggestionText.mid(firstLineEnd);
+
+        int replaceLength = calculateReplaceLength(firstLine, rightText);
+        QString remainingRightText = (replaceLength > 0) ? rightText.mid(replaceLength) : rightText;
+
+        QString displayText = leftText + firstLine + remainingRightText + restOfCompletion;
+        replacementDocument()->setPlainText(displayText);
+    }
+}
+
+bool LLMSuggestion::applyWord(TextEditor::TextEditorWidget *widget)
+{
+    return applyPart(Word, widget);
+}
+
+bool LLMSuggestion::applyLine(TextEditor::TextEditorWidget *widget)
+{
+    return applyPart(Line, widget);
+}
+
+bool LLMSuggestion::applyPart(Part part, TextEditor::TextEditorWidget *widget)
+{
+    const auto &currentSuggestions = suggestions();
+    const auto &currentData = currentSuggestions[currentSuggestion()];
+    const Utils::Text::Range range = currentData.range;
+    const QTextCursor cursor = range.begin.toTextCursor(sourceDocument());
+    QTextCursor currentCursor = widget->textCursor();
+    const QString text = currentData.text;
+
+    const int startPos = currentCursor.positionInBlock() - cursor.positionInBlock()
+                         + (cursor.selectionEnd() - cursor.selectionStart());
+
+    int next = part == Word ? Utils::endOfNextWord(text, startPos) : text.indexOf('\n', startPos);
+
+    if (next == -1) {
+        if (part == Line) {
+            next = text.length();
+        } else {
+            return apply();
+        }
+    }
+
+    if (part == Line)
+        ++next;
+
+    QString subText = text.mid(startPos, next - startPos);
+
+    if (subText.isEmpty()) {
+        return false;
+    }
+
+    if (startPos == 0) {
+        QTextBlock currentBlock = cursor.block();
+        QString textAfterCursor = currentBlock.text().mid(cursor.positionInBlock());
+
+        int replaceLength = calculateReplaceLength(text, textAfterCursor);
+
+        if (replaceLength > 0) {
+            currentCursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, replaceLength);
+            currentCursor.removeSelectedText();
+        }
+    }
+
+    if (!subText.contains('\n')) {
+        currentCursor.insertText(subText);
+
+        const QString remainingText = text.mid(next);
+        if (!remainingText.isEmpty()) {
+            QTextCursor newCursor = widget->textCursor();
+            const Utils::Text::Position newStart = Utils::Text::Position::fromPositionInDocument(
+                newCursor.document(), newCursor.position());
+            const Utils::Text::Position
+                newEnd{newStart.line, newStart.column + int(remainingText.length())};
+            const Utils::Text::Range newRange{newStart, newEnd};
+            const QList<Data> newSuggestion{{newRange, newStart, remainingText}};
+            widget->insertSuggestion(
+                std::make_unique<LLMSuggestion>(newSuggestion, widget->document(), 0));
+        }
+    } else {
+        currentCursor.insertText(subText);
+
+        if (const int seperatorPos = subText.lastIndexOf('\n'); seperatorPos >= 0) {
+            const QString newCompletionText = text.mid(startPos + seperatorPos + 1);
+            if (!newCompletionText.isEmpty()) {
+                const Utils::Text::Position newStart{int(range.begin.line + subText.count('\n')), 0};
+                const Utils::Text::Position newEnd{newStart.line, int(newCompletionText.length())};
+                const Utils::Text::Range newRange{newStart, newEnd};
+                const QList<Data> newSuggestion{{newRange, newEnd, newCompletionText}};
+                widget->insertSuggestion(
+                    std::make_unique<LLMSuggestion>(newSuggestion, widget->document(), 0));
+            }
+        }
+    }
+
+    return false;
+}
+
+bool LLMSuggestion::apply()
+{
+    const auto &currentSuggestions = suggestions();
+    const auto &currentData = currentSuggestions[currentSuggestion()];
+    const Utils::Text::Range range = currentData.range;
+    const QTextCursor cursor = range.begin.toTextCursor(sourceDocument());
+    QString text = currentData.text;
+
+    QTextBlock currentBlock = cursor.block();
+    QString textAfterCursor = currentBlock.text().mid(cursor.positionInBlock());
+
+    QTextCursor editCursor = cursor;
+    editCursor.beginEditBlock();
+
+    int firstLineEnd = text.indexOf('\n');
+    if (firstLineEnd != -1) {
+        QString firstLine = text.left(firstLineEnd);
+        QString restOfText = text.mid(firstLineEnd);
+
+        int replaceLength = calculateReplaceLength(firstLine, textAfterCursor);
+
+        if (replaceLength > 0) {
+            editCursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, replaceLength);
+            editCursor.removeSelectedText();
+        }
+
+        editCursor.insertText(firstLine + restOfText);
+    } else {
+        int replaceLength = calculateReplaceLength(text, textAfterCursor);
+
+        if (replaceLength > 0) {
+            editCursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, replaceLength);
+            editCursor.removeSelectedText();
+        }
+
+        editCursor.insertText(text);
+    }
+
+    editCursor.endEditBlock();
+    return true;
+}
+
+} // namespace QodeAssist
+

sources/completion/LLMSuggestion.hpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024-2026 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+ */
+
+#pragma once
+
+#include <texteditor/texteditor.h>
+#include <texteditor/textsuggestion.h>
+
+namespace QodeAssist {
+
+class LLMSuggestion : public TextEditor::CyclicSuggestion
+{
+public:
+    enum Part { Word, Line };
+
+    LLMSuggestion(
+        const QList<Data> &suggestions, QTextDocument *sourceDocument, int currentCompletion = 0);
+
+    bool applyWord(TextEditor::TextEditorWidget *widget) override;
+    bool applyLine(TextEditor::TextEditorWidget *widget) override;
+    bool applyPart(Part part, TextEditor::TextEditorWidget *widget);
+    bool apply() override;
+
+    static int calculateReplaceLength(const QString &suggestion, const QString &rightText);
+};
+} // namespace QodeAssist

sources/completion/LSPCompletion.hpp

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024-2026 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+ */
+
+#pragma once
+
+#include <languageserverprotocol/jsonkeys.h>
+#include <languageserverprotocol/jsonrpcmessages.h>
+#include <languageserverprotocol/lsptypes.h>
+
+namespace QodeAssist {
+
+class Completion : public LanguageServerProtocol::JsonObject
+{
+    static constexpr LanguageServerProtocol::Key displayTextKey{"displayText"};
+    static constexpr LanguageServerProtocol::Key uuidKey{"uuid"};
+
+public:
+    using JsonObject::JsonObject;
+
+    QString displayText() const { return typedValue<QString>(displayTextKey); }
+    LanguageServerProtocol::Position position() const
+    {
+        return typedValue<LanguageServerProtocol::Position>(LanguageServerProtocol::positionKey);
+    }
+    void setRange(const LanguageServerProtocol::Range &range)
+    {
+        insert(LanguageServerProtocol::rangeKey, range);
+    }
+    LanguageServerProtocol::Range range() const
+    {
+        return typedValue<LanguageServerProtocol::Range>(LanguageServerProtocol::rangeKey);
+    }
+    QString text() const { return typedValue<QString>(LanguageServerProtocol::textKey); }
+    void setText(const QString &text) { insert(LanguageServerProtocol::textKey, text); }
+    QString uuid() const { return typedValue<QString>(uuidKey); }
+
+    bool isValid() const override
+    {
+        return contains(LanguageServerProtocol::textKey)
+               && contains(LanguageServerProtocol::rangeKey)
+               && contains(LanguageServerProtocol::positionKey);
+    }
+};
+
+class GetCompletionParams : public LanguageServerProtocol::JsonObject
+{
+public:
+    static constexpr LanguageServerProtocol::Key docKey{"doc"};
+
+    GetCompletionParams(
+        const LanguageServerProtocol::TextDocumentIdentifier &document,
+        int version,
+        const LanguageServerProtocol::Position &position)
+    {
+        setTextDocument(document);
+        setVersion(version);
+        setPosition(position);
+    }
+    using JsonObject::JsonObject;
+
+    // The text document.
+    LanguageServerProtocol::TextDocumentIdentifier textDocument() const
+    {
+        return typedValue<LanguageServerProtocol::TextDocumentIdentifier>(docKey);
+    }
+    void setTextDocument(const LanguageServerProtocol::TextDocumentIdentifier &id)
+    {
+        insert(docKey, id);
+    }
+
+    // The position inside the text document.
+    LanguageServerProtocol::Position position() const
+    {
+        return LanguageServerProtocol::fromJsonValue<LanguageServerProtocol::Position>(
+            value(docKey).toObject().value(LanguageServerProtocol::positionKey));
+    }
+    void setPosition(const LanguageServerProtocol::Position &position)
+    {
+        QJsonObject result = value(docKey).toObject();
+        result[LanguageServerProtocol::positionKey] = (QJsonObject) position;
+        insert(docKey, result);
+    }
+
+    // The version
+    int version() const { return typedValue<int>(LanguageServerProtocol::versionKey); }
+    void setVersion(int version)
+    {
+        QJsonObject result = value(docKey).toObject();
+        result[LanguageServerProtocol::versionKey] = version;
+        insert(docKey, result);
+    }
+
+    bool isValid() const override
+    {
+        return contains(docKey)
+               && value(docKey).toObject().contains(LanguageServerProtocol::positionKey)
+               && value(docKey).toObject().contains(LanguageServerProtocol::versionKey);
+    }
+};
+
+class GetCompletionResponse : public LanguageServerProtocol::JsonObject
+{
+    static constexpr LanguageServerProtocol::Key completionKey{"completions"};
+
+public:
+    using JsonObject::JsonObject;
+
+    LanguageServerProtocol::LanguageClientArray<Completion> completions() const
+    {
+        return clientArray<Completion>(completionKey);
+    }
+};
+
+class GetCompletionRequest
+    : public LanguageServerProtocol::Request<GetCompletionResponse, std::nullptr_t, GetCompletionParams>
+{
+public:
+    explicit GetCompletionRequest(const GetCompletionParams &params = {})
+        : Request(methodName, params)
+    {}
+    using Request::Request;
+    constexpr static const LanguageServerProtocol::Key methodName{"getCompletionsCycling"};
+};
+} // namespace QodeAssist

sources/completion/QodeAssistClient.cpp

@@ -0,0 +1,730 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024-2026 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+ */
+
+#include "completion/QodeAssistClient.hpp"
+
+#include <QApplication>
+#include <QInputDialog>
+#include <QKeyEvent>
+#include <QTimer>
+
+#include <coreplugin/icore.h>
+#include <languageclient/languageclientsettings.h>
+#include <projectexplorer/projectmanager.h>
+
+#include "completion/LLMClientInterface.hpp"
+#include "completion/LLMSuggestion.hpp"
+#include "refactor/RefactorSuggestion.hpp"
+#include "refactor/RefactorSuggestionHoverHandler.hpp"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
+#include "settings/ProjectSettings.hpp"
+#include "settings/QuickRefactorSettings.hpp"
+#include "widgets/RefactorWidgetHandler.hpp"
+#include "refactor/RefactorContextHelper.hpp"
+#include <context/ChangesManager.h>
+#include <logger/Logger.hpp>
+
+using namespace LanguageServerProtocol;
+using namespace TextEditor;
+using namespace Utils;
+using namespace ProjectExplorer;
+using namespace Core;
+
+namespace QodeAssist {
+
+namespace {
+Utils::Text::Position toTextPos(const Utils::Text::Position &pos)
+{
+    return Utils::Text::Position{pos.line, pos.column};
+}
+
+bool isIdentifierChar(QChar c)
+{
+    return c.isLetterOrNumber() || c == QLatin1Char('_');
+}
+
+bool isInsideIdentifier(const QTextCursor &cursor)
+{
+    const QTextBlock block = cursor.block();
+    const int col = cursor.positionInBlock();
+    const QString text = block.text();
+    if (col <= 0 || col > text.size())
+        return false;
+    if (!isIdentifierChar(text.at(col - 1)))
+        return false;
+    return col < text.size() && isIdentifierChar(text.at(col));
+}
+
+bool isAfterMemberAccess(const QTextCursor &cursor)
+{
+    const QTextBlock block = cursor.block();
+    const int col = cursor.positionInBlock();
+    const QString text = block.text();
+    if (col <= 0)
+        return false;
+
+    int i = col - 1;
+    while (i >= 0 && isIdentifierChar(text.at(i)))
+        --i;
+
+    if (i < 0)
+        return false;
+
+    const QChar c = text.at(i);
+    if (c == QLatin1Char('.'))
+        return true;
+    if (c == QLatin1Char('>') && i >= 1 && text.at(i - 1) == QLatin1Char('-'))
+        return true;
+    if (c == QLatin1Char(':') && i >= 1 && text.at(i - 1) == QLatin1Char(':'))
+        return true;
+    return false;
+}
+
+bool isFreshIndentedLine(const QTextCursor &cursor)
+{
+    const QTextBlock block = cursor.block();
+    const int col = cursor.positionInBlock();
+    if (col == 0)
+        return false;
+    const QString leftText = block.text().left(col);
+    for (const QChar &ch : leftText) {
+        if (!ch.isSpace())
+            return false;
+    }
+    return true;
+}
+
+bool isAfterEagerTrigger(const QTextCursor &cursor)
+{
+    const QTextBlock block = cursor.block();
+    const int col = cursor.positionInBlock();
+    const QString text = block.text();
+    int i = col - 1;
+    while (i >= 0 && text.at(i).isSpace())
+        --i;
+    if (i < 0)
+        return false;
+    const QChar c = text.at(i);
+    return c == QLatin1Char('{') || c == QLatin1Char('(') || c == QLatin1Char(',')
+           || c == QLatin1Char('=') || c == QLatin1Char('[') || c == QLatin1Char(';')
+           || c == QLatin1Char(':') || c == QLatin1Char('>');
+}
+
+bool isManualMode()
+{
+    return Settings::codeCompletionSettings().completionMode.stringValue() == "Manual";
+}
+} // anonymous namespace
+
+QodeAssistClient::QodeAssistClient(LLMClientInterface *clientInterface)
+    : LanguageClient::Client(clientInterface)
+    , m_llmClient(clientInterface)
+    , m_recentCharCount(0)
+{
+    setName("QodeAssist");
+    LanguageClient::LanguageFilter filter;
+    filter.mimeTypes = QStringList() << "*";
+    setSupportedLanguage(filter);
+
+    start();
+    setupConnections();
+
+    m_typingTimer.start();
+
+    m_refactorHoverHandler = new RefactorSuggestionHoverHandler();
+    m_refactorWidgetHandler = new RefactorWidgetHandler(this);
+}
+
+QodeAssistClient::~QodeAssistClient()
+{
+    cleanupConnections();
+    delete m_refactorHoverHandler;
+    delete m_refactorWidgetHandler;
+}
+
+void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
+{
+    auto project = ProjectManager::projectForFile(document->filePath());
+    if (!isEnabled(project))
+        return;
+
+    Client::openDocument(document);
+
+    auto editors = TextEditor::BaseTextEditor::textEditorsForDocument(document);
+    for (auto *editor : editors) {
+        if (auto *widget = editor->editorWidget()) {
+            widget->addHoverHandler(m_refactorHoverHandler);
+            widget->installEventFilter(this);
+        }
+    }
+
+    connect(
+        document,
+        &TextDocument::contentsChangedWithPosition,
+        this,
+        [this, document](int position, int charsRemoved, int charsAdded) {
+            if (!Settings::codeCompletionSettings().autoCompletion())
+                return;
+
+            if (isManualMode())
+                return;
+
+            auto project = ProjectManager::projectForFile(document->filePath());
+            if (!isEnabled(project))
+                return;
+
+            auto textEditor = BaseTextEditor::currentTextEditor();
+            if (!textEditor || textEditor->document() != document)
+                return;
+
+            if (Settings::codeCompletionSettings().useProjectChangesCache())
+                Context::ChangesManager::instance()
+                    .addChange(document, position, charsRemoved, charsAdded);
+
+            TextEditorWidget *widget = textEditor->editorWidget();
+            if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
+                return;
+
+            const int cursorPosition = widget->textCursor().position();
+            if (cursorPosition < position || cursorPosition > position + charsAdded)
+                return;
+
+            if (charsRemoved > 0 || charsAdded <= 0) {
+                m_recentCharCount = 0;
+                m_typingTimer.restart();
+                return;
+            }
+
+            QTextCursor cursor = widget->textCursor();
+            cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor, 1);
+            const QString lastChar = cursor.selectedText();
+            if (lastChar.isEmpty())
+                return;
+
+            const QChar lastCh = lastChar[0];
+            if (lastCh == QLatin1Char('\n') || lastCh == QChar::ParagraphSeparator
+                || lastCh == QChar::LineSeparator) {
+                m_recentCharCount = 0;
+                m_typingTimer.restart();
+                return;
+            }
+
+            const bool isSpaceOrTab = lastCh.isSpace();
+            const bool ignoreWhitespace
+                = Settings::codeCompletionSettings().ignoreWhitespaceInCharCount();
+
+            if (!ignoreWhitespace || !isSpaceOrTab)
+                m_recentCharCount += charsAdded;
+
+            if (m_typingTimer.elapsed()
+                > Settings::codeCompletionSettings().autoCompletionTypingInterval()) {
+                m_recentCharCount = (ignoreWhitespace && isSpaceOrTab) ? 0 : charsAdded;
+                m_typingTimer.restart();
+            }
+
+            handleAutoRequestTrigger(widget);
+        });
+}
+
+bool QodeAssistClient::canOpenProject(ProjectExplorer::Project *project)
+{
+    return isEnabled(project);
+}
+
+void QodeAssistClient::requestCompletions(TextEditor::TextEditorWidget *editor)
+{
+    auto project = ProjectManager::projectForFile(editor->textDocument()->filePath());
+
+    if (!isEnabled(project))
+        return;
+
+
+    if (m_llmClient->contextManager()
+            ->ignoreManager()
+            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+        LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
+                        .arg(editor->textDocument()->filePath().toUrlishString()));
+        return;
+    }
+
+    MultiTextCursor cursor = editor->multiTextCursor();
+    if (cursor.hasMultipleCursors() || cursor.hasSelection() || editor->suggestionVisible())
+        return;
+
+    const auto &settings = Settings::codeCompletionSettings();
+    if (settings.abortAssistOnRequest() && !settings.respectQtcPopup())
+        editor->abortAssist();
+
+    const FilePath filePath = editor->textDocument()->filePath();
+    GetCompletionRequest request{
+        {TextDocumentIdentifier(hostPathToServerUri(filePath)),
+         documentVersion(filePath),
+         Position(cursor.mainCursor())}};
+    if (Settings::codeCompletionSettings().showProgressWidget()) {
+        m_progressHandler.setCancelCallback([this, editor = QPointer<TextEditorWidget>(editor)]() {
+            if (editor) {
+                cancelRunningRequest(editor);
+            }
+        });
+        m_progressHandler.showProgress(editor);
+    }
+    request.setResponseCallback([this, editor = QPointer<TextEditorWidget>(editor)](
+                                    const GetCompletionRequest::Response &response) {
+        QTC_ASSERT(editor, return);
+        handleCompletions(response, editor);
+    });
+    m_runningRequests[editor] = request;
+    sendMessage(request);
+}
+
+void QodeAssistClient::requestQuickRefactor(
+    TextEditor::TextEditorWidget *editor, const QString &instructions)
+{
+    auto project = ProjectManager::projectForFile(editor->textDocument()->filePath());
+
+    if (!isEnabled(project))
+        return;
+
+    if (m_llmClient->contextManager()
+            ->ignoreManager()
+            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+        LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
+                        .arg(editor->textDocument()->filePath().toUrlishString()));
+        return;
+    }
+
+    if (!m_refactorHandler) {
+        m_refactorHandler = new QuickRefactorHandler(this);
+        connect(
+            m_refactorHandler,
+            &QuickRefactorHandler::refactoringCompleted,
+            this,
+            &QodeAssistClient::handleRefactoringResult);
+    }
+
+    m_progressHandler.setCancelCallback([this, editor = QPointer<TextEditorWidget>(editor)]() {
+        if (editor && m_refactorHandler) {
+            m_refactorHandler->cancelRequest();
+            m_progressHandler.hideProgress();
+        }
+    });
+    m_progressHandler.showProgress(editor);
+    m_refactorHandler->sendRefactorRequest(editor, instructions);
+}
+
+void QodeAssistClient::scheduleRequest(TextEditor::TextEditorWidget *editor)
+{
+    if (m_runningRequests.contains(editor)) {
+        if (Settings::codeCompletionSettings().cancelOnInput())
+            cancelRunningRequest(editor);
+        else
+            return;
+    }
+
+    auto it = m_scheduledRequests.find(editor);
+    if (it == m_scheduledRequests.end()) {
+        auto timer = new QTimer(this);
+        timer->setSingleShot(true);
+        connect(timer, &QTimer::timeout, this, [this, editor]() {
+            if (!editor || m_runningRequests.contains(editor))
+                return;
+            if (editor->textCursor().position()
+                    != m_scheduledRequests[editor]->property("cursorPosition").toInt())
+                return;
+            requestCompletions(editor);
+        });
+        connect(editor, &TextEditorWidget::destroyed, this, [this, editor]() {
+            delete m_scheduledRequests.take(editor);
+            cancelRunningRequest(editor);
+        });
+        it = m_scheduledRequests.insert(editor, timer);
+    }
+
+    it.value()->setProperty("cursorPosition", editor->textCursor().position());
+    it.value()->start(Settings::codeCompletionSettings().startSuggestionTimer());
+}
+void QodeAssistClient::handleCompletions(
+    const GetCompletionRequest::Response &response, TextEditor::TextEditorWidget *editor)
+{
+    m_progressHandler.hideProgress();
+    const auto &settings = Settings::codeCompletionSettings();
+    if (settings.abortAssistOnRequest() && !settings.respectQtcPopup())
+        editor->abortAssist();
+
+    if (response.error()) {
+        log(*response.error());
+        m_errorHandler
+            .showError(editor, tr("Code completion failed: %1").arg(response.error()->message()));
+        return;
+    }
+
+    int requestPosition = -1;
+    if (const auto requestParams = m_runningRequests.take(editor).params())
+        requestPosition = requestParams->position().toPositionInDocument(editor->document());
+
+    const MultiTextCursor cursors = editor->multiTextCursor();
+    if (cursors.hasMultipleCursors() || cursors.hasSelection())
+        return;
+
+    const int currentPosition = cursors.mainCursor().position();
+    if (requestPosition < 0 || currentPosition < requestPosition)
+        return;
+
+    QString typedSinceRequest;
+    if (currentPosition > requestPosition) {
+        QTextCursor diffCursor(editor->document());
+        diffCursor.setPosition(requestPosition);
+        diffCursor.setPosition(currentPosition, QTextCursor::KeepAnchor);
+        typedSinceRequest = diffCursor.selectedText();
+        if (typedSinceRequest.contains(QChar::ParagraphSeparator)
+            || typedSinceRequest.contains(QLatin1Char('\n'))) {
+            return;
+        }
+    }
+
+    if (const std::optional<GetCompletionResponse> result = response.result()) {
+        auto isValidCompletion = [](const Completion &completion) {
+            return completion.isValid() && !completion.text().trimmed().isEmpty();
+        };
+        QList<Completion> completions
+            = Utils::filtered(result->completions().toListOrEmpty(), isValidCompletion);
+
+        QList<Completion> matchedCompletions;
+        matchedCompletions.reserve(completions.size());
+        for (Completion &completion : completions) {
+            const LanguageServerProtocol::Range range = completion.range();
+            if (range.start().line() != range.end().line())
+                continue;
+
+            QString completionText = completion.text();
+            const int end = int(completionText.size()) - 1;
+            int delta = 0;
+            while (delta <= end && completionText[end - delta].isSpace())
+                ++delta;
+            if (delta > 0)
+                completionText.chop(delta);
+
+            if (!typedSinceRequest.isEmpty()) {
+                if (!completionText.startsWith(typedSinceRequest))
+                    continue;
+                completionText = completionText.mid(typedSinceRequest.size());
+                if (completionText.isEmpty())
+                    continue;
+            }
+
+            completion.setText(completionText);
+            matchedCompletions.append(completion);
+        }
+
+        if (matchedCompletions.isEmpty()) {
+            LOG_MESSAGE("No valid completions received");
+            return;
+        }
+
+        const Text::Position anchor = typedSinceRequest.isEmpty()
+            ? Text::Position{}
+            : Text::Position::fromPositionInDocument(editor->document(), currentPosition);
+        const bool useAnchor = !typedSinceRequest.isEmpty();
+
+        auto suggestions = Utils::transform(matchedCompletions,
+                                            [useAnchor, &anchor](const Completion &c) {
+            auto toTextPos = [](const LanguageServerProtocol::Position pos) {
+                return Text::Position{pos.line() + 1, pos.character()};
+            };
+
+            if (useAnchor) {
+                return TextSuggestion::Data{Text::Range{anchor, anchor}, anchor, c.text()};
+            }
+
+            Text::Range range{toTextPos(c.range().start()), toTextPos(c.range().end())};
+            Text::Position pos{toTextPos(c.position())};
+            return TextSuggestion::Data{range, pos, c.text()};
+        });
+
+        editor->insertSuggestion(std::make_unique<LLMSuggestion>(suggestions, editor->document()));
+    }
+}
+
+void QodeAssistClient::cancelRunningRequest(TextEditor::TextEditorWidget *editor)
+{
+    const auto it = m_runningRequests.constFind(editor);
+    if (it == m_runningRequests.constEnd())
+        return;
+    m_progressHandler.hideProgress();
+    cancelRequest(it->id());
+    m_runningRequests.erase(it);
+}
+
+bool QodeAssistClient::isEnabled(ProjectExplorer::Project *project) const
+{
+    if (!project)
+        return Settings::generalSettings().enableQodeAssist();
+
+    Settings::ProjectSettings settings(project);
+    return settings.isEnabled();
+}
+
+void QodeAssistClient::setupConnections()
+{
+    auto openDoc = [this](IDocument *document) {
+        if (auto *textDocument = qobject_cast<TextDocument *>(document))
+            openDocument(textDocument);
+    };
+
+    m_documentOpenedConnection
+        = connect(EditorManager::instance(), &EditorManager::documentOpened, this, openDoc);
+    m_documentClosedConnection = connect(
+        EditorManager::instance(), &EditorManager::documentClosed, this, [this](IDocument *document) {
+            if (auto textDocument = qobject_cast<TextDocument *>(document))
+                closeDocument(textDocument);
+        });
+
+    for (IDocument *doc : DocumentModel::openedDocuments())
+        openDoc(doc);
+}
+
+void QodeAssistClient::cleanupConnections()
+{
+    disconnect(m_documentOpenedConnection);
+    disconnect(m_documentClosedConnection);
+
+    qDeleteAll(m_scheduledRequests);
+    m_scheduledRequests.clear();
+}
+
+void QodeAssistClient::handleRefactoringResult(const RefactorResult &result)
+{
+    m_progressHandler.hideProgress();
+
+    if (!result.success) {
+        QString errorMessage = result.errorMessage.isEmpty()
+                                   ? tr("Quick refactor failed")
+                                   : tr("Quick refactor failed: %1").arg(result.errorMessage);
+
+        if (result.editor) {
+            m_errorHandler.showError(result.editor, errorMessage);
+        }
+
+        LOG_MESSAGE(QString("Refactoring failed: %1").arg(result.errorMessage));
+        return;
+    }
+
+    if (!result.editor) {
+        LOG_MESSAGE("Refactoring result has no editor");
+        return;
+    }
+
+    int displayMode = Settings::quickRefactorSettings().displayMode();
+    
+    if (displayMode == 0) {
+        displayRefactoringWidget(result);
+    } else {
+        displayRefactoringSuggestion(result);
+    }
+}
+
+void QodeAssistClient::displayRefactoringSuggestion(const RefactorResult &result)
+{
+    TextEditorWidget *editorWidget = result.editor;
+
+    Utils::Text::Range range{toTextPos(result.insertRange.begin), toTextPos(result.insertRange.end)};
+    Utils::Text::Position pos = toTextPos(result.insertRange.begin);
+
+    int startPos = range.begin.toPositionInDocument(editorWidget->document());
+    int endPos = range.end.toPositionInDocument(editorWidget->document());
+
+    if (startPos != endPos) {
+        QTextCursor startCursor(editorWidget->document());
+        startCursor.setPosition(startPos);
+        if (startCursor.positionInBlock() > 0) {
+            startCursor.movePosition(QTextCursor::StartOfBlock);
+        }
+
+        QTextCursor endCursor(editorWidget->document());
+        endCursor.setPosition(endPos);
+        if (endCursor.positionInBlock() > 0) {
+            endCursor.movePosition(QTextCursor::EndOfBlock);
+            if (!endCursor.atEnd()) {
+                endCursor.movePosition(QTextCursor::NextCharacter);
+            }
+        }
+
+        Utils::Text::Position expandedBegin = Utils::Text::Position::fromPositionInDocument(
+            editorWidget->document(), startCursor.position());
+        Utils::Text::Position expandedEnd = Utils::Text::Position::fromPositionInDocument(
+            editorWidget->document(), endCursor.position());
+
+        range = Utils::Text::Range(expandedBegin, expandedEnd);
+    }
+
+    TextEditor::TextSuggestion::Data suggestionData{
+        Utils::Text::Range{toTextPos(result.insertRange.begin), toTextPos(result.insertRange.end)},
+        pos,
+        result.newText};
+    editorWidget->insertSuggestion(
+        std::make_unique<RefactorSuggestion>(suggestionData, editorWidget->document()));
+
+    m_refactorHoverHandler->setSuggestionRange(range);
+
+    m_refactorHoverHandler->setApplyCallback([this, editorWidget]() {
+        QKeyEvent tabEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::NoModifier);
+        QApplication::sendEvent(editorWidget, &tabEvent);
+        m_refactorHoverHandler->clearSuggestionRange();
+    });
+
+    m_refactorHoverHandler->setDismissCallback([this, editorWidget]() {
+        editorWidget->clearSuggestion();
+        m_refactorHoverHandler->clearSuggestionRange();
+    });
+
+    LOG_MESSAGE("Displaying refactoring suggestion with hover handler");
+}
+
+void QodeAssistClient::displayRefactoringWidget(const RefactorResult &result)
+{
+    TextEditorWidget *editorWidget = result.editor;
+    Utils::Text::Range range{toTextPos(result.insertRange.begin), toTextPos(result.insertRange.end)};
+    
+    RefactorContext ctx = RefactorContextHelper::extractContext(editorWidget, range);
+    
+    QString displayOriginal;
+    QString displayRefactored;
+    QString textToApply = result.newText;
+    
+    if (ctx.isInsertion) {
+        bool isMultiline = result.newText.contains('\n');
+        
+        if (isMultiline) {
+            displayOriginal = ctx.textBeforeCursor;
+            displayRefactored = ctx.textBeforeCursor + result.newText;
+        } else {
+            displayOriginal = ctx.textBeforeCursor + ctx.textAfterCursor;
+            displayRefactored = ctx.textBeforeCursor + result.newText + ctx.textAfterCursor;
+        }
+        
+        if (!ctx.textBeforeCursor.isEmpty() || !ctx.textAfterCursor.isEmpty()) {
+            textToApply = result.newText;
+        }
+    } else {
+        displayOriginal = ctx.originalText;
+        displayRefactored = result.newText;
+    }
+
+    m_refactorWidgetHandler->setApplyCallback([this, editorWidget, result](const QString &editedText) {
+        applyRefactoringEdit(editorWidget, result.insertRange, editedText);
+    });
+
+    m_refactorWidgetHandler->setDeclineCallback([]() {});
+
+    m_refactorWidgetHandler->showRefactorWidget(
+        editorWidget, displayOriginal, displayRefactored, range,
+        ctx.contextBefore, ctx.contextAfter);
+    
+    m_refactorWidgetHandler->setTextToApply(textToApply);
+}
+
+void QodeAssistClient::applyRefactoringEdit(TextEditor::TextEditorWidget *editor,
+                                             const Utils::Text::Range &range,
+                                             const QString &text)
+{
+    const QTextCursor startCursor = range.begin.toTextCursor(editor->document());
+    const QTextCursor endCursor = range.end.toTextCursor(editor->document());
+    const int startPos = startCursor.position();
+    const int endPos = endCursor.position();
+    
+    QTextCursor editCursor(editor->document());
+    editCursor.beginEditBlock();
+
+    if (startPos == endPos) {
+        bool isMultiline = text.contains('\n');
+        editCursor.setPosition(startPos);
+        
+        if (isMultiline) {
+            editCursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
+            editCursor.removeSelectedText();
+        }
+        
+        editCursor.insertText(text);
+    } else {
+        editCursor.setPosition(startPos);
+        editCursor.setPosition(endPos, QTextCursor::KeepAnchor);
+        editCursor.removeSelectedText();
+        editCursor.insertText(text);
+    }
+
+    editCursor.endEditBlock();
+}
+
+void QodeAssistClient::handleAutoRequestTrigger(TextEditor::TextEditorWidget *widget)
+{
+    const QTextCursor cursor = widget->textCursor();
+    const auto &settings = Settings::codeCompletionSettings();
+    const bool smart = settings.smartContextTrigger();
+
+    if (smart && (isInsideIdentifier(cursor) || isAfterMemberAccess(cursor)))
+        return;
+
+    const bool eager = smart && (isFreshIndentedLine(cursor) || isAfterEagerTrigger(cursor));
+    const int charThreshold = settings.autoCompletionCharThreshold();
+
+    if (eager || m_recentCharCount > charThreshold)
+        scheduleRequest(widget);
+}
+
+bool QodeAssistClient::eventFilter(QObject *watched, QEvent *event)
+{
+    auto *editor = qobject_cast<TextEditor::TextEditorWidget *>(watched);
+    if (!editor)
+        return LanguageClient::Client::eventFilter(watched, event);
+
+    if (event->type() == QEvent::KeyPress) {
+        auto *keyEvent = static_cast<QKeyEvent *>(event);
+
+        if (keyEvent->key() == Qt::Key_Escape) {
+            if (m_runningRequests.contains(editor)) {
+                cancelRunningRequest(editor);
+            }
+
+            if (m_scheduledRequests.contains(editor)) {
+                auto *timer = m_scheduledRequests.value(editor);
+                if (timer && timer->isActive()) {
+                    timer->stop();
+                }
+            }
+
+            if (m_refactorHandler && m_refactorHandler->isProcessing()) {
+                m_refactorHandler->cancelRequest();
+            }
+
+            m_progressHandler.hideProgress();
+        }
+    }
+
+    return LanguageClient::Client::eventFilter(watched, event);
+}
+
+} // namespace QodeAssist

sources/completion/QodeAssistClient.hpp

@@ -0,0 +1,73 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QObject>
+
+#include "completion/LLMClientInterface.hpp"
+#include "completion/LSPCompletion.hpp"
+#include "refactor/QuickRefactorHandler.hpp"
+#include "refactor/RefactorSuggestionHoverHandler.hpp"
+#include "widgets/CompletionProgressHandler.hpp"
+#include "widgets/CompletionErrorHandler.hpp"
+#include "widgets/EditorChatButtonHandler.hpp"
+#include "widgets/RefactorWidgetHandler.hpp"
+#include <languageclient/client.h>
+#include "templates/IPromptProvider.hpp"
+#include "providers/IProviderRegistry.hpp"
+
+namespace QodeAssist {
+
+class QodeAssistClient : public LanguageClient::Client
+{
+    Q_OBJECT
+public:
+    explicit QodeAssistClient(LLMClientInterface *clientInterface);
+    ~QodeAssistClient() override;
+
+    void openDocument(TextEditor::TextDocument *document) override;
+    bool canOpenProject(ProjectExplorer::Project *project) override;
+
+    void requestCompletions(TextEditor::TextEditorWidget *editor);
+    void requestQuickRefactor(
+        TextEditor::TextEditorWidget *editor, const QString &instructions = QString());
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event) override;
+
+private:
+    void scheduleRequest(TextEditor::TextEditorWidget *editor);
+    void handleCompletions(
+        const GetCompletionRequest::Response &response, TextEditor::TextEditorWidget *editor);
+    void cancelRunningRequest(TextEditor::TextEditorWidget *editor);
+    bool isEnabled(ProjectExplorer::Project *project) const;
+
+    void setupConnections();
+    void cleanupConnections();
+    void handleRefactoringResult(const RefactorResult &result);
+    void displayRefactoringSuggestion(const RefactorResult &result);
+    void displayRefactoringWidget(const RefactorResult &result);
+    void applyRefactoringEdit(TextEditor::TextEditorWidget *editor, const Utils::Text::Range &range, const QString &text);
+
+    void handleAutoRequestTrigger(TextEditor::TextEditorWidget *widget);
+
+    QHash<TextEditor::TextEditorWidget *, GetCompletionRequest> m_runningRequests;
+    QHash<TextEditor::TextEditorWidget *, QTimer *> m_scheduledRequests;
+    QMetaObject::Connection m_documentOpenedConnection;
+    QMetaObject::Connection m_documentClosedConnection;
+
+    QElapsedTimer m_typingTimer;
+    int m_recentCharCount;
+    CompletionProgressHandler m_progressHandler;
+    CompletionErrorHandler m_errorHandler;
+    EditorChatButtonHandler m_chatButtonHandler;
+    QuickRefactorHandler *m_refactorHandler{nullptr};
+    RefactorSuggestionHoverHandler *m_refactorHoverHandler{nullptr};
+    RefactorWidgetHandler *m_refactorWidgetHandler{nullptr};
+    LLMClientInterface *m_llmClient;
+};
+
+} // namespace QodeAssist