Version 0.2.3, Update to QtCreator 14.0.2

Add no print support

Test disabling qt6 print component

Clean unnecessary code

Add library

.github/workflows/build_cmake.yml

@@ -4,8 +4,8 @@ on: [push]
 
 env:
   PLUGIN_NAME: QodeAssist
-  QT_VERSION: 6.7.2
-  QT_CREATOR_VERSION: 14.0.0
+  QT_VERSION: 6.7.3
+  QT_CREATOR_VERSION: 14.0.2
   QT_CREATOR_SNAPSHOT: NO
   MACOS_DEPLOYMENT_TARGET: "11.0"
   CMAKE_VERSION: "3.29.6"
@@ -100,7 +100,7 @@ jobs:
             COMMAND sudo apt update
           )
           execute_process(
-            COMMAND sudo apt install libgl1-mesa-dev
+            COMMAND sudo apt install libgl1-mesa-dev libcups2-dev
             RESULT_VARIABLE result
           )
           if (NOT result EQUAL 0)

CMakeLists.txt

@@ -10,7 +10,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 find_package(QtCreator REQUIRED COMPONENTS Core)
-find_package(Qt6 COMPONENTS Widgets REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Widgets Network REQUIRED)
 
 add_qtc_plugin(QodeAssist
   PLUGIN_DEPENDS
@@ -32,10 +32,12 @@ add_qtc_plugin(QodeAssist
     LLMClientInterface.hpp LLMClientInterface.cpp
     PromptTemplateManager.hpp PromptTemplateManager.cpp
     templates/PromptTemplate.hpp
-    templates/CodeLLamaTemplate.hpp
+    templates/CodeLlamaFimTemplate.hpp
     templates/StarCoder2Template.hpp
     templates/DeepSeekCoderV2.hpp
     templates/CustomTemplate.hpp
+    templates/DeepSeekCoderChatTemplate.hpp
+    templates/CodeLlamaInstruct.hpp
     providers/LLMProvider.hpp
     providers/OllamaProvider.hpp providers/OllamaProvider.cpp
     providers/LMStudioProvider.hpp providers/LMStudioProvider.cpp
@@ -54,4 +56,10 @@ add_qtc_plugin(QodeAssist
     settings/CustomPromptSettings.hpp settings/CustomPromptSettings.cpp
     settings/PresetPromptsSettings.hpp settings/PresetPromptsSettings.cpp
     settings/SettingsUtils.hpp
+    core/ChangesManager.h core/ChangesManager.cpp
+    core/LLMRequestHandler.hpp core/LLMRequestHandler.cpp
+    core/LLMRequestConfig.hpp
+    chat/ChatWidget.h chat/ChatWidget.cpp
+    chat/ChatOutputPane.h chat/ChatOutputPane.cpp
+    chat/ChatClientInterface.hpp chat/ChatClientInterface.cpp
 )

DocumentContextReader.cpp

@@ -23,6 +23,7 @@
 #include <QTextBlock>
 #include <languageserverprotocol/lsptypes.h>
 
+#include "core/ChangesManager.h"
 #include "settings/ContextSettings.hpp"
 
 const QRegularExpression &getYearRegex()
@@ -209,4 +210,53 @@ CopyrightInfo DocumentContextReader::copyrightInfo() const
     return m_copyrightInfo;
 }
 
+ContextData DocumentContextReader::prepareContext(int lineNumber, int cursorPosition) const
+{
+    QString contextBefore = getContextBefore(lineNumber, cursorPosition);
+    QString contextAfter = getContextAfter(lineNumber, cursorPosition);
+    QString instructions = getInstructions();
+
+    return {contextBefore, contextAfter, instructions};
+}
+
+QString DocumentContextReader::getContextBefore(int lineNumber, int cursorPosition) const
+{
+    if (Settings::contextSettings().readFullFile()) {
+        return readWholeFileBefore(lineNumber, cursorPosition);
+    } else {
+        int effectiveStartLine;
+        int beforeCursor = Settings::contextSettings().readStringsBeforeCursor();
+        if (m_copyrightInfo.found) {
+            effectiveStartLine = qMax(m_copyrightInfo.endLine + 1, lineNumber - beforeCursor);
+        } else {
+            effectiveStartLine = qMax(0, lineNumber - beforeCursor);
+        }
+        return getContextBetween(effectiveStartLine, lineNumber, cursorPosition);
+    }
+}
+
+QString DocumentContextReader::getContextAfter(int lineNumber, int cursorPosition) const
+{
+    if (Settings::contextSettings().readFullFile()) {
+        return readWholeFileAfter(lineNumber, cursorPosition);
+    } else {
+        int endLine = qMin(m_document->blockCount() - 1,
+                           lineNumber + Settings::contextSettings().readStringsAfterCursor());
+        return getContextBetween(lineNumber + 1, endLine, -1);
+    }
+}
+
+QString DocumentContextReader::getInstructions() const
+{
+    QString instructions;
+
+    if (Settings::contextSettings().useFilePathInContext())
+        instructions += getLanguageAndFileInfo();
+
+    if (Settings::contextSettings().useProjectChangesCache())
+        instructions += ChangesManager::instance().getRecentChangesContext(m_textDocument);
+
+    return instructions;
+}
+
 } // namespace QodeAssist

DocumentContextReader.hpp

@@ -22,6 +22,8 @@
 #include <QTextDocument>
 #include <texteditor/textdocument.h>
 
+#include "QodeAssistData.hpp"
+
 namespace QodeAssist {
 
 struct CopyrightInfo
@@ -48,6 +50,13 @@ public:
 
     CopyrightInfo copyrightInfo() const;
 
+    ContextData prepareContext(int lineNumber, int cursorPosition) const;
+
+private:
+    QString getContextBefore(int lineNumber, int cursorPosition) const;
+    QString getContextAfter(int lineNumber, int cursorPosition) const;
+    QString getInstructions() const;
+
 private:
     TextEditor::TextDocument *m_textDocument;
     QTextDocument *m_document;

LLMClientInterface.cpp

@@ -29,15 +29,19 @@
 #include "LLMProvidersManager.hpp"
 #include "PromptTemplateManager.hpp"
 #include "QodeAssistUtils.hpp"
+#include "core/LLMRequestConfig.hpp"
 #include "settings/ContextSettings.hpp"
 #include "settings/GeneralSettings.hpp"
 
 namespace QodeAssist {
 
 LLMClientInterface::LLMClientInterface()
-    : m_manager(new QNetworkAccessManager(this))
+    : m_requestHandler(this)
 {
-    updateProvider();
+    connect(&m_requestHandler,
+            &LLMRequestHandler::completionReceived,
+            this,
+            &LLMClientInterface::sendCompletionToClient);
 }
 
 Utils::FilePath LLMClientInterface::serverDeviceTemplate() const
@@ -52,8 +56,6 @@ void LLMClientInterface::startImpl()
 
 void LLMClientInterface::sendData(const QByteArray &data)
 {
-    updateProvider();
-
     QJsonDocument doc = QJsonDocument::fromJson(data);
     if (!doc.isObject())
         return;
@@ -85,87 +87,13 @@ void LLMClientInterface::sendData(const QByteArray &data)
 void LLMClientInterface::handleCancelRequest(const QJsonObject &request)
 {
     QString id = request["params"].toObject()["id"].toString();
-    if (m_activeRequests.contains(id)) {
-        m_activeRequests[id]->abort();
-        m_activeRequests.remove(id);
+    if (m_requestHandler.cancelRequest(id)) {
         logMessage(QString("Request %1 cancelled successfully").arg(id));
     } else {
         logMessage(QString("Request %1 not found").arg(id));
     }
 }
 
-bool LLMClientInterface::processSingleLineCompletion(QNetworkReply *reply,
-                                                     const QJsonObject &request,
-                                                     const QString &accumulatedCompletion)
-{
-    int newlinePos = accumulatedCompletion.indexOf('\n');
-
-    if (newlinePos != -1) {
-        QString singleLineCompletion = accumulatedCompletion.left(newlinePos).trimmed();
-        singleLineCompletion = removeStopWords(singleLineCompletion);
-
-        QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
-
-        sendCompletionToClient(singleLineCompletion, request, position, true);
-        m_accumulatedResponses.remove(reply);
-        reply->abort();
-
-        return true;
-    }
-    return false;
-}
-
-QString LLMClientInterface::сontextBefore(TextEditor::TextEditorWidget *widget,
-                                          int lineNumber,
-                                          int cursorPosition)
-{
-    if (!widget)
-        return QString();
-
-    DocumentContextReader reader(widget->textDocument());
-    const auto &copyright = reader.copyrightInfo();
-
-    logMessage(QString{"Line Number: %1"}.arg(lineNumber));
-    logMessage(QString("Copyright found %1 %2").arg(copyright.found).arg(copyright.endLine));
-    if (lineNumber < reader.findCopyright().endLine)
-        return QString();
-
-    QString contextBefore;
-    if (Settings::contextSettings().readFullFile()) {
-        contextBefore = reader.readWholeFileBefore(lineNumber, cursorPosition);
-    } else {
-        contextBefore
-            = reader.getContextBefore(lineNumber,
-                                      cursorPosition,
-                                      Settings::contextSettings().readStringsBeforeCursor());
-    }
-
-    return contextBefore;
-}
-
-QString LLMClientInterface::сontextAfter(TextEditor::TextEditorWidget *widget,
-                                         int lineNumber,
-                                         int cursorPosition)
-{
-    if (!widget)
-        return QString();
-
-    DocumentContextReader reader(widget->textDocument());
-    if (lineNumber < reader.findCopyright().endLine)
-        return QString();
-
-    QString contextAfter;
-    if (Settings::contextSettings().readFullFile()) {
-        contextAfter = reader.readWholeFileAfter(lineNumber, cursorPosition);
-    } else {
-        contextAfter = reader.getContextAfter(lineNumber,
-                                              cursorPosition,
-                                              Settings::contextSettings().readStringsAfterCursor());
-    }
-
-    return contextAfter;
-}
-
 void LLMClientInterface::handleInitialize(const QJsonObject &request)
 {
     QJsonObject response;
@@ -216,40 +144,29 @@ void LLMClientInterface::handleExit(const QJsonObject &request)
     emit finished();
 }
 
-void LLMClientInterface::handleLLMResponse(QNetworkReply *reply, const QJsonObject &request)
+void LLMClientInterface::handleCompletion(const QJsonObject &request)
 {
-    QString &accumulatedResponse = m_accumulatedResponses[reply];
+    auto updatedContext = prepareContext(request);
 
-    auto &templateManager = PromptTemplateManager::instance();
-    const Templates::PromptTemplate *currentTemplate = templateManager.getCurrentTemplate();
+    LLMConfig config;
+    config.requestType = RequestType::Fim;
+    config.provider = LLMProvidersManager::instance().getCurrentFimProvider();
+    config.promptTemplate = PromptTemplateManager::instance().getCurrentFimTemplate();
+    config.url = QUrl(QString("%1%2").arg(Settings::generalSettings().url(),
+                                          Settings::generalSettings().endPoint()));
 
-    auto &providerManager = LLMProvidersManager::instance();
-    bool isComplete = providerManager.getCurrentProvider()->handleResponse(reply,
-                                                                           accumulatedResponse);
+    config.providerRequest = {{"model", Settings::generalSettings().modelName.value()},
+                              {"stream", true},
+                              {"stop",
+                               QJsonArray::fromStringList(config.promptTemplate->stopWords())}};
 
-    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+    if (Settings::contextSettings().useSpecificInstructions())
+        config.providerRequest["system"] = Settings::contextSettings().specificInstractions();
 
-    if (!Settings::generalSettings().multiLineCompletion()
-        && processSingleLineCompletion(reply, request, accumulatedResponse)) {
-        return;
-    }
+    config.promptTemplate->prepareRequest(config.providerRequest, updatedContext);
+    config.provider->prepareRequest(config.providerRequest);
 
-    if (isComplete || reply->isFinished()) {
-        if (isComplete) {
-            auto cleanedCompletion = removeStopWords(accumulatedResponse);
-            sendCompletionToClient(cleanedCompletion, request, position, true);
-        } else {
-            handleCompletion(request, accumulatedResponse);
-        }
-        m_accumulatedResponses.remove(reply);
-    }
-}
-
-void LLMClientInterface::handleCompletion(const QJsonObject &request,
-                                          const QStringView &accumulatedCompletion)
-{
-    auto updatedContext = prepareContext(request, accumulatedCompletion);
-    sendLLMRequest(request, updatedContext);
+    m_requestHandler.sendLLMRequest(config, request);
 }
 
 ContextData LLMClientInterface::prepareContext(const QJsonObject &request,
@@ -272,34 +189,16 @@ ContextData LLMClientInterface::prepareContext(const QJsonObject &request,
     int cursorPosition = position["character"].toInt();
     int lineNumber = position["line"].toInt();
 
-    auto textEditor = TextEditor::BaseTextEditor::currentTextEditor();
-    TextEditor::TextEditorWidget *widget = textEditor->editorWidget();
-
-    DocumentContextReader reader(widget->textDocument());
-
-    QString contextBefore = сontextBefore(widget, lineNumber, cursorPosition);
-    QString contextAfter = сontextAfter(widget, lineNumber, cursorPosition);
-    QString instructions = QString("%1%2").arg(Settings::contextSettings().useSpecificInstructions()
-                                                   ? reader.getSpecificInstructions()
-                                                   : QString(),
-                                               Settings::contextSettings().useFilePathInContext()
-                                                   ? reader.getLanguageAndFileInfo()
-                                                   : QString());
-
-    return {QString("%1%2").arg(contextBefore, accumulatedCompletion), contextAfter, instructions};
-}
-
-void LLMClientInterface::updateProvider()
-{
-    m_serverUrl = QUrl(QString("%1%2").arg(Settings::generalSettings().url(),
-                                           Settings::generalSettings().endPoint()));
+    DocumentContextReader reader(textDocument);
+    return reader.prepareContext(lineNumber, cursorPosition);
 }
 
 void LLMClientInterface::sendCompletionToClient(const QString &completion,
                                                 const QJsonObject &request,
-                                                const QJsonObject &position,
                                                 bool isComplete)
 {
+    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+
     QJsonObject response;
     response["jsonrpc"] = "2.0";
     response[LanguageServerProtocol::idKey] = request["id"];
@@ -331,69 +230,6 @@ void LLMClientInterface::sendCompletionToClient(const QString &completion,
     emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
 }
 
-void LLMClientInterface::sendLLMRequest(const QJsonObject &request, const ContextData &prompt)
-{
-    QJsonObject providerRequest = {{"model", Settings::generalSettings().modelName.value()},
-                                   {"stream", true}};
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    currentTemplate->prepareRequest(providerRequest, prompt);
-
-    auto &providerManager = LLMProvidersManager::instance();
-    providerManager.getCurrentProvider()->prepareRequest(providerRequest);
-
-    logMessage(QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
-                   .arg(m_serverUrl.toString(),
-                        QString::fromUtf8(
-                            QJsonDocument(providerRequest).toJson(QJsonDocument::Indented))));
-
-    QNetworkRequest networkRequest(m_serverUrl);
-    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-
-    if (providerRequest.contains("api_key")) {
-        QString apiKey = providerRequest["api_key"].toString();
-        networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey).toUtf8());
-        providerRequest.remove("api_key");
-    }
-
-    QNetworkReply *reply = m_manager->post(networkRequest, QJsonDocument(providerRequest).toJson());
-    if (!reply) {
-        logMessage("Error: Failed to create network reply");
-        return;
-    }
-
-    QString requestId = request["id"].toString();
-    m_activeRequests[requestId] = reply;
-
-    connect(reply, &QNetworkReply::readyRead, this, [this, reply, request]() {
-        handleLLMResponse(reply, request);
-    });
-
-    connect(reply, &QNetworkReply::finished, this, [this, reply, requestId]() {
-        reply->deleteLater();
-        m_activeRequests.remove(requestId);
-        if (reply->error() != QNetworkReply::NoError) {
-            logMessage(QString("Error in QodeAssist request: %1").arg(reply->errorString()));
-        } else {
-            logMessage("Request finished successfully");
-        }
-    });
-}
-
-QString LLMClientInterface::removeStopWords(const QStringView &completion)
-{
-    QString filteredCompletion = completion.toString();
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    QStringList stopWords = currentTemplate->stopWords();
-
-    for (const QString &stopWord : stopWords) {
-        filteredCompletion = filteredCompletion.replace(stopWord, "");
-    }
-
-    return filteredCompletion;
-}
-
 void LLMClientInterface::startTimeMeasurement(const QString &requestId)
 {
     m_requestStartTimes[requestId] = QDateTime::currentMSecsSinceEpoch();

LLMClientInterface.hpp

@@ -23,6 +23,7 @@
 #include <texteditor/texteditor.h>
 
 #include "QodeAssistData.hpp"
+#include "core/LLMRequestHandler.hpp"
 
 class QNetworkReply;
 class QNetworkAccessManager;
@@ -36,22 +37,13 @@ class LLMClientInterface : public LanguageClient::BaseClientInterface
 public:
     LLMClientInterface();
 
-public:
     Utils::FilePath serverDeviceTemplate() const override;
 
     void sendCompletionToClient(const QString &completion,
                                 const QJsonObject &request,
-                                const QJsonObject &position,
                                 bool isComplete);
 
-    void handleCompletion(const QJsonObject &request,
-                          const QStringView &accumulatedCompletion = QString());
-    void sendLLMRequest(const QJsonObject &request, const ContextData &prompt);
-    void handleLLMResponse(QNetworkReply *reply, const QJsonObject &request);
-
-    ContextData prepareContext(const QJsonObject &request,
-                               const QStringView &accumulatedCompletion = QString{});
-    void updateProvider();
+    void handleCompletion(const QJsonObject &request);
 
 protected:
     void startImpl() override;
@@ -65,19 +57,11 @@ private:
     void handleInitialized(const QJsonObject &request);
     void handleExit(const QJsonObject &request);
     void handleCancelRequest(const QJsonObject &request);
-    bool processSingleLineCompletion(QNetworkReply *reply,
-                                     const QJsonObject &request,
-                                     const QString &accumulatedCompletion);
 
-    QString сontextBefore(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
-    QString сontextAfter(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
-    QString removeStopWords(const QStringView &completion);
-
-    QUrl m_serverUrl;
-    QNetworkAccessManager *m_manager;
-    QMap<QString, QNetworkReply *> m_activeRequests;
-    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+    ContextData prepareContext(const QJsonObject &request,
+                               const QStringView &accumulatedCompletion = QString{});
 
+    LLMRequestHandler m_requestHandler;
     QElapsedTimer m_completionTimer;
     QMap<QString, qint64> m_requestStartTimes;
 

LLMProvidersManager.cpp

@@ -19,6 +19,8 @@
 
 #include "LLMProvidersManager.hpp"
 
+#include "QodeAssistUtils.hpp"
+
 namespace QodeAssist {
 
 LLMProvidersManager &LLMProvidersManager::instance()
@@ -27,25 +29,53 @@ LLMProvidersManager &LLMProvidersManager::instance()
     return instance;
 }
 
-QStringList LLMProvidersManager::getProviderNames() const
+Providers::LLMProvider *LLMProvidersManager::setCurrentFimProvider(const QString &name)
 {
-    return m_providers.keys();
-}
-
-void LLMProvidersManager::setCurrentProvider(const QString &name)
-{
-    if (m_providers.contains(name)) {
-        m_currentProviderName = name;
-    }
-}
-
-Providers::LLMProvider *LLMProvidersManager::getCurrentProvider()
-{
-    if (m_currentProviderName.isEmpty()) {
+    logMessage("Setting current FIM provider to: " + name);
+    if (!m_providers.contains(name)) {
+        logMessage("Can't find provider with name: " + name);
         return nullptr;
     }
 
-    return m_providers[m_currentProviderName];
+    m_currentFimProvider = m_providers[name];
+    return m_currentFimProvider;
+}
+
+Providers::LLMProvider *LLMProvidersManager::setCurrentChatProvider(const QString &name)
+{
+    logMessage("Setting current chat provider to: " + name);
+    if (!m_providers.contains(name)) {
+        logMessage("Can't find chat provider with name: " + name);
+        return nullptr;
+    }
+
+    m_currentChatProvider = m_providers[name];
+    return m_currentChatProvider;
+}
+
+Providers::LLMProvider *LLMProvidersManager::getCurrentFimProvider()
+{
+    if (m_currentFimProvider == nullptr) {
+        logMessage("Current fim provider is null");
+        return nullptr;
+    }
+
+    return m_currentFimProvider;
+}
+
+Providers::LLMProvider *LLMProvidersManager::getCurrentChatProvider()
+{
+    if (m_currentChatProvider == nullptr) {
+        logMessage("Current chat provider is null");
+        return nullptr;
+    }
+
+    return m_currentChatProvider;
+}
+
+QStringList LLMProvidersManager::providersNames() const
+{
+    return m_providers.keys();
 }
 
 LLMProvidersManager::~LLMProvidersManager()

LLMProvidersManager.hpp

@@ -29,6 +29,7 @@ class LLMProvidersManager
 {
 public:
     static LLMProvidersManager &instance();
+    ~LLMProvidersManager();
 
     template<typename T>
     void registerProvider()
@@ -40,11 +41,13 @@ public:
         m_providers[name] = provider;
     }
 
-    QStringList getProviderNames() const;
-    void setCurrentProvider(const QString &name);
-    Providers::LLMProvider *getCurrentProvider();
+    Providers::LLMProvider *setCurrentFimProvider(const QString &name);
+    Providers::LLMProvider *setCurrentChatProvider(const QString &name);
 
-    ~LLMProvidersManager();
+    Providers::LLMProvider *getCurrentFimProvider();
+    Providers::LLMProvider *getCurrentChatProvider();
+
+    QStringList providersNames() const;
 
 private:
     LLMProvidersManager() = default;
@@ -52,7 +55,8 @@ private:
     LLMProvidersManager &operator=(const LLMProvidersManager &) = delete;
 
     QMap<QString, Providers::LLMProvider *> m_providers;
-    QString m_currentProviderName;
+    Providers::LLMProvider *m_currentFimProvider = nullptr;
+    Providers::LLMProvider *m_currentChatProvider = nullptr;
 };
 
 } // namespace QodeAssist

PromptTemplateManager.cpp

@@ -19,6 +19,8 @@
 
 #include "PromptTemplateManager.hpp"
 
+#include "QodeAssistUtils.hpp"
+
 namespace QodeAssist {
 
 PromptTemplateManager &PromptTemplateManager::instance()
@@ -27,27 +29,60 @@ PromptTemplateManager &PromptTemplateManager::instance()
     return instance;
 }
 
-void PromptTemplateManager::setCurrentTemplate(const QString &name)
+void PromptTemplateManager::setCurrentFimTemplate(const QString &name)
 {
-    if (m_templates.contains(name)) {
-        m_currentTemplateName = name;
+    logMessage("Setting current FIM provider to: " + name);
+    if (!m_fimTemplates.contains(name) || m_fimTemplates[name] == nullptr) {
+        logMessage("Error to set current FIM template" + name);
+        return;
     }
+
+    m_currentFimTemplate = m_fimTemplates[name];
 }
 
-const Templates::PromptTemplate *PromptTemplateManager::getCurrentTemplate() const
+Templates::PromptTemplate *PromptTemplateManager::getCurrentFimTemplate()
 {
-    auto it = m_templates.find(m_currentTemplateName);
-    return it != m_templates.end() ? it.value() : nullptr;
+    if (m_currentFimTemplate == nullptr) {
+        logMessage("Current fim provider is null");
+        return nullptr;
+    }
+
+    return m_currentFimTemplate;
 }
 
-QStringList PromptTemplateManager::getTemplateNames() const
+void PromptTemplateManager::setCurrentChatTemplate(const QString &name)
 {
-    return m_templates.keys();
+    logMessage("Setting current chat provider to:  " + name);
+    if (!m_chatTemplates.contains(name) || m_chatTemplates[name] == nullptr) {
+        logMessage("Error to set current chat template" + name);
+        return;
+    }
+
+    m_currentChatTemplate = m_chatTemplates[name];
+}
+
+Templates::PromptTemplate *PromptTemplateManager::getCurrentChatTemplate()
+{
+    if (m_currentChatTemplate == nullptr)
+        logMessage("Current chat provider is null");
+
+    return m_currentChatTemplate;
+}
+
+QStringList PromptTemplateManager::fimTemplatesNames() const
+{
+    return m_fimTemplates.keys();
+}
+
+QStringList PromptTemplateManager::chatTemplatesNames() const
+{
+    return m_chatTemplates.keys();
 }
 
 PromptTemplateManager::~PromptTemplateManager()
 {
-    qDeleteAll(m_templates);
+    qDeleteAll(m_fimTemplates);
+    qDeleteAll(m_chatTemplates);
 }
 
 } // namespace QodeAssist

PromptTemplateManager.hpp

@@ -30,6 +30,7 @@ class PromptTemplateManager
 {
 public:
     static PromptTemplateManager &instance();
+    ~PromptTemplateManager();
 
     template<typename T>
     void registerTemplate()
@@ -38,22 +39,31 @@ public:
                       "T must inherit from PromptTemplate");
         T *template_ptr = new T();
         QString name = template_ptr->name();
-        m_templates[name] = template_ptr;
+        if (template_ptr->type() == Templates::TemplateType::Fim) {
+            m_fimTemplates[name] = template_ptr;
+        } else if (template_ptr->type() == Templates::TemplateType::Chat) {
+            m_chatTemplates[name] = template_ptr;
+        }
     }
 
-    void setCurrentTemplate(const QString &name);
-    const Templates::PromptTemplate *getCurrentTemplate() const;
-    QStringList getTemplateNames() const;
+    void setCurrentFimTemplate(const QString &name);
+    Templates::PromptTemplate *getCurrentFimTemplate();
 
-    ~PromptTemplateManager();
+    void setCurrentChatTemplate(const QString &name);
+    Templates::PromptTemplate *getCurrentChatTemplate();
+
+    QStringList fimTemplatesNames() const;
+    QStringList chatTemplatesNames() const;
 
 private:
     PromptTemplateManager() = default;
     PromptTemplateManager(const PromptTemplateManager &) = delete;
     PromptTemplateManager &operator=(const PromptTemplateManager &) = delete;
 
-    QMap<QString, Templates::PromptTemplate *> m_templates;
-    QString m_currentTemplateName;
+    QMap<QString, Templates::PromptTemplate *> m_fimTemplates;
+    QMap<QString, Templates::PromptTemplate *> m_chatTemplates;
+    Templates::PromptTemplate *m_currentFimTemplate;
+    Templates::PromptTemplate *m_currentChatTemplate;
 };
 
 } // namespace QodeAssist

QodeAssist.json.in

@@ -1,6 +1,6 @@
 {
     "Name" : "QodeAssist",
-    "Version" : "0.1.1",
+    "Version" : "0.2.3",
     "CompatVersion" : "${IDE_VERSION_COMPAT}",
     "Vendor" : "Petr Mironychev",
     "Copyright" : "(C) ${IDE_COPYRIGHT_YEAR} Petr Mironychev, (C) ${IDE_COPYRIGHT_YEAR} The Qt Company Ltd",

QodeAssistClient.cpp

@@ -31,6 +31,8 @@
 
 #include "LLMClientInterface.hpp"
 #include "LLMSuggestion.hpp"
+#include "core/ChangesManager.h"
+#include "settings/ContextSettings.hpp"
 #include "settings/GeneralSettings.hpp"
 
 using namespace LanguageServerProtocol;
@@ -83,6 +85,13 @@ void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
                 auto textEditor = BaseTextEditor::currentTextEditor();
                 if (!textEditor || textEditor->document() != document)
                     return;
+
+                if (Settings::contextSettings().useProjectChangesCache())
+                    ChangesManager::instance().addChange(document,
+                                                         position,
+                                                         charsRemoved,
+                                                         charsAdded);
+
                 TextEditorWidget *widget = textEditor->editorWidget();
                 if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
                     return;

QodeAssistConstants.hpp

@@ -53,12 +53,20 @@ const char AUTO_COMPLETION_CHAR_THRESHOLD[] = "QodeAssist.autoCompletionCharThre
 const char AUTO_COMPLETION_TYPING_INTERVAL[] = "QodeAssist.autoCompletionTypingInterval";
 const char MAX_FILE_THRESHOLD[] = "QodeAssist.maxFileThreshold";
 const char OLLAMA_LIVETIME[] = "QodeAssist.ollamaLivetime";
-const char SPECIFIC_INSTRUCTIONS[] = "QodeAssist.specificInstractions";
+const char SYSTEM_PROMPT[] = "QodeAssist.systemPrompt";
 const char MULTILINE_COMPLETION[] = "QodeAssist.multilineCompletion";
 const char API_KEY[] = "QodeAssist.apiKey";
-const char USE_SPECIFIC_INSTRUCTIONS[] = "QodeAssist.useSpecificInstructions";
+const char USE_SYSTEM_PROMPT[] = "QodeAssist.useSystemPrompt";
 const char USE_FILE_PATH_IN_CONTEXT[] = "QodeAssist.useFilePathInContext";
 const char CUSTOM_JSON_TEMPLATE[] = "QodeAssist.customJsonTemplate";
+const char USE_PROJECT_CHANGES_CACHE[] = "QodeAssist.useProjectChangesCache";
+const char MAX_CHANGES_CACHE_SIZE[] = "QodeAssist.maxChangesCacheSize";
+const char CHAT_LLM_PROVIDERS[] = "QodeAssist.chatLlmProviders";
+const char CHAT_URL[] = "QodeAssist.chatUrl";
+const char CHAT_END_POINT[] = "QodeAssist.chatEndPoint";
+const char CHAT_MODEL_NAME[] = "QodeAssist.chatModelName";
+const char CHAT_SELECT_MODELS[] = "QodeAssist.chatSelectModels";
+const char CHAT_PROMPTS[] = "QodeAssist.chatPrompts";
 
 const char QODE_ASSIST_GENERAL_OPTIONS_ID[] = "QodeAssist.GeneralOptions";
 const char QODE_ASSIST_GENERAL_SETTINGS_PAGE_ID[] = "QodeAssist.1GeneralSettingsPageId";

QodeAssistUtils.hpp

@@ -19,7 +19,12 @@
 
 #pragma once
 
+#include <QEventLoop>
+#include <QNetworkReply>
+#include <QNetworkRequest>
 #include <QString>
+#include <QTimer>
+#include <QUrl>
 #include <coreplugin/messagemanager.h>
 #include <utils/qtcassert.h>
 
@@ -55,6 +60,8 @@ inline void logMessages(const QStringList &messages, bool silent = true)
         return;
 
     QStringList prefixedMessages;
+    qDebug() << prefixedMessages;
+
     for (const QString &message : messages) {
         prefixedMessages << (QLatin1String("[Qode Assist] ") + message);
     }
@@ -65,4 +72,36 @@ inline void logMessages(const QStringList &messages, bool silent = true)
     }
 }
 
+inline bool pingUrl(const QUrl &url, int timeout = 5000)
+{
+    if (!url.isValid()) {
+        return false;
+    }
+
+    QNetworkAccessManager manager;
+    QNetworkRequest request(url);
+    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, true);
+
+    QScopedPointer<QNetworkReply> reply(manager.get(request));
+
+    QTimer timer;
+    timer.setSingleShot(true);
+
+    QEventLoop loop;
+    QObject::connect(reply.data(), &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+
+    timer.start(timeout);
+    loop.exec();
+
+    if (timer.isActive()) {
+        timer.stop();
+        return (reply->error() == QNetworkReply::NoError);
+    } else {
+        QObject::disconnect(reply.data(), &QNetworkReply::finished, &loop, &QEventLoop::quit);
+        reply->abort();
+        return false;
+    }
+}
+
 } // namespace QodeAssist

README.md

@@ -1,8 +1,10 @@
 # QodeAssist
-[![Build plugin](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml/badge.svg?branch=main)](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml) [![Ko-fi](https://img.shields.io/badge/Ko--fi-FF5E5B?logo=ko-fi&logoColor=white)](https://ko-fi.com/petrmdev)
+[![Build plugin](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml/badge.svg?branch=main)](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml)
 
 QodeAssist is an AI-powered coding assistant plugin for Qt Creator. It provides intelligent code completion and suggestions for C++ and QML, leveraging large language models through local providers like Ollama. Enhance your coding productivity with context-aware AI assistance directly in your Qt development environment.
 
+<img src="https://github.com/user-attachments/assets/255a52f1-5cc0-4ca3-b05c-c4cf9cdbe25a" width="600" alt="QodeAssistPreview">
+
 ## Supported LLM Providers
 QodeAssist currently supports the following LLM (Large Language Model) providers:
 - [Ollama](https://ollama.com)
@@ -10,34 +12,68 @@ QodeAssist currently supports the following LLM (Large Language Model) providers
 - OpenAI compatible providers
 
 ## Supported Models
-QodeAssist has been tested with the following language models, all trained for Fill-in-theMiddle:
 
-Ollama:
-- [starcoder2](https://ollama.com/library/starcoder2)
-- [codellama](https://ollama.com/library/codellama)
+QodeAssist has been thoroughly tested and optimized for use with the following language models, all of which are specifically trained for Fill-in-the-Middle (FIM) tasks:
+
+- CodeLlama
+- StarCoder2
 - DeepSeek-Coder-V2-Lite-Base
 
-LM studio:
+These models have demonstrated excellent performance in code completion and assistance tasks within the QodeAssist environment.
+
+### Custom Prompts
+
+For advanced users or those with specific requirements, QodeAssist offers the flexibility to create, save, and load custom prompts using JSON templates. This feature allows you to tailor the AI's behavior to your exact needs.
+
+To get started with custom prompts:
+
+1. Navigate to the "Custom Template" option in the FIM Prompt Settings.
+2. Create your custom JSON prompt template.
+3. Use the "Save Custom Template to JSON" button to store your template for future use.
+4. To use a previously saved template, click "Load Custom Template from JSON".
+5. Make sure to select "Custom Template" from the dropdown menu in the FIM Prompt Settings on the General page to activate your custom template.
+
+For inspiration and examples of effective custom prompts, please refer to the `rawPromptExamples` folder in our repository.
+
+<img width="600" alt="Custom template" src="https://github.com/user-attachments/assets/4a14c552-baba-4531-ab4f-cb1f9ac6620b">
+<img width="600" alt="Select custom template" src="https://github.com/user-attachments/assets/3651dafd-83f9-4df9-943f-69c28cd3d8a3">
+
+### Tested Models
+
+#### Ollama:
+- [starcoder2](https://ollama.com/library/starcoder2)
+- [codellama](https://ollama.com/library/codellama)
+
+#### LM Studio:
 - [second-state/StarCoder2-7B-GGUF](https://huggingface.co/second-state/StarCoder2-7B-GGUF)
 - [TheBloke/CodeLlama-7B-GGUF](https://huggingface.co/TheBloke/CodeLlama-7B-GGUF)
 
 Please note that while these models have been specifically tested and confirmed to work well with QodeAssist, other models compatible with the supported providers may also work. We encourage users to experiment with different models and report their experiences.
+
 If you've successfully used a model that's not listed here, please let us know by opening an issue or submitting a pull request to update this list.
 
 ## Development Progress
 
 - [x] Basic plugin with code autocomplete functionality
-- [ ] Improve and automate settings
+- [x] Improve and automate settings
 - [ ] Add chat functionality
+- [x] Sharing diff with model
+- [ ] Sharing project source with model
 - [ ] Support for more providers and models
 
 ## Plugin installation using Ollama as an example
 
 1. Install QtCreator 14.0
 2. Install [Ollama](https://ollama.com). Make sure to review the system requirements before installation.
-3. Install a language model in Ollama. For example, you can run:
+3. Install a language models in Ollama. For example, you can run:
+
+For suggestions:
 ```
-ollama run starcoder2:7b
+ollama run codellama:7b-code
+```
+For chat:
+```
+ollama run codellama:7b-instruct
 ```
 4. Download the QodeAssist plugin.
 5. Launch Qt Creator and install the plugin:
@@ -48,13 +84,16 @@ ollama run starcoder2:7b
 
 ## Configure Plugin
 
+<img src="https://github.com/user-attachments/assets/0743d09e-1f02-44ed-9a1a-85e2a0a0c01a" width="800" alt="QodeAssist в действии">
+
 1. Open Qt Creator settings
 2. Navigate to the "Qode Assist" tab
-3. Choose your LLM provider (e.g., Ollama)
-4. Select the installed model by the "Select Model" button
+3. Select "General" page
+4. Choose your LLM provider (e.g., Ollama)
+5. Select the installed model by the "Select Model" button
    - For LM Studio you will see current load model
-5. Choose the prompt template that corresponds to your model
-6. Apply the settings
+6. Choose the prompt template that corresponds to your model
+7. Apply the settings
 
 You're all set! QodeAssist is now ready to use in Qt Creator.
 
@@ -91,7 +130,8 @@ Verify that the selected prompt template matches the model you're using
 If you're still experiencing issues with QodeAssist, you can try resetting the settings to their default values:
 1. Open Qt Creator settings
 2. Navigate to the "Qode Assist" tab
-3. Click on the "Reset to Defaults" button
+3. Pick settings page for reset
+4. Click on the "Reset Page to Defaults" button
     - The API key will not reset
     - Select model after reset
 
@@ -105,7 +145,7 @@ If you find QodeAssist helpful, there are several ways you can support the proje
 3. **Spread the Word**: Star our GitHub repository and share QodeAssist with your fellow developers.
 
 4. **Financial Support**: If you'd like to support the development financially, you can make a donation using one of the following:
-   - Buy me a coffee [![Ko-fi](https://img.shields.io/badge/Ko--fi-FF5E5B?logo=ko-fi&logoColor=white)](https://ko-fi.com/petrmdev)
+   - [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/P5P412V96G)
    - Bitcoin (BTC): `bc1qndq7f0mpnlya48vk7kugvyqj5w89xrg4wzg68t`
    - Ethereum (ETH): `0xA5e8c37c94b24e25F9f1f292a01AF55F03099D8D`
    - Litecoin (LTC): `ltc1qlrxnk30s2pcjchzx4qrxvdjt5gzuervy5mv0vy`

chat/ChatClientInterface.cpp

@@ -0,0 +1,192 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#include "ChatClientInterface.hpp"
+#include "LLMProvidersManager.hpp"
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistUtils.hpp"
+#include "settings/ContextSettings.hpp"
+#include "settings/GeneralSettings.hpp"
+#include "settings/PresetPromptsSettings.hpp"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QUuid>
+
+namespace QodeAssist::Chat {
+
+int ChatHistory::estimateTokenCount(const QString &text) const
+{
+    return text.length() / 4;
+}
+
+void ChatHistory::addMessage(ChatMessage::Role role, const QString &content)
+{
+    int tokenCount = estimateTokenCount(content);
+    m_messages.append({role, content, tokenCount});
+    m_totalTokens += tokenCount;
+    trim();
+}
+void ChatHistory::clear()
+{
+    m_messages.clear();
+    m_totalTokens = 0;
+}
+
+QVector<ChatMessage> ChatHistory::getMessages() const
+{
+    return m_messages;
+}
+
+QString ChatHistory::getSystemPrompt() const
+{
+    return m_systemPrompt;
+}
+
+void ChatHistory::setSystemPrompt(const QString &prompt)
+{
+    m_systemPrompt = prompt;
+}
+
+void ChatHistory::trim()
+{
+    while (m_messages.size() > MAX_HISTORY_SIZE || m_totalTokens > MAX_TOKENS) {
+        if (!m_messages.isEmpty()) {
+            m_totalTokens -= m_messages.first().tokenCount;
+            m_messages.removeFirst();
+        } else {
+            break;
+        }
+    }
+}
+
+ChatClientInterface::ChatClientInterface(QObject *parent)
+    : QObject(parent)
+    , m_requestHandler(new LLMRequestHandler(this))
+{
+    connect(m_requestHandler,
+            &LLMRequestHandler::completionReceived,
+            this,
+            [this](const QString &completion, const QJsonObject &, bool isComplete) {
+                handleLLMResponse(completion, isComplete);
+            });
+
+    connect(m_requestHandler,
+            &LLMRequestHandler::requestFinished,
+            this,
+            [this](const QString &, bool success, const QString &errorString) {
+                if (!success) {
+                    emit errorOccurred(errorString);
+                }
+            });
+
+    m_chatHistory.setSystemPrompt("You are a helpful C++ and QML programming assistant.");
+}
+
+ChatClientInterface::~ChatClientInterface() = default;
+
+void ChatClientInterface::sendMessage(const QString &message)
+{
+    logMessage("Sending message: " + message);
+    logMessage("chatProvider " + Settings::generalSettings().chatLlmProviders.stringValue());
+    logMessage("chatTemplate " + Settings::generalSettings().chatPrompts.stringValue());
+
+    auto chatTemplate = PromptTemplateManager::instance().getCurrentChatTemplate();
+    auto chatProvider = LLMProvidersManager::instance().getCurrentChatProvider();
+
+    ContextData context;
+    context.prefix = message;
+    context.suffix = "";
+    if (Settings::contextSettings().useSpecificInstructions())
+        context.instriuctions = Settings::contextSettings().specificInstractions();
+
+    QJsonObject providerRequest;
+    providerRequest["model"] = Settings::generalSettings().chatModelName();
+    providerRequest["stream"] = true;
+    providerRequest["messages"] = prepareMessagesForRequest();
+
+    chatTemplate->prepareRequest(providerRequest, context);
+    chatProvider->prepareRequest(providerRequest);
+
+    LLMConfig config;
+    config.requestType = RequestType::Chat;
+    config.provider = chatProvider;
+    config.promptTemplate = chatTemplate;
+    config.url = QString("%1%2").arg(Settings::generalSettings().chatUrl(),
+                                     Settings::generalSettings().chatEndPoint());
+    config.providerRequest = providerRequest;
+
+    QJsonObject request;
+    request["id"] = QUuid::createUuid().toString();
+
+    m_accumulatedResponse.clear();
+    m_chatHistory.addMessage(ChatMessage::Role::User, message);
+    m_requestHandler->sendLLMRequest(config, request);
+}
+
+void ChatClientInterface::clearMessages()
+{
+    m_chatHistory.clear();
+    m_accumulatedResponse.clear();
+    logMessage("Chat history cleared");
+}
+
+QVector<ChatMessage> ChatClientInterface::getChatHistory() const
+{
+    return m_chatHistory.getMessages();
+}
+
+void ChatClientInterface::handleLLMResponse(const QString &response, bool isComplete)
+{
+    m_accumulatedResponse += response;
+
+    if (isComplete) {
+        logMessage("Message completed. Final response: " + m_accumulatedResponse);
+        emit messageReceived(m_accumulatedResponse.trimmed());
+
+        m_chatHistory.addMessage(ChatMessage::Role::Assistant, m_accumulatedResponse.trimmed());
+        m_accumulatedResponse.clear();
+    }
+}
+
+QJsonArray ChatClientInterface::prepareMessagesForRequest() const
+{
+    QJsonArray messages;
+
+    messages.append(QJsonObject{{"role", "system"}, {"content", m_chatHistory.getSystemPrompt()}});
+
+    for (const auto &message : m_chatHistory.getMessages()) {
+        QString role;
+        switch (message.role) {
+        case ChatMessage::Role::User:
+            role = "user";
+            break;
+        case ChatMessage::Role::Assistant:
+            role = "assistant";
+            break;
+        default:
+            continue;
+        }
+        messages.append(QJsonObject{{"role", role}, {"content", message.content}});
+    }
+
+    return messages;
+}
+
+} // namespace QodeAssist::Chat

chat/ChatClientInterface.hpp

@@ -0,0 +1,83 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QVector>
+#include "QodeAssistData.hpp"
+#include "core/LLMRequestHandler.hpp"
+
+namespace QodeAssist::Chat {
+
+struct ChatMessage
+{
+    enum class Role { System, User, Assistant };
+    Role role;
+    QString content;
+    int tokenCount;
+};
+
+class ChatHistory
+{
+public:
+    void addMessage(ChatMessage::Role role, const QString &content);
+    void clear();
+    QVector<ChatMessage> getMessages() const;
+    QString getSystemPrompt() const;
+    void setSystemPrompt(const QString &prompt);
+    void trim();
+
+private:
+    QVector<ChatMessage> m_messages;
+    QString m_systemPrompt;
+    int m_totalTokens = 0;
+    static const int MAX_HISTORY_SIZE = 50;
+    static const int MAX_TOKENS = 4000;
+
+    int estimateTokenCount(const QString &text) const;
+};
+
+class ChatClientInterface : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ChatClientInterface(QObject *parent = nullptr);
+    ~ChatClientInterface();
+
+    void sendMessage(const QString &message);
+    void clearMessages();
+    QVector<ChatMessage> getChatHistory() const;
+
+signals:
+    void messageReceived(const QString &message);
+    void errorOccurred(const QString &error);
+
+private:
+    void handleLLMResponse(const QString &response, bool isComplete);
+    QJsonArray prepareMessagesForRequest() const;
+
+    LLMRequestHandler *m_requestHandler;
+    QString m_accumulatedResponse;
+    ChatHistory m_chatHistory;
+};
+
+} // namespace QodeAssist::Chat

chat/ChatOutputPane.cpp

@@ -0,0 +1,95 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#include "ChatOutputPane.h"
+
+#include "QodeAssisttr.h"
+
+namespace QodeAssist::Chat {
+
+ChatOutputPane::ChatOutputPane(QObject *parent)
+    : Core::IOutputPane(parent)
+    , m_chatWidget(new ChatWidget)
+{
+    setId("QodeAssistChat");
+    setDisplayName(Tr::tr("QodeAssist Chat"));
+    setPriorityInStatusBar(-40);
+}
+
+ChatOutputPane::~ChatOutputPane()
+{
+    delete m_chatWidget;
+}
+
+QWidget *ChatOutputPane::outputWidget(QWidget *)
+{
+    return m_chatWidget;
+}
+
+QList<QWidget *> ChatOutputPane::toolBarWidgets() const
+{
+    return {};
+}
+
+void ChatOutputPane::clearContents()
+{
+    m_chatWidget->clear();
+}
+
+void ChatOutputPane::visibilityChanged(bool visible)
+{
+    if (visible)
+        m_chatWidget->scrollToBottom();
+}
+
+void ChatOutputPane::setFocus()
+{
+    m_chatWidget->setFocus();
+}
+
+bool ChatOutputPane::hasFocus() const
+{
+    return m_chatWidget->hasFocus();
+}
+
+bool ChatOutputPane::canFocus() const
+{
+    return true;
+}
+
+bool ChatOutputPane::canNavigate() const
+{
+    return false;
+}
+
+bool ChatOutputPane::canNext() const
+{
+    return false;
+}
+
+bool ChatOutputPane::canPrevious() const
+{
+    return false;
+}
+
+void ChatOutputPane::goToNext() {}
+
+void ChatOutputPane::goToPrev() {}
+
+} // namespace QodeAssist::Chat

chat/ChatOutputPane.h

@@ -0,0 +1,52 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include "ChatWidget.h"
+#include <coreplugin/ioutputpane.h>
+
+namespace QodeAssist::Chat {
+
+class ChatOutputPane : public Core::IOutputPane
+{
+    Q_OBJECT
+
+public:
+    explicit ChatOutputPane(QObject *parent = nullptr);
+    ~ChatOutputPane() override;
+
+    QWidget *outputWidget(QWidget *parent) override;
+    QList<QWidget *> toolBarWidgets() const override;
+    void clearContents() override;
+    void visibilityChanged(bool visible) override;
+    void setFocus() override;
+    bool hasFocus() const override;
+    bool canFocus() const override;
+    bool canNavigate() const override;
+    bool canNext() const override;
+    bool canPrevious() const override;
+    void goToNext() override;
+    void goToPrev() override;
+
+private:
+    ChatWidget *m_chatWidget;
+};
+
+} // namespace QodeAssist::Chat

chat/ChatWidget.cpp

@@ -0,0 +1,147 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#include "ChatWidget.h"
+#include "QodeAssistUtils.hpp"
+
+#include <QCoreApplication>
+#include <QDateTime>
+#include <QScrollBar>
+#include <QVBoxLayout>
+#include <QtCore/qtimer.h>
+
+namespace QodeAssist::Chat {
+
+ChatWidget::ChatWidget(QWidget *parent)
+    : QWidget(parent)
+    , m_showTimestamp(false)
+    , m_chatClient(new ChatClientInterface(this))
+{
+    setupUi();
+
+    connect(m_sendButton, &QPushButton::clicked, this, &ChatWidget::sendMessage);
+    connect(m_messageInput, &QLineEdit::returnPressed, this, &ChatWidget::sendMessage);
+
+    connect(m_chatClient, &ChatClientInterface::messageReceived, this, &ChatWidget::receiveMessage);
+    connect(m_chatClient, &ChatClientInterface::errorOccurred, this, &ChatWidget::handleError);
+
+    logMessage("ChatWidget initialized");
+}
+
+void ChatWidget::setupUi()
+{
+    m_chatDisplay = new QTextEdit(this);
+    m_chatDisplay->setReadOnly(true);
+
+    m_messageInput = new QLineEdit(this);
+    m_sendButton = new QPushButton("Send", this);
+
+    QHBoxLayout *inputLayout = new QHBoxLayout;
+    inputLayout->addWidget(m_messageInput);
+    inputLayout->addWidget(m_sendButton);
+
+    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    mainLayout->addWidget(m_chatDisplay);
+    mainLayout->addLayout(inputLayout);
+
+    setLayout(mainLayout);
+}
+
+void ChatWidget::sendMessage()
+{
+    QString message = m_messageInput->text().trimmed();
+    if (!message.isEmpty()) {
+        logMessage("Sending message: " + message);
+        addMessage(message, true);
+        m_chatClient->sendMessage(message);
+        m_messageInput->clear();
+        addMessage("AI is typing...", false);
+    }
+}
+
+void ChatWidget::receiveMessage(const QString &message)
+{
+    updateLastAIMessage(message);
+}
+
+void ChatWidget::receivePartialMessage(const QString &partialMessage)
+{
+    logMessage("Received partial message: " + partialMessage);
+    m_currentAIResponse += partialMessage;
+    updateLastAIMessage(m_currentAIResponse);
+}
+
+void ChatWidget::onMessageCompleted()
+{
+    updateLastAIMessage(m_currentAIResponse);
+    m_currentAIResponse.clear();
+    scrollToBottom();
+}
+
+void ChatWidget::handleError(const QString &error)
+{
+    logMessage("Error occurred: " + error);
+    addMessage("Error: " + error, false);
+}
+
+void ChatWidget::addMessage(const QString &message, bool fromUser)
+{
+    auto prefix = fromUser ? "You: " : "AI: ";
+    QString timestamp = m_showTimestamp ? QDateTime::currentDateTime().toString("[hh:mm:ss] ") : "";
+    QString fullMessage = timestamp + prefix + message;
+    m_chatDisplay->append(fullMessage);
+    scrollToBottom();
+}
+
+void ChatWidget::updateLastAIMessage(const QString &message)
+{
+    QTextCursor cursor = m_chatDisplay->textCursor();
+    cursor.movePosition(QTextCursor::End);
+    cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor);
+    cursor.removeSelectedText();
+
+    QString timestamp = m_showTimestamp ? QDateTime::currentDateTime().toString("[hh:mm:ss] ") : "";
+    cursor.insertText(timestamp + "AI: " + message);
+
+    cursor.movePosition(QTextCursor::End);
+    m_chatDisplay->setTextCursor(cursor);
+
+    scrollToBottom();
+    m_chatDisplay->repaint();
+}
+
+void ChatWidget::clear()
+{
+    m_chatDisplay->clear();
+    m_currentAIResponse.clear();
+    m_chatClient->clearMessages();
+}
+
+void ChatWidget::scrollToBottom()
+{
+    QScrollBar *scrollBar = m_chatDisplay->verticalScrollBar();
+    scrollBar->setValue(scrollBar->maximum());
+}
+
+void ChatWidget::setShowTimestamp(bool show)
+{
+    m_showTimestamp = show;
+}
+
+} // namespace QodeAssist::Chat

chat/ChatWidget.h

@@ -0,0 +1,63 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QLineEdit>
+#include <QPushButton>
+#include <QTextEdit>
+#include <QWidget>
+
+#include "ChatClientInterface.hpp"
+
+namespace QodeAssist::Chat {
+
+class ChatWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit ChatWidget(QWidget *parent = nullptr);
+
+    void clear();
+    void scrollToBottom();
+    void setShowTimestamp(bool show);
+
+    void receiveMessage(const QString &message);
+
+private slots:
+    void sendMessage();
+    void receivePartialMessage(const QString &partialMessage);
+    void onMessageCompleted();
+    void handleError(const QString &error);
+
+private:
+    QTextEdit *m_chatDisplay;
+    QLineEdit *m_messageInput;
+    QPushButton *m_sendButton;
+    bool m_showTimestamp;
+    ChatClientInterface *m_chatClient;
+    QString m_currentAIResponse;
+
+    void setupUi();
+    void addMessage(const QString &message, bool fromUser = true);
+    void updateLastAIMessage(const QString &message);
+};
+
+} // namespace QodeAssist::Chat

core/ChangesManager.cpp

@@ -0,0 +1,83 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#include "ChangesManager.h"
+#include "QodeAssistUtils.hpp"
+#include "settings/ContextSettings.hpp"
+
+namespace QodeAssist {
+
+ChangesManager &ChangesManager::instance()
+{
+    static ChangesManager instance;
+    return instance;
+}
+
+ChangesManager::ChangesManager()
+    : QObject(nullptr)
+{
+}
+
+ChangesManager::~ChangesManager()
+{
+}
+
+void ChangesManager::addChange(TextEditor::TextDocument *document,
+                               int position,
+                               int charsRemoved,
+                               int charsAdded)
+{
+    auto &documentQueue = m_documentChanges[document];
+
+    QTextBlock block = document->document()->findBlock(position);
+    int lineNumber = block.blockNumber();
+    QString lineContent = block.text();
+    QString fileName = document->filePath().fileName();
+
+    ChangeInfo change{fileName, lineNumber, lineContent};
+
+    auto it = std::find_if(documentQueue.begin(),
+                           documentQueue.end(),
+                           [lineNumber](const ChangeInfo &c) { return c.lineNumber == lineNumber; });
+
+    if (it != documentQueue.end()) {
+        it->lineContent = lineContent;
+    } else {
+        documentQueue.enqueue(change);
+
+        if (documentQueue.size() > Settings::contextSettings().maxChangesCacheSize()) {
+            documentQueue.dequeue();
+        }
+    }
+}
+
+QString ChangesManager::getRecentChangesContext(const TextEditor::TextDocument *currentDocument) const
+{
+    QString context;
+    for (auto it = m_documentChanges.constBegin(); it != m_documentChanges.constEnd(); ++it) {
+        if (it.key() != currentDocument) {
+            for (const auto &change : it.value()) {
+                context += change.lineContent + "\n";
+            }
+        }
+    }
+    return context;
+}
+
+} // namespace QodeAssist

core/ChangesManager.h

@@ -0,0 +1,61 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QDateTime>
+#include <QHash>
+#include <QQueue>
+#include <QTimer>
+#include <texteditor/textdocument.h>
+
+namespace QodeAssist {
+
+class ChangesManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    struct ChangeInfo
+    {
+        QString fileName;
+        int lineNumber;
+        QString lineContent;
+    };
+
+    static ChangesManager &instance();
+
+    void addChange(TextEditor::TextDocument *document,
+                   int position,
+                   int charsRemoved,
+                   int charsAdded);
+    QString getRecentChangesContext(const TextEditor::TextDocument *currentDocument) const;
+
+private:
+    ChangesManager();
+    ~ChangesManager();
+    ChangesManager(const ChangesManager &) = delete;
+    ChangesManager &operator=(const ChangesManager &) = delete;
+
+    void cleanupOldChanges();
+
+    QHash<TextEditor::TextDocument *, QQueue<ChangeInfo>> m_documentChanges;
+};
+
+} // namespace QodeAssist

core/LLMRequestConfig.hpp

@@ -0,0 +1,40 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QJsonObject>
+#include <QUrl>
+#include "providers/LLMProvider.hpp"
+#include "templates/PromptTemplate.hpp"
+
+namespace QodeAssist {
+
+enum class RequestType { Fim, Chat };
+
+struct LLMConfig
+{
+    QUrl url;
+    Providers::LLMProvider *provider;
+    Templates::PromptTemplate *promptTemplate;
+    QJsonObject providerRequest;
+    RequestType requestType;
+};
+
+} // namespace QodeAssist

core/LLMRequestHandler.cpp

@@ -0,0 +1,160 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#include "LLMRequestHandler.hpp"
+#include "LLMProvidersManager.hpp"
+#include "QodeAssistUtils.hpp"
+#include "settings/GeneralSettings.hpp"
+
+#include <QJsonDocument>
+#include <QNetworkReply>
+
+namespace QodeAssist {
+
+LLMRequestHandler::LLMRequestHandler(QObject *parent)
+    : QObject(parent)
+    , m_manager(new QNetworkAccessManager(this))
+{}
+
+void LLMRequestHandler::sendLLMRequest(const LLMConfig &config, const QJsonObject &request)
+{
+    logMessage(QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
+                   .arg(config.url.toString(),
+                        QString::fromUtf8(
+                            QJsonDocument(config.providerRequest).toJson(QJsonDocument::Indented))));
+
+    QNetworkRequest networkRequest(config.url);
+    prepareNetworkRequest(networkRequest, config.providerRequest);
+
+    QNetworkReply *reply = m_manager->post(networkRequest,
+                                           QJsonDocument(config.providerRequest).toJson());
+    if (!reply) {
+        logMessage("Error: Failed to create network reply");
+        return;
+    }
+
+    QString requestId = request["id"].toString();
+    m_activeRequests[requestId] = reply;
+
+    connect(reply, &QNetworkReply::readyRead, this, [this, reply, request, config]() {
+        handleLLMResponse(reply, request, config);
+    });
+
+    connect(reply, &QNetworkReply::finished, this, [this, reply, requestId]() {
+        reply->deleteLater();
+        m_activeRequests.remove(requestId);
+        if (reply->error() != QNetworkReply::NoError) {
+            logMessage(QString("Error in QodeAssist request: %1").arg(reply->errorString()));
+            emit requestFinished(requestId, false, reply->errorString());
+        } else {
+            logMessage("Request finished successfully");
+            emit requestFinished(requestId, true, QString());
+        }
+    });
+}
+
+void LLMRequestHandler::handleLLMResponse(QNetworkReply *reply,
+                                          const QJsonObject &request,
+                                          const LLMConfig &config)
+{
+    QString &accumulatedResponse = m_accumulatedResponses[reply];
+
+    bool isComplete = config.provider->handleResponse(reply, accumulatedResponse);
+
+    if (config.requestType == RequestType::Fim) {
+        if (!Settings::generalSettings().multiLineCompletion()
+            && processSingleLineCompletion(reply, request, accumulatedResponse, config)) {
+            return;
+        }
+    }
+
+    if (isComplete || reply->isFinished()) {
+        if (isComplete) {
+            if (config.requestType == RequestType::Fim) {
+                auto cleanedCompletion = removeStopWords(accumulatedResponse,
+                                                         config.promptTemplate->stopWords());
+                emit completionReceived(cleanedCompletion, request, true);
+            } else {
+                emit completionReceived(accumulatedResponse, request, true);
+            }
+        } else {
+            emit completionReceived(accumulatedResponse, request, false);
+        }
+        m_accumulatedResponses.remove(reply);
+    }
+}
+
+bool LLMRequestHandler::cancelRequest(const QString &id)
+{
+    if (m_activeRequests.contains(id)) {
+        QNetworkReply *reply = m_activeRequests[id];
+        reply->abort();
+        m_activeRequests.remove(id);
+        m_accumulatedResponses.remove(reply);
+        emit requestCancelled(id);
+        return true;
+    }
+    return false;
+}
+
+void LLMRequestHandler::prepareNetworkRequest(QNetworkRequest &networkRequest,
+                                              const QJsonObject &providerRequest)
+{
+    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+    if (providerRequest.contains("api_key")) {
+        QString apiKey = providerRequest["api_key"].toString();
+        networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey).toUtf8());
+    }
+}
+
+bool LLMRequestHandler::processSingleLineCompletion(QNetworkReply *reply,
+                                                    const QJsonObject &request,
+                                                    const QString &accumulatedResponse,
+                                                    const LLMConfig &config)
+{
+    int newlinePos = accumulatedResponse.indexOf('\n');
+
+    if (newlinePos != -1) {
+        QString singleLineCompletion = accumulatedResponse.left(newlinePos).trimmed();
+        singleLineCompletion = removeStopWords(singleLineCompletion,
+                                               config.promptTemplate->stopWords());
+
+        emit completionReceived(singleLineCompletion, request, true);
+        m_accumulatedResponses.remove(reply);
+        reply->abort();
+
+        return true;
+    }
+    return false;
+}
+
+QString LLMRequestHandler::removeStopWords(const QStringView &completion,
+                                           const QStringList &stopWords)
+{
+    QString filteredCompletion = completion.toString();
+
+    for (const QString &stopWord : stopWords) {
+        filteredCompletion = filteredCompletion.replace(stopWord, "");
+    }
+
+    return filteredCompletion;
+}
+
+} // namespace QodeAssist

core/LLMRequestHandler.hpp

@@ -0,0 +1,64 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QJsonObject>
+#include <QNetworkAccessManager>
+#include <QObject>
+
+#include "QodeAssistData.hpp"
+#include "core/LLMRequestConfig.hpp"
+
+class QNetworkReply;
+
+namespace QodeAssist {
+
+class LLMRequestHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit LLMRequestHandler(QObject *parent = nullptr);
+
+    void sendLLMRequest(const LLMConfig &config, const QJsonObject &request);
+    void handleLLMResponse(QNetworkReply *reply,
+                           const QJsonObject &request,
+                           const LLMConfig &config);
+    bool cancelRequest(const QString &id);
+
+signals:
+    void completionReceived(const QString &completion, const QJsonObject &request, bool isComplete);
+    void requestFinished(const QString &requestId, bool success, const QString &errorString);
+    void requestCancelled(const QString &id);
+
+private:
+    QNetworkAccessManager *m_manager;
+    QMap<QString, QNetworkReply *> m_activeRequests;
+    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+
+    void prepareNetworkRequest(QNetworkRequest &networkRequest, const QJsonObject &providerRequest);
+    bool processSingleLineCompletion(QNetworkReply *reply,
+                                     const QJsonObject &request,
+                                     const QString &accumulatedResponse,
+                                     const LLMConfig &config);
+    QString removeStopWords(const QStringView &completion, const QStringList &stopWords);
+};
+
+} // namespace QodeAssist

providers/LLMProvider.hpp

@@ -35,10 +35,11 @@ public:
     virtual QString name() const = 0;
     virtual QString url() const = 0;
     virtual QString completionEndpoint() const = 0;
+    virtual QString chatEndpoint() const = 0;
 
     virtual void prepareRequest(QJsonObject &request) = 0;
     virtual bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) = 0;
-    virtual QList<QString> getInstalledModels(const Utils::Environment &env) = 0;
+    virtual QList<QString> getInstalledModels(const Utils::Environment &env, const QString &url) = 0;
 };
 
 } // namespace QodeAssist::Providers

providers/LMStudioProvider.cpp

@@ -25,7 +25,6 @@
 #include <QJsonObject>
 #include <QNetworkReply>
 
-#include "PromptTemplateManager.hpp"
 #include "QodeAssistUtils.hpp"
 #include "settings/PresetPromptsSettings.hpp"
 
@@ -48,21 +47,33 @@ QString LMStudioProvider::completionEndpoint() const
     return "/v1/chat/completions";
 }
 
+QString LMStudioProvider::chatEndpoint() const
+{
+    return "/v1/chat/completions";
+}
+
 void LMStudioProvider::prepareRequest(QJsonObject &request)
 {
     auto &settings = Settings::presetPromptsSettings();
-    const auto &currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    if (currentTemplate->name() == "Custom Template")
-        return;
+    QJsonArray messages;
+
+    if (request.contains("system")) {
+        QJsonObject systemMessage{{"role", "system"},
+                                  {"content", request.take("system").toString()}};
+        messages.append(systemMessage);
+    }
+
     if (request.contains("prompt")) {
-        QJsonArray messages{
-            {QJsonObject{{"role", "user"}, {"content", request.take("prompt").toString()}}}};
+        QJsonObject userMessage{{"role", "user"}, {"content", request.take("prompt").toString()}};
+        messages.append(userMessage);
+    }
+
+    if (!messages.isEmpty()) {
         request["messages"] = std::move(messages);
     }
 
     request["max_tokens"] = settings.maxTokens();
     request["temperature"] = settings.temperature();
-    request["stop"] = QJsonArray::fromStringList(currentTemplate->stopWords());
     if (settings.useTopP())
         request["top_p"] = settings.topP();
     if (settings.useTopK())
@@ -114,11 +125,12 @@ bool LMStudioProvider::handleResponse(QNetworkReply *reply, QString &accumulated
     return isComplete;
 }
 
-QList<QString> LMStudioProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> LMStudioProvider::getInstalledModels(const Utils::Environment &env,
+                                                    const QString &url)
 {
     QList<QString> models;
     QNetworkAccessManager manager;
-    QNetworkRequest request(QUrl(url() + "/v1/models"));
+    QNetworkRequest request(QString("%1%2").arg(url, "/v1/models"));
 
     QNetworkReply *reply = manager.get(request);
 

providers/LMStudioProvider.hpp

@@ -31,9 +31,10 @@ public:
     QString name() const override;
     QString url() const override;
     QString completionEndpoint() const override;
+    QString chatEndpoint() const override;
     void prepareRequest(QJsonObject &request) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const Utils::Environment &env, const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

providers/OllamaProvider.cpp

@@ -48,18 +48,18 @@ QString OllamaProvider::completionEndpoint() const
     return "/api/generate";
 }
 
+QString OllamaProvider::chatEndpoint() const
+{
+    return "/api/chat";
+}
+
 void OllamaProvider::prepareRequest(QJsonObject &request)
 {
     auto &settings = Settings::presetPromptsSettings();
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    if (currentTemplate->name() == "Custom Template")
-        return;
 
     QJsonObject options;
     options["num_predict"] = settings.maxTokens();
-    options["keep_alive"] = settings.ollamaLivetime();
     options["temperature"] = settings.temperature();
-    options["stop"] = QJsonArray::fromStringList(currentTemplate->stopWords());
     if (settings.useTopP())
         options["top_p"] = settings.topP();
     if (settings.useTopK())
@@ -69,40 +69,65 @@ void OllamaProvider::prepareRequest(QJsonObject &request)
     if (settings.usePresencePenalty())
         options["presence_penalty"] = settings.presencePenalty();
     request["options"] = options;
+    request["keep_alive"] = settings.ollamaLivetime();
 }
 
 bool OllamaProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
 {
+    QString endpoint = reply->url().path();
+
     bool isComplete = false;
     while (reply->canReadLine()) {
         QByteArray line = reply->readLine().trimmed();
         if (line.isEmpty()) {
             continue;
         }
-        QJsonDocument jsonResponse = QJsonDocument::fromJson(line);
-        if (jsonResponse.isNull()) {
-            qWarning() << "Invalid JSON response from Ollama:" << line;
+
+        QJsonDocument doc = QJsonDocument::fromJson(line);
+        if (doc.isNull()) {
+            logMessage("Invalid JSON response from Ollama: " + QString::fromUtf8(line));
             continue;
         }
-        QJsonObject responseObj = jsonResponse.object();
-        if (responseObj.contains("response")) {
-            QString completion = responseObj["response"].toString();
 
-            accumulatedResponse += completion;
+        QJsonObject responseObj = doc.object();
+
+        if (responseObj.contains("error")) {
+            QString errorMessage = responseObj["error"].toString();
+            logMessage("Error in Ollama response: " + errorMessage);
+            return false;
         }
-        if (responseObj["done"].toBool()) {
+
+        if (endpoint == completionEndpoint()) {
+            if (responseObj.contains("response")) {
+                QString completion = responseObj["response"].toString();
+                accumulatedResponse += completion;
+            }
+        } else if (endpoint == chatEndpoint()) {
+            if (responseObj.contains("message")) {
+                QJsonObject message = responseObj["message"].toObject();
+                if (message.contains("content")) {
+                    QString content = message["content"].toString();
+                    accumulatedResponse += content;
+                }
+            }
+        } else {
+            logMessage("Unknown endpoint: " + endpoint);
+        }
+
+        if (responseObj.contains("done") && responseObj["done"].toBool()) {
             isComplete = true;
             break;
         }
     }
+
     return isComplete;
 }
 
-QList<QString> OllamaProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> OllamaProvider::getInstalledModels(const Utils::Environment &env, const QString &url)
 {
     QList<QString> models;
     QNetworkAccessManager manager;
-    QNetworkRequest request(QUrl(url() + "/api/tags"));
+    QNetworkRequest request(QString("%1%2").arg(url, "/api/tags"));
     QNetworkReply *reply = manager.get(request);
 
     QEventLoop loop;

providers/OllamaProvider.hpp

@@ -31,9 +31,10 @@ public:
     QString name() const override;
     QString url() const override;
     QString completionEndpoint() const override;
+    QString chatEndpoint() const override;
     void prepareRequest(QJsonObject &request) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const Utils::Environment &env, const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

providers/OpenAICompatProvider.cpp

@@ -24,7 +24,6 @@
 #include <QJsonObject>
 #include <QNetworkReply>
 
-#include "PromptTemplateManager.hpp"
 #include "settings/PresetPromptsSettings.hpp"
 
 namespace QodeAssist::Providers {
@@ -46,22 +45,33 @@ QString OpenAICompatProvider::completionEndpoint() const
     return "/v1/chat/completions";
 }
 
+QString OpenAICompatProvider::chatEndpoint() const
+{
+    return "/v1/chat/completions";
+}
+
 void OpenAICompatProvider::prepareRequest(QJsonObject &request)
 {
     auto &settings = Settings::presetPromptsSettings();
-    const auto &currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    if (currentTemplate->name() == "Custom Template")
-        return;
+    QJsonArray messages;
+
+    if (request.contains("system")) {
+        QJsonObject systemMessage{{"role", "system"},
+                                  {"content", request.take("system").toString()}};
+        messages.append(systemMessage);
+    }
 
     if (request.contains("prompt")) {
-        QJsonArray messages{
-            {QJsonObject{{"role", "user"}, {"content", request.take("prompt").toString()}}}};
+        QJsonObject userMessage{{"role", "user"}, {"content", request.take("prompt").toString()}};
+        messages.append(userMessage);
+    }
+
+    if (!messages.isEmpty()) {
         request["messages"] = std::move(messages);
     }
 
     request["max_tokens"] = settings.maxTokens();
     request["temperature"] = settings.temperature();
-    request["stop"] = QJsonArray::fromStringList(currentTemplate->stopWords());
     if (settings.useTopP())
         request["top_p"] = settings.topP();
     if (settings.useTopK())
@@ -118,7 +128,8 @@ bool OpenAICompatProvider::handleResponse(QNetworkReply *reply, QString &accumul
     return isComplete;
 }
 
-QList<QString> OpenAICompatProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> OpenAICompatProvider::getInstalledModels(const Utils::Environment &env,
+                                                        const QString &url)
 {
     return QStringList();
 }

providers/OpenAICompatProvider.hpp

@@ -31,9 +31,10 @@ public:
     QString name() const override;
     QString url() const override;
     QString completionEndpoint() const override;
+    QString chatEndpoint() const override;
     void prepareRequest(QJsonObject &request) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const Utils::Environment &env, const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

qodeassist.cpp

@@ -26,8 +26,9 @@
 #include <coreplugin/coreconstants.h>
 #include <coreplugin/icontext.h>
 #include <coreplugin/icore.h>
+#include <coreplugin/messagemanager.h>
+#include <coreplugin/modemanager.h>
 #include <coreplugin/statusbarmanager.h>
-
 #include <extensionsystem/iplugin.h>
 #include <languageclient/languageclientmanager.h>
 
@@ -41,11 +42,16 @@
 #include "LLMProvidersManager.hpp"
 #include "PromptTemplateManager.hpp"
 #include "QodeAssistClient.hpp"
+#include "chat/ChatOutputPane.h"
 #include "providers/LMStudioProvider.hpp"
 #include "providers/OllamaProvider.hpp"
 #include "providers/OpenAICompatProvider.hpp"
-#include "templates/CodeLLamaTemplate.hpp"
+
+#include "settings/GeneralSettings.hpp"
+#include "templates/CodeLlamaFimTemplate.hpp"
+#include "templates/CodeLlamaInstruct.hpp"
 #include "templates/CustomTemplate.hpp"
+#include "templates/DeepSeekCoderChatTemplate.hpp"
 #include "templates/DeepSeekCoderV2.hpp"
 #include "templates/StarCoder2Template.hpp"
 
@@ -78,10 +84,12 @@ public:
         providerManager.registerProvider<Providers::OpenAICompatProvider>();
 
         auto &templateManager = PromptTemplateManager::instance();
-        templateManager.registerTemplate<Templates::CodeLLamaTemplate>();
+        templateManager.registerTemplate<Templates::CodeLlamaFimTemplate>();
         templateManager.registerTemplate<Templates::StarCoder2Template>();
         templateManager.registerTemplate<Templates::DeepSeekCoderV2Template>();
         templateManager.registerTemplate<Templates::CustomTemplate>();
+        templateManager.registerTemplate<Templates::DeepSeekCoderChatTemplate>();
+        templateManager.registerTemplate<Templates::CodeLlamaInstructTemplate>();
 
         Utils::Icon QCODEASSIST_ICON(
             {{":/resources/images/qoderassist-icon.png", Utils::Theme::IconsBaseColor}});
@@ -106,6 +114,8 @@ public:
         auto toggleButton = new QToolButton;
         toggleButton->setDefaultAction(requestAction.contextAction());
         StatusBarManager::addStatusBarWidget(toggleButton, StatusBarManager::RightCorner);
+
+        m_chatOutputPane = new Chat::ChatOutputPane(this);
     }
 
     void extensionsInitialized() final
@@ -139,6 +149,7 @@ public:
 
 private:
     QPointer<QodeAssistClient> m_qodeAssistClient;
+    QPointer<Chat::ChatOutputPane> m_chatOutputPane;
 };
 
 } // namespace QodeAssist::Internal

settings/ContextSettings.cpp

@@ -17,8 +17,6 @@
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
  */
 
-#pragma once
-
 #include "ContextSettings.hpp"
 
 #include <QMessageBox>
@@ -60,11 +58,11 @@ ContextSettings::ContextSettings()
     useFilePathInContext.setDefaultValue(false);
     useFilePathInContext.setLabelText(Tr::tr("Use File Path in Context"));
 
-    useSpecificInstructions.setSettingsKey(Constants::USE_SPECIFIC_INSTRUCTIONS);
-    useSpecificInstructions.setDefaultValue(false);
-    useSpecificInstructions.setLabelText(Tr::tr("Use Specific Instructions"));
+    useSpecificInstructions.setSettingsKey(Constants::USE_SYSTEM_PROMPT);
+    useSpecificInstructions.setDefaultValue(true);
+    useSpecificInstructions.setLabelText(Tr::tr("Use System Prompt"));
 
-    specificInstractions.setSettingsKey(Constants::SPECIFIC_INSTRUCTIONS);
+    specificInstractions.setSettingsKey(Constants::SYSTEM_PROMPT);
     specificInstractions.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
     specificInstractions.setLabelText(
         Tr::tr("Instructions: Please keep %1 for languge name, warning, it shouldn't too big"));
@@ -74,6 +72,15 @@ ContextSettings::ContextSettings()
 
     resetToDefaults.m_buttonText = Tr::tr("Reset Page to Defaults");
 
+    useProjectChangesCache.setSettingsKey(Constants::USE_PROJECT_CHANGES_CACHE);
+    useProjectChangesCache.setDefaultValue(true);
+    useProjectChangesCache.setLabelText(Tr::tr("Use Project Changes Cache"));
+
+    maxChangesCacheSize.setSettingsKey(Constants::MAX_CHANGES_CACHE_SIZE);
+    maxChangesCacheSize.setLabelText(Tr::tr("Max Changes Cache Size"));
+    maxChangesCacheSize.setRange(2, 1000);
+    maxChangesCacheSize.setDefaultValue(20);
+
     readSettings();
 
     readStringsAfterCursor.setEnabled(!readFullFile());
@@ -90,6 +97,8 @@ ContextSettings::ContextSettings()
                       useFilePathInContext,
                       useSpecificInstructions,
                       specificInstractions,
+                      useProjectChangesCache,
+                      Row{maxChangesCacheSize, Stretch{1}},
                       Stretch{1}};
     });
 }
@@ -123,10 +132,6 @@ void ContextSettings::resetPageToDefaults()
         resetAspect(useSpecificInstructions);
         resetAspect(specificInstractions);
     }
-
-    QMessageBox::information(Core::ICore::dialogParent(),
-                             Tr::tr("Settings Reset"),
-                             Tr::tr("All settings have been reset to their default values."));
 }
 
 class ContextSettingsPage : public Core::IOptionsPage

settings/ContextSettings.hpp

@@ -37,6 +37,8 @@ public:
     Utils::StringAspect specificInstractions{this};
     Utils::BoolAspect useSpecificInstructions{this};
     Utils::BoolAspect useFilePathInContext{this};
+    Utils::BoolAspect useProjectChangesCache{this};
+    Utils::IntegerAspect maxChangesCacheSize{this};
 
     ButtonAspect resetToDefaults{this};
 

settings/CustomPromptSettings.cpp

@@ -122,10 +122,6 @@ void CustomPromptSettings::resetSettingsToDefaults()
     if (reply == QMessageBox::Yes) {
         resetAspect(customJsonTemplate);
     }
-
-    QMessageBox::information(Core::ICore::dialogParent(),
-                             Tr::tr("Settings Reset"),
-                             Tr::tr("All settings have been reset to their default values."));
 }
 
 void CustomPromptSettings::saveCustomTemplate()

settings/GeneralSettings.cpp

@@ -24,6 +24,7 @@
 #include <coreplugin/dialogs/ioptionspage.h>
 #include <coreplugin/icore.h>
 #include <utils/layoutbuilder.h>
+#include <utils/utilsicons.h>
 
 #include "LLMProvidersManager.hpp"
 #include "PromptTemplateManager.hpp"
@@ -58,8 +59,8 @@ GeneralSettings::GeneralSettings()
     enableLogging.setDefaultValue(false);
 
     multiLineCompletion.setSettingsKey(Constants::MULTILINE_COMPLETION);
-    multiLineCompletion.setDefaultValue(true);
-    multiLineCompletion.setLabelText(Tr::tr("Enable Multiline Completion"));
+    multiLineCompletion.setDefaultValue(false);
+    multiLineCompletion.setLabelText(Tr::tr("Enable Multiline Completion(experimental)"));
 
     startSuggestionTimer.setSettingsKey(Constants::START_SUGGESTION_TIMER);
     startSuggestionTimer.setLabelText(Tr::tr("with delay(ms)"));
@@ -72,7 +73,7 @@ GeneralSettings::GeneralSettings()
         Tr::tr("The number of characters that need to be typed within the typing interval "
                "before an AI suggestion request is sent."));
     autoCompletionCharThreshold.setRange(0, 10);
-    autoCompletionCharThreshold.setDefaultValue(1);
+    autoCompletionCharThreshold.setDefaultValue(0);
 
     autoCompletionTypingInterval.setSettingsKey(Constants::AUTO_COMPLETION_TYPING_INTERVAL);
     autoCompletionTypingInterval.setLabelText(Tr::tr("character(s) within(ms)"));
@@ -83,9 +84,8 @@ GeneralSettings::GeneralSettings()
     autoCompletionTypingInterval.setDefaultValue(2000);
 
     llmProviders.setSettingsKey(Constants::LLM_PROVIDERS);
-    llmProviders.setDisplayName(Tr::tr("FIM Provider:"));
+    llmProviders.setDisplayName(Tr::tr("AI Suggest Provider:"));
     llmProviders.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
-    llmProviders.setDefaultValue(0);
 
     url.setSettingsKey(Constants::URL);
     url.setLabelText(Tr::tr("URL:"));
@@ -96,37 +96,58 @@ GeneralSettings::GeneralSettings()
     endPoint.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
 
     modelName.setSettingsKey(Constants::MODEL_NAME);
-    modelName.setLabelText(Tr::tr("LLM Name:"));
+    modelName.setLabelText(Tr::tr("Model name:"));
     modelName.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
 
     selectModels.m_buttonText = Tr::tr("Select Fill-In-the-Middle Model");
 
     fimPrompts.setDisplayName(Tr::tr("Fill-In-the-Middle Prompt"));
     fimPrompts.setSettingsKey(Constants::FIM_PROMPTS);
-    fimPrompts.setDefaultValue(0);
     fimPrompts.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
     resetToDefaults.m_buttonText = Tr::tr("Reset Page to Defaults");
 
-    const auto &manager = LLMProvidersManager::instance();
-    if (!manager.getProviderNames().isEmpty()) {
-        const auto providerNames = manager.getProviderNames();
-        for (const QString &name : providerNames) {
-            llmProviders.addOption(name);
-        }
-    }
+    chatLlmProviders.setSettingsKey(Constants::CHAT_LLM_PROVIDERS);
+    chatLlmProviders.setDisplayName(Tr::tr("AI Chat Provider:"));
+    chatLlmProviders.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
 
-    const auto &promptManager = PromptTemplateManager::instance();
-    if (!promptManager.getTemplateNames().isEmpty()) {
-        const auto promptNames = promptManager.getTemplateNames();
-        for (const QString &name : promptNames) {
-            fimPrompts.addOption(name);
-        }
-    }
+    chatUrl.setSettingsKey(Constants::CHAT_URL);
+    chatUrl.setLabelText(Tr::tr("URL:"));
+    chatUrl.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    chatEndPoint.setSettingsKey(Constants::CHAT_END_POINT);
+    chatEndPoint.setLabelText(Tr::tr("Chat Endpoint:"));
+    chatEndPoint.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    chatModelName.setSettingsKey(Constants::CHAT_MODEL_NAME);
+    chatModelName.setLabelText(Tr::tr("Model name:"));
+    chatModelName.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    chatSelectModels.m_buttonText = Tr::tr("Select Chat Model");
+
+    chatPrompts.setDisplayName(Tr::tr("Chat Prompt"));
+    chatPrompts.setSettingsKey(Constants::CHAT_PROMPTS);
+    chatPrompts.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
+
+    loadProviders();
+    loadPrompts();
+
+    llmProviders.setDefaultValue(llmProviders.indexForDisplay("Ollama"));
+    chatLlmProviders.setDefaultValue(chatLlmProviders.indexForDisplay("Ollama"));
+    fimPrompts.setDefaultValue(fimPrompts.indexForDisplay("CodeLLama FIM"));
+    chatPrompts.setDefaultValue(chatPrompts.indexForDisplay("CodeLLama Chat"));
 
     readSettings();
 
-    LLMProvidersManager::instance().setCurrentProvider(llmProviders.stringValue());
-    PromptTemplateManager::instance().setCurrentTemplate(fimPrompts.stringValue());
+    auto fimProviderName = llmProviders.displayForIndex(llmProviders.value());
+    setCurrentFimProvider(fimProviderName);
+    auto chatProviderName = chatLlmProviders.displayForIndex(chatLlmProviders.value());
+    setCurrentChatProvider(chatProviderName);
+
+    auto nameFimPromts = fimPrompts.displayForIndex(fimPrompts.value());
+    PromptTemplateManager::instance().setCurrentFimTemplate(nameFimPromts);
+    auto nameChatPromts = chatPrompts.displayForIndex(chatPrompts.value());
+    PromptTemplateManager::instance().setCurrentChatTemplate(nameChatPromts);
+
     setLoggingEnabled(enableLogging());
 
     setupConnections();
@@ -134,64 +155,97 @@ GeneralSettings::GeneralSettings()
     setLayouter([this]() {
         using namespace Layouting;
 
-        auto rootLayout = Column{Row{enableQodeAssist, Stretch{1}, resetToDefaults},
-                                 enableAutoComplete,
-                                 multiLineCompletion,
-                                 Row{autoCompletionCharThreshold,
-                                     autoCompletionTypingInterval,
-                                     startSuggestionTimer,
-                                     Stretch{1}},
-                                 Space{8},
-                                 enableLogging,
-                                 Space{8},
-                                 llmProviders,
-                                 Row{url, endPoint},
-                                 Space{8},
-                                 Row{selectModels, modelName},
-                                 Space{8},
-                                 fimPrompts,
-                                 Stretch{1}};
+        auto rootLayout
+            = Column{Row{enableQodeAssist, Stretch{1}, resetToDefaults},
+                     enableAutoComplete,
+                     multiLineCompletion,
+                     Row{autoCompletionCharThreshold,
+                         autoCompletionTypingInterval,
+                         startSuggestionTimer,
+                         Stretch{1}},
+                     Space{8},
+                     enableLogging,
+                     Space{8},
+                     Group{title(Tr::tr("AI Suggestions")),
+                           Column{Row{llmProviders, Stretch{1}},
+                                  Row{url, endPoint, fimUrlIndicator},
+                                  Row{selectModels, modelName, fimModelIndicator},
+                                  Row{fimPrompts, Stretch{1}}}},
+                     Space{16},
+                     Group{title(Tr::tr("AI Chat(experimental)")),
+                           Column{Row{chatLlmProviders, Stretch{1}},
+                                  Row{chatUrl, chatEndPoint, chatUrlIndicator},
+                                  Row{chatSelectModels, chatModelName, chatModelIndicator},
+                                  Row{chatPrompts, Stretch{1}}}},
+                     Stretch{1}};
         return rootLayout;
     });
+
+    updateStatusIndicators();
 }
 
 void GeneralSettings::setupConnections()
 {
     connect(&llmProviders, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
-        int index = llmProviders.volatileValue();
-        logMessage(QString("currentProvider %1").arg(llmProviders.displayForIndex(index)));
-        LLMProvidersManager::instance().setCurrentProvider(llmProviders.displayForIndex(index));
-        updateProviderSettings();
+        auto providerName = llmProviders.displayForIndex(llmProviders.volatileValue());
+        setCurrentFimProvider(providerName);
+        modelName.setVolatileValue("");
     });
+    connect(&chatLlmProviders, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
+        auto providerName = chatLlmProviders.displayForIndex(chatLlmProviders.volatileValue());
+        setCurrentChatProvider(providerName);
+        chatModelName.setVolatileValue("");        
+    });
+
     connect(&fimPrompts, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
         int index = fimPrompts.volatileValue();
-        logMessage(QString("currentPrompt %1").arg(fimPrompts.displayForIndex(index)));
-        PromptTemplateManager::instance().setCurrentTemplate(fimPrompts.displayForIndex(index));
+        PromptTemplateManager::instance().setCurrentFimTemplate(fimPrompts.displayForIndex(index));
     });
-    connect(&selectModels, &ButtonAspect::clicked, this, [this]() { showModelSelectionDialog(); });
+    connect(&chatPrompts, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
+        int index = chatPrompts.volatileValue();
+        PromptTemplateManager::instance().setCurrentChatTemplate(chatPrompts.displayForIndex(index));
+    });
+
+    connect(&selectModels, &ButtonAspect::clicked, this, [this]() {
+        auto *provider = LLMProvidersManager::instance().getCurrentFimProvider();
+        showModelSelectionDialog(&modelName, provider);
+    });
+    connect(&chatSelectModels, &ButtonAspect::clicked, this, [this]() {
+        auto *provider = LLMProvidersManager::instance().getCurrentChatProvider();
+        showModelSelectionDialog(&chatModelName, provider);
+    });
+
     connect(&enableLogging, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
         setLoggingEnabled(enableLogging.volatileValue());
     });
     connect(&resetToDefaults, &ButtonAspect::clicked, this, &GeneralSettings::resetPageToDefaults);
+
+    connect(&url,
+            &Utils::StringAspect::volatileValueChanged,
+            this,
+            &GeneralSettings::updateStatusIndicators);
+    connect(&modelName,
+            &Utils::StringAspect::volatileValueChanged,
+            this,
+            &GeneralSettings::updateStatusIndicators);
+    connect(&chatUrl,
+            &Utils::StringAspect::volatileValueChanged,
+            this,
+            &GeneralSettings::updateStatusIndicators);
+    connect(&chatModelName,
+            &Utils::StringAspect::volatileValueChanged,
+            this,
+            &GeneralSettings::updateStatusIndicators);
 }
 
-void GeneralSettings::updateProviderSettings()
+void GeneralSettings::showModelSelectionDialog(Utils::StringAspect *modelNameObj,
+                                               Providers::LLMProvider *provider)
 {
-    const auto provider = LLMProvidersManager::instance().getCurrentProvider();
-
-    if (provider) {
-        url.setVolatileValue(provider->url());
-        endPoint.setVolatileValue(provider->completionEndpoint());
-    }
-}
-
-void GeneralSettings::showModelSelectionDialog()
-{
-    auto *provider = LLMProvidersManager::instance().getCurrentProvider();
     Utils::Environment env = Utils::Environment::systemEnvironment();
+    QString providerUrl = (modelNameObj == &modelName) ? url() : chatUrl();
 
     if (provider) {
-        QStringList models = provider->getInstalledModels(env);
+        QStringList models = provider->getInstalledModels(env, providerUrl);
         bool ok;
         QString selectedModel = QInputDialog::getItem(Core::ICore::dialogParent(),
                                                       Tr::tr("Select LLM Model"),
@@ -202,7 +256,7 @@ void GeneralSettings::showModelSelectionDialog()
                                                       &ok);
 
         if (ok && !selectedModel.isEmpty()) {
-            modelName.setVolatileValue(selectedModel);
+            modelNameObj->setVolatileValue(selectedModel);
             writeSettings();
         }
     }
@@ -220,23 +274,105 @@ void GeneralSettings::resetPageToDefaults()
     if (reply == QMessageBox::Yes) {
         resetAspect(enableQodeAssist);
         resetAspect(enableAutoComplete);
-        resetAspect(llmProviders);
-        resetAspect(url);
-        resetAspect(endPoint);
-        resetAspect(modelName);
-        resetAspect(fimPrompts);
         resetAspect(enableLogging);
         resetAspect(startSuggestionTimer);
         resetAspect(autoCompletionTypingInterval);
         resetAspect(autoCompletionCharThreshold);
+        resetAspect(llmProviders);
+        resetAspect(chatLlmProviders);
+        resetAspect(fimPrompts);
+        resetAspect(chatPrompts);
     }
 
-    fimPrompts.setStringValue("StarCoder2");
-    llmProviders.setStringValue("Ollama");
+    modelName.setVolatileValue("");
+    chatModelName.setVolatileValue("");
 
-    QMessageBox::information(Core::ICore::dialogParent(),
-                             Tr::tr("Settings Reset"),
-                             Tr::tr("All settings have been reset to their default values."));
+    updateStatusIndicators();
+}
+
+void GeneralSettings::updateStatusIndicators()
+{
+    bool fimUrlValid = !url.volatileValue().isEmpty() && !endPoint.volatileValue().isEmpty();
+    bool fimModelValid = !modelName.volatileValue().isEmpty();
+    bool chatUrlValid = !chatUrl.volatileValue().isEmpty()
+                        && !chatEndPoint.volatileValue().isEmpty();
+    bool chatModelValid = !chatModelName.volatileValue().isEmpty();
+
+    bool fimPingSuccessful = false;
+    if (fimUrlValid) {
+        QUrl pingUrl(url.volatileValue());
+        fimPingSuccessful = QodeAssist::pingUrl(pingUrl);
+    }
+    bool chatPingSuccessful = false;
+    if (chatUrlValid) {
+        QUrl pingUrl(chatUrl.volatileValue());
+        chatPingSuccessful = QodeAssist::pingUrl(pingUrl);
+    }
+
+    setIndicatorStatus(fimModelIndicator,
+                       fimModelValid ? tr("Model is properly configured")
+                                     : tr("No model selected or model name is invalid"),
+                       fimModelValid);
+    setIndicatorStatus(fimUrlIndicator,
+                       fimPingSuccessful ? tr("Server is reachable")
+                                         : tr("Server is not reachable or URL is invalid"),
+                       fimPingSuccessful);
+
+    setIndicatorStatus(chatModelIndicator,
+                       chatModelValid ? tr("Model is properly configured")
+                                      : tr("No model selected or model name is invalid"),
+                       chatModelValid);
+    setIndicatorStatus(chatUrlIndicator,
+                       chatPingSuccessful ? tr("Server is reachable")
+                                          : tr("Server is not reachable or URL is invalid"),
+                       chatPingSuccessful);
+}
+
+void GeneralSettings::setIndicatorStatus(Utils::StringAspect &indicator,
+                                         const QString &tooltip,
+                                         bool isValid)
+{
+    const Utils::Icon &icon = isValid ? Utils::Icons::OK : Utils::Icons::WARNING;
+    indicator.setLabelPixmap(icon.pixmap());
+    indicator.setToolTip(tooltip);
+}
+
+void GeneralSettings::setCurrentFimProvider(const QString &name)
+{
+    const auto provider = LLMProvidersManager::instance().setCurrentFimProvider(name);
+    if (!provider)
+        return;
+
+    url.setValue(provider->url());
+    endPoint.setValue(provider->completionEndpoint());
+}
+
+void GeneralSettings::setCurrentChatProvider(const QString &name)
+{
+    const auto provider = LLMProvidersManager::instance().setCurrentChatProvider(name);
+    if (!provider)
+        return;
+
+    chatUrl.setValue(provider->url());
+    chatEndPoint.setValue(provider->chatEndpoint());
+}
+
+void GeneralSettings::loadProviders()
+{
+    for (const auto &name : LLMProvidersManager::instance().providersNames()) {
+        llmProviders.addOption(name);
+        chatLlmProviders.addOption(name);
+    }
+}
+
+void GeneralSettings::loadPrompts()
+{
+    for (const auto &name : PromptTemplateManager::instance().fimTemplatesNames()) {
+        fimPrompts.addOption(name);
+    }
+    for (const auto &name : PromptTemplateManager::instance().chatTemplatesNames()) {
+        chatPrompts.addOption(name);
+    }
 }
 
 class GeneralSettingsPage : public Core::IOptionsPage

settings/GeneralSettings.hpp

@@ -21,6 +21,7 @@
 
 #include <utils/aspects.h>
 
+#include "providers/LLMProvider.hpp"
 #include "settings/SettingsUtils.hpp"
 
 namespace QodeAssist::Settings {
@@ -47,11 +48,33 @@ public:
     Utils::SelectionAspect fimPrompts{this};
     ButtonAspect resetToDefaults{this};
 
+    Utils::SelectionAspect chatLlmProviders{this};
+    Utils::StringAspect chatUrl{this};
+    Utils::StringAspect chatEndPoint{this};
+
+    Utils::StringAspect chatModelName{this};
+    ButtonAspect chatSelectModels{this};
+    Utils::SelectionAspect chatPrompts{this};
+
+    Utils::StringAspect fimModelIndicator{this};
+    Utils::StringAspect fimUrlIndicator{this};
+    Utils::StringAspect chatModelIndicator{this};
+    Utils::StringAspect chatUrlIndicator{this};
+
 private:
     void setupConnections();
-    void updateProviderSettings();
-    void showModelSelectionDialog();
+    void showModelSelectionDialog(Utils::StringAspect *modelNameObj,
+                                  Providers::LLMProvider *provider);
     void resetPageToDefaults();
+
+    void updateStatusIndicators();
+    void setIndicatorStatus(Utils::StringAspect &indicator, const QString &tooltip, bool isValid);
+
+    void setCurrentFimProvider(const QString &name);
+    void setCurrentChatProvider(const QString &name);
+
+    void loadProviders();
+    void loadPrompts();
 };
 
 GeneralSettings &generalSettings();

settings/PresetPromptsSettings.cpp

@@ -45,6 +45,7 @@ PresetPromptsSettings::PresetPromptsSettings()
     temperature.setLabelText(Tr::tr("Temperature:"));
     temperature.setDefaultValue(0.2);
     temperature.setRange(0.0, 10.0);
+    temperature.setSingleStep(0.1);
 
     ollamaLivetime.setSettingsKey(Constants::OLLAMA_LIVETIME);
     ollamaLivetime.setLabelText(
@@ -62,15 +63,16 @@ PresetPromptsSettings::PresetPromptsSettings()
     useTopP.setDefaultValue(false);
 
     topP.setSettingsKey(Constants::TOP_P);
-    topP.setLabelText(Tr::tr("top_p"));
+    topP.setLabelText(Tr::tr("use top_p"));
     topP.setDefaultValue(0.9);
     topP.setRange(0.0, 1.0);
+    topP.setSingleStep(0.1);
 
     useTopK.setSettingsKey(Constants::USE_TOP_K);
     useTopK.setDefaultValue(false);
 
     topK.setSettingsKey(Constants::TOP_K);
-    topK.setLabelText(Tr::tr("top_k"));
+    topK.setLabelText(Tr::tr("use top_k"));
     topK.setDefaultValue(50);
     topK.setRange(1, 1000);
 
@@ -78,17 +80,19 @@ PresetPromptsSettings::PresetPromptsSettings()
     usePresencePenalty.setDefaultValue(false);
 
     presencePenalty.setSettingsKey(Constants::PRESENCE_PENALTY);
-    presencePenalty.setLabelText(Tr::tr("presence_penalty"));
+    presencePenalty.setLabelText(Tr::tr("use presence_penalty"));
     presencePenalty.setDefaultValue(0.0);
     presencePenalty.setRange(-2.0, 2.0);
+    presencePenalty.setSingleStep(0.1);
 
     useFrequencyPenalty.setSettingsKey(Constants::USE_FREQUENCY_PENALTY);
     useFrequencyPenalty.setDefaultValue(false);
 
     frequencyPenalty.setSettingsKey(Constants::FREQUENCY_PENALTY);
-    frequencyPenalty.setLabelText(Tr::tr("frequency_penalty"));
+    frequencyPenalty.setLabelText(Tr::tr("use frequency_penalty"));
     frequencyPenalty.setDefaultValue(0.0);
     frequencyPenalty.setRange(-2.0, 2.0);
+    frequencyPenalty.setSingleStep(0.1);
 
     apiKey.setSettingsKey(Constants::API_KEY);
     apiKey.setLabelText(Tr::tr("API Key:"));
@@ -99,17 +103,12 @@ PresetPromptsSettings::PresetPromptsSettings()
 
     readSettings();
 
-    topK.setEnabled(useTopK());
-    topP.setEnabled(useTopP());
-    presencePenalty.setEnabled(usePresencePenalty());
-    frequencyPenalty.setEnabled(useFrequencyPenalty());
-
     setupConnections();
 
     setLayouter([this]() {
         using namespace Layouting;
         return Column{Row{temperature, Stretch{1}, resetToDefaults},
-                      maxTokens,
+                      Row{maxTokens, Stretch{1}},
                       Row{useTopP, topP, Stretch{1}},
                       Row{useTopK, topK, Stretch{1}},
                       Row{usePresencePenalty, presencePenalty, Stretch{1}},
@@ -121,19 +120,6 @@ PresetPromptsSettings::PresetPromptsSettings()
 
 void PresetPromptsSettings::setupConnections()
 {
-    connect(&useTopP, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        topP.setEnabled(useTopP.volatileValue());
-    });
-    connect(&useTopK, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        topK.setEnabled(useTopK.volatileValue());
-    });
-    connect(&usePresencePenalty, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        presencePenalty.setEnabled(usePresencePenalty.volatileValue());
-    });
-    connect(&useFrequencyPenalty, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        frequencyPenalty.setEnabled(useFrequencyPenalty.volatileValue());
-    });
-
     connect(&resetToDefaults,
             &ButtonAspect::clicked,
             this,
@@ -162,10 +148,6 @@ void PresetPromptsSettings::resetSettingsToDefaults()
         resetAspect(useFrequencyPenalty);
         resetAspect(frequencyPenalty);
     }
-
-    QMessageBox::information(Core::ICore::dialogParent(),
-                             Tr::tr("Settings Reset"),
-                             Tr::tr("All settings have been reset to their default values."));
 }
 
 class PresetPromptsSettingsPage : public Core::IOptionsPage

templates/CodeLlamaFimTemplate.hpp

@@ -23,10 +23,11 @@
 
 namespace QodeAssist::Templates {
 
-class CodeLLamaTemplate : public PromptTemplate
+class CodeLlamaFimTemplate : public PromptTemplate
 {
 public:
-    QString name() const override { return "CodeLlama"; }
+    TemplateType type() const override { return TemplateType::Fim; }
+    QString name() const override { return "CodeLLama FIM"; }
     QString promptTemplate() const override { return "%1<PRE> %2 <SUF>%3 <MID>"; }
     QStringList stopWords() const override
     {

templates/CodeLlamaInstruct.hpp

@@ -0,0 +1,49 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QtCore/qjsonarray.h>
+#include "PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class CodeLlamaInstructTemplate : public PromptTemplate
+{
+public:
+    TemplateType type() const override { return TemplateType::Chat; }
+    QString name() const override { return "CodeLLama Chat"; }
+    QString promptTemplate() const override { return "[INST] %1 [/INST]"; }
+    QStringList stopWords() const override { return QStringList() << "[INST]" << "[/INST]"; }
+
+    void prepareRequest(QJsonObject &request, const ContextData &context) const override
+    {
+        QString formattedPrompt = promptTemplate().arg(context.prefix);
+        QJsonArray messages = request["messages"].toArray();
+
+        QJsonObject newMessage;
+        newMessage["role"] = "user";
+        newMessage["content"] = formattedPrompt;
+        messages.append(newMessage);
+
+        request["messages"] = messages;
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/CustomTemplate.hpp

@@ -32,7 +32,8 @@ namespace QodeAssist::Templates {
 class CustomTemplate : public PromptTemplate
 {
 public:
-    QString name() const override { return "Custom Template"; }
+    TemplateType type() const override { return TemplateType::Fim; }
+    QString name() const override { return "Custom FIM Template"; }
     QString promptTemplate() const override
     {
         return Settings::customPromptSettings().customJsonTemplate();

templates/DeepSeekCoderChatTemplate.hpp

@@ -0,0 +1,54 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * 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/>.
+ */
+
+#pragma once
+
+#include <QJsonArray>
+#include "PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class DeepSeekCoderChatTemplate : public PromptTemplate
+{
+public:
+    QString name() const override { return "DeepSeek Coder Chat"; }
+    TemplateType type() const override { return TemplateType::Chat; }
+
+    QString promptTemplate() const override { return "### Instruction:\n%1\n### Response:\n"; }
+
+    QStringList stopWords() const override
+    {
+        return QStringList() << "### Instruction:" << "### Response:" << "\n\n### " << "<|EOT|>";
+    }
+
+    void prepareRequest(QJsonObject &request, const ContextData &context) const override
+    {
+        QString formattedPrompt = promptTemplate().arg(context.prefix);
+        QJsonArray messages = request["messages"].toArray();
+
+        QJsonObject newMessage;
+        newMessage["role"] = "user";
+        newMessage["content"] = formattedPrompt;
+        messages.append(newMessage);
+
+        request["messages"] = messages;
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/DeepSeekCoderV2.hpp

@@ -26,7 +26,8 @@ namespace QodeAssist::Templates {
 class DeepSeekCoderV2Template : public PromptTemplate
 {
 public:
-    QString name() const override { return "DeepSeekCoderV2"; }
+    TemplateType type() const override { return TemplateType::Fim; }
+    QString name() const override { return "DeepSeekCoder FIM"; }
     QString promptTemplate() const override
     {
         return "%1<｜fim▁begin｜>%2<｜fim▁hole｜>%3<｜fim▁end｜>";

templates/PromptTemplate.hpp

@@ -27,10 +27,13 @@
 
 namespace QodeAssist::Templates {
 
+enum class TemplateType { Chat, Fim };
+
 class PromptTemplate
 {
 public:
     virtual ~PromptTemplate() = default;
+    virtual TemplateType type() const = 0;
     virtual QString name() const = 0;
     virtual QString promptTemplate() const = 0;
     virtual QStringList stopWords() const = 0;

templates/StarCoder2Template.hpp

@@ -26,7 +26,8 @@ namespace QodeAssist::Templates {
 class StarCoder2Template : public PromptTemplate
 {
 public:
-    QString name() const override { return "StarCoder2"; }
+    TemplateType type() const override { return TemplateType::Fim; }
+    QString name() const override { return "StarCoder2 FIM"; }
     QString promptTemplate() const override { return "%1<fim_prefix>%2<fim_suffix>%3<fim_middle>"; }
     QStringList stopWords() const override
     {