Initial commit

2025-07-14 02:54:48 -04:00 · 2024-08-27 11:58:55 +02:00
parent f90ca5bde6
commit 819e103471
37 changed files with 3384 additions and 0 deletions
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@ -0,0 +1,41 @@
+# GitHub Actions & Workflows
+
+The `build_cmake.yml` in this directory adds a [GitHub action][1] and workflow that builds
+your plugin anytime you push commits to GitHub on Windows, Linux and macOS.
+
+The build artifacts can be downloaded from GitHub and be installed into an existing Qt Creator
+installation.
+
+When you push a tag, the workflow also creates a new release on GitHub.
+
+## Keeping it up to date
+
+Near the top of the file you find a section starting with `env:`.
+
+The value for `QT_VERSION` specifies the Qt version to use for building the plugin.
+
+The value for `QT_CREATOR_VERSION` specifies the Qt Creator version to use for building the plugin.
+
+The value for `QT_CREATOR_SNAPSHOT` can either be `NO` or `latest` or the build ID of a specific
+snapshot build for the Qt Creator version that you specified.
+
+You need to keep these values updated for different versions of your plugin, and take care
+that the Qt version and Qt Creator version you specify are compatible.
+
+## What it does
+
+The build job consists of several steps:
+
+* Install required packages on the build host
+* Download, unpack and install the binary for the Qt version
+* Download and unpack the binary for the Qt Creator version
+* Build the plugin and upload the plugin libraries to GitHub
+* If a tag is pushed, create a release on GitHub for the tag, including zipped plugin libraries
+  for download
+
+## Limitations
+
+If your plugin requires additional resources besides the plugin library, you need to adapt the
+script accordingly.
+
+[1]: https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-github-actions
--- a/.github/workflows/build_cmake.yml
+++ b/.github/workflows/build_cmake.yml
@ -0,0 +1,304 @@
+name: Build plugin
+
+on: [push]
+
+env:
+  PLUGIN_NAME: QodeAssist
+  QT_VERSION: 6.7.2
+  QT_CREATOR_VERSION: 14.0.0
+  QT_CREATOR_SNAPSHOT: NO
+  MACOS_DEPLOYMENT_TARGET: "11.0"
+  CMAKE_VERSION: "3.29.6"
+  NINJA_VERSION: "1.12.1"
+
+jobs:
+  build:
+    name: ${{ matrix.config.name }}
+    runs-on: ${{ matrix.config.os }}
+    outputs:
+        tag: ${{ steps.git.outputs.tag }}
+    strategy:
+      matrix:
+        config:
+        - {
+            name: "Windows Latest MSVC", artifact: "Windows-x64",
+            os: windows-latest,
+            cc: "cl", cxx: "cl",
+            environment_script: "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvars64.bat",
+          }
+        - {
+            name: "Ubuntu Latest GCC", artifact: "Linux-x64",
+            os: ubuntu-latest,
+            cc: "gcc", cxx: "g++"
+          }
+        - {
+            name: "macOS Latest Clang", artifact: "macOS-universal",
+            os: macos-latest,
+            cc: "clang", cxx: "clang++"
+          }
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Checkout submodules
+      id: git
+      shell: cmake -P {0}
+      run: |
+        if (${{github.ref}} MATCHES "tags/v(.*)")
+            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${CMAKE_MATCH_1}\n")
+        else()
+            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${{github.run_id}}\n")
+        endif()
+
+    - name: Download Ninja and CMake
+      shell: cmake -P {0}
+      run: |
+        set(cmake_version "$ENV{CMAKE_VERSION}")
+        set(ninja_version "$ENV{NINJA_VERSION}")
+
+        if ("${{ runner.os }}" STREQUAL "Windows")
+          set(ninja_suffix "win.zip")
+          set(cmake_suffix "windows-x86_64.zip")
+          set(cmake_dir "cmake-${cmake_version}-windows-x86_64/bin")
+        elseif ("${{ runner.os }}" STREQUAL "Linux")
+          set(ninja_suffix "linux.zip")
+          set(cmake_suffix "linux-x86_64.tar.gz")
+          set(cmake_dir "cmake-${cmake_version}-linux-x86_64/bin")
+        elseif ("${{ runner.os }}" STREQUAL "macOS")
+          set(ninja_suffix "mac.zip")
+          set(cmake_suffix "macos-universal.tar.gz")
+          set(cmake_dir "cmake-${cmake_version}-macos-universal/CMake.app/Contents/bin")
+        endif()
+
+        set(ninja_url "https://github.com/ninja-build/ninja/releases/download/v${ninja_version}/ninja-${ninja_suffix}")
+        file(DOWNLOAD "${ninja_url}" ./ninja.zip SHOW_PROGRESS)
+        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ninja.zip)
+
+        set(cmake_url "https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-${cmake_suffix}")
+        file(DOWNLOAD "${cmake_url}" ./cmake.zip SHOW_PROGRESS)
+        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./cmake.zip)
+
+        # Add to PATH environment variable
+        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/${cmake_dir}" cmake_dir)
+        set(path_separator ":")
+        if ("${{ runner.os }}" STREQUAL "Windows")
+          set(path_separator ";")
+        endif()
+        file(APPEND "$ENV{GITHUB_PATH}" "$ENV{GITHUB_WORKSPACE}${path_separator}${cmake_dir}")
+
+        if (NOT "${{ runner.os }}" STREQUAL "Windows")
+          execute_process(
+            COMMAND chmod +x ninja
+            COMMAND chmod +x ${cmake_dir}/cmake
+          )
+        endif()
+
+    - name: Install system libs
+      shell: cmake -P {0}
+      run: |
+        if ("${{ runner.os }}" STREQUAL "Linux")
+          execute_process(
+            COMMAND sudo apt update
+          )
+          execute_process(
+            COMMAND sudo apt install libgl1-mesa-dev
+            RESULT_VARIABLE result
+          )
+          if (NOT result EQUAL 0)
+            message(FATAL_ERROR "Failed to install dependencies")
+          endif()
+        endif()
+
+    - name: Download Qt
+      id: qt
+      shell: cmake -P {0}
+      run: |
+        set(qt_version "$ENV{QT_VERSION}")
+
+        string(REPLACE "." "" qt_version_dotless "${qt_version}")
+        if ("${{ runner.os }}" STREQUAL "Windows")
+          set(url_os "windows_x86")
+          set(qt_package_arch_suffix "win64_msvc2019_64")
+          set(qt_dir_prefix "${qt_version}/msvc2019_64")
+          set(qt_package_suffix "-Windows-Windows_10_22H2-MSVC2019-Windows-Windows_10_22H2-X86_64")
+        elseif ("${{ runner.os }}" STREQUAL "Linux")
+          set(url_os "linux_x64")
+          if (qt_version VERSION_LESS "6.7.0")
+            set(qt_package_arch_suffix "gcc_64")
+          else()
+            set(qt_package_arch_suffix "linux_gcc_64")
+          endif()
+          set(qt_dir_prefix "${qt_version}/gcc_64")
+          set(qt_package_suffix "-Linux-RHEL_8_8-GCC-Linux-RHEL_8_8-X86_64")
+        elseif ("${{ runner.os }}" STREQUAL "macOS")
+          set(url_os "mac_x64")
+          set(qt_package_arch_suffix "clang_64")
+          set(qt_dir_prefix "${qt_version}/macos")
+          set(qt_package_suffix "-MacOS-MacOS_13-Clang-MacOS-MacOS_13-X86_64-ARM64")
+        endif()
+
+        set(qt_base_url "https://download.qt.io/online/qtsdkrepository/${url_os}/desktop/qt6_${qt_version_dotless}")
+        file(DOWNLOAD "${qt_base_url}/Updates.xml" ./Updates.xml SHOW_PROGRESS)
+
+        file(READ ./Updates.xml updates_xml)
+        string(REGEX MATCH "<Name>qt.qt6.*<Version>([0-9+-.]+)</Version>" updates_xml_output "${updates_xml}")
+        set(qt_package_version ${CMAKE_MATCH_1})
+
+        file(MAKE_DIRECTORY qt6)
+
+        # Save the path for other steps
+        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/qt6/${qt_dir_prefix}" qt_dir)
+        file(APPEND "$ENV{GITHUB_OUTPUT}" "qt_dir=${qt_dir}")
+
+        message("Downloading Qt to ${qt_dir}")
+        function(downloadAndExtract url archive)
+          message("Downloading ${url}")
+          file(DOWNLOAD "${url}" ./${archive} SHOW_PROGRESS)
+          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../${archive} WORKING_DIRECTORY qt6)
+        endfunction()
+
+        foreach(package qtbase qtdeclarative)
+          downloadAndExtract(
+            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
+            ${package}.7z
+          )
+        endforeach()
+
+        foreach(package qt5compat qtshadertools)
+          downloadAndExtract(
+            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${package}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
+            ${package}.7z
+          )
+        endforeach()
+
+        # uic depends on libicu*.so
+        if ("${{ runner.os }}" STREQUAL "Linux")
+          if (qt_version VERSION_LESS "6.7.0")
+            set(uic_suffix "Rhel7.2-x64")
+          else()
+            set(uic_suffix "Rhel8.6-x86_64")
+          endif()
+          downloadAndExtract(
+            "${qt_base_url}/qt.qt6.${qt_version_dotless}.${qt_package_arch_suffix}/${qt_package_version}icu-linux-${uic_suffix}.7z"
+            icu.7z
+          )
+        endif()
+
+    - name: Download Qt Creator
+      id: qt_creator
+      shell: cmake -P {0}
+      run: |
+        string(REGEX MATCH "([0-9]+.[0-9]+).[0-9]+" outvar "$ENV{QT_CREATOR_VERSION}")
+
+        set(qtc_base_url "https://download.qt.io/official_releases/qtcreator/${CMAKE_MATCH_1}/$ENV{QT_CREATOR_VERSION}/installer_source")
+        set(qtc_snapshot "$ENV{QT_CREATOR_SNAPSHOT}")
+        if (qtc_snapshot)
+          set(qtc_base_url "https://download.qt.io/snapshots/qtcreator/${CMAKE_MATCH_1}/$ENV{QT_CREATOR_VERSION}/installer_source/${qtc_snapshot}")
+        endif()
+
+        if ("${{ runner.os }}" STREQUAL "Windows")
+          set(qtc_platform "windows_x64")
+        elseif ("${{ runner.os }}" STREQUAL "Linux")
+          set(qtc_platform "linux_x64")
+        elseif ("${{ runner.os }}" STREQUAL "macOS")
+          set(qtc_platform "mac_x64")
+        endif()
+
+        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/qtcreator" qtc_dir)
+        # Save the path for other steps
+        file(APPEND "$ENV{GITHUB_OUTPUT}" "qtc_dir=${qtc_dir}")
+
+        file(MAKE_DIRECTORY qtcreator)
+
+        message("Downloading Qt Creator from ${qtc_base_url}/${qtc_platform}")
+
+        foreach(package qtcreator qtcreator_dev)
+          file(DOWNLOAD
+            "${qtc_base_url}/${qtc_platform}/${package}.7z" ./${package}.7z SHOW_PROGRESS)
+          execute_process(COMMAND
+            ${CMAKE_COMMAND} -E tar xvf ../${package}.7z WORKING_DIRECTORY qtcreator)
+        endforeach()
+
+    - name: Build
+      shell: cmake -P {0}
+      run: |
+        set(ENV{CC} ${{ matrix.config.cc }})
+        set(ENV{CXX} ${{ matrix.config.cxx }})
+        set(ENV{MACOSX_DEPLOYMENT_TARGET} "${{ env.MACOS_DEPLOYMENT_TARGET }}")
+
+        if ("${{ runner.os }}" STREQUAL "Windows" AND NOT "x${{ matrix.config.environment_script }}" STREQUAL "x")
+          execute_process(
+            COMMAND "${{ matrix.config.environment_script }}" && set
+            OUTPUT_FILE environment_script_output.txt
+          )
+          file(STRINGS environment_script_output.txt output_lines)
+          foreach(line IN LISTS output_lines)
+            if (line MATCHES "^([a-zA-Z0-9_-]+)=(.*)$")
+              set(ENV{${CMAKE_MATCH_1}} "${CMAKE_MATCH_2}")
+            endif()
+          endforeach()
+        endif()
+
+        set(ENV{NINJA_STATUS} "[%f/%t %o/sec] ")
+        if ("${{ runner.os }}" STREQUAL "macOS")
+            set(ENV{CMAKE_OSX_ARCHITECTURES} "x86_64;arm64")
+        endif()
+
+        set(build_plugin_py "scripts/build_plugin.py")
+        foreach(dir "share/qtcreator/scripts" "Qt Creator.app/Contents/Resources/scripts" "Contents/Resources/scripts")
+          if(EXISTS "${{ steps.qt_creator.outputs.qtc_dir }}/${dir}/build_plugin.py")
+            set(build_plugin_py "${dir}/build_plugin.py")
+            break()
+          endif()
+        endforeach()
+
+        execute_process(
+          COMMAND python
+            -u
+            "${{ steps.qt_creator.outputs.qtc_dir }}/${build_plugin_py}"
+            --name "$ENV{PLUGIN_NAME}-$ENV{QT_CREATOR_VERSION}-${{ matrix.config.artifact }}"
+            --src .
+            --build build
+            --qt-path "${{ steps.qt.outputs.qt_dir }}"
+            --qtc-path "${{ steps.qt_creator.outputs.qtc_dir }}"
+            --output-path "$ENV{GITHUB_WORKSPACE}"
+          RESULT_VARIABLE result
+        )
+        if (NOT result EQUAL 0)
+          string(REGEX MATCH "FAILED:.*$" error_message "${output}")
+          string(REPLACE "\n" "%0A" error_message "${error_message}")
+          message("::error::${error_message}")
+          message(FATAL_ERROR "Build failed")
+        endif()
+
+    - name: Upload
+      uses: actions/upload-artifact@v4
+      with:
+        path: ./${{ env.PLUGIN_NAME }}-${{ env.QT_CREATOR_VERSION }}-${{ matrix.config.artifact }}.7z
+        name: ${{ env.PLUGIN_NAME}}-${{ env.QT_CREATOR_VERSION }}-${{ matrix.config.artifact }}.7z
+
+  release:
+    if: contains(github.ref, 'tags/v')
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - name: Download artifacts
+      uses: actions/download-artifact@v4
+      with:
+        path: release-with-dirs
+
+    - name: Fixup artifacts
+      run: |
+        mkdir release
+        mv release-with-dirs/*/* release/
+
+    - name: Create Release
+      id: create_release
+      uses: softprops/action-gh-release@v2
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: v${{ needs.build.outputs.tag }}
+        files: release/*
+        draft: false
+        prerelease: false
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,75 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+CMakeLists.txt.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+
+/build
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(QodeAssist)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+find_package(QtCreator REQUIRED COMPONENTS Core)
+find_package(Qt6 COMPONENTS Widgets REQUIRED)
+
+add_qtc_plugin(QodeAssist
+  PLUGIN_DEPENDS
+    QtCreator::Core
+    QtCreator::LanguageClient
+    QtCreator::TextEditor
+  DEPENDS
+    Qt::Widgets
+    QtCreator::ExtensionSystem
+    QtCreator::Utils
+    QtCreator::ProjectExplorer
+  SOURCES
+    .github/workflows/build_cmake.yml
+    .github/workflows/README.md
+    README.md
+    qodeassist.cpp
+    QodeAssistConstants.hpp
+    QodeAssisttr.h
+    LLMClientInterface.hpp LLMClientInterface.cpp
+    PromptTemplateManager.hpp PromptTemplateManager.cpp
+    templates/PromptTemplate.hpp
+    templates/CodeLLamaTemplate.hpp
+    templates/StarCoder2Template.hpp
+    providers/LLMProvider.hpp
+    providers/OllamaProvider.hpp providers/OllamaProvider.cpp
+    providers/LMStudioProvider.hpp providers/LMStudioProvider.cpp
+    LLMProvidersManager.hpp LLMProvidersManager.cpp
+    QodeAssistSettings.hpp QodeAssistSettings.cpp
+    QodeAssist.qrc
+    LSPCompletion.hpp
+    LLMSuggestion.hpp LLMSuggestion.cpp
+    QodeAssistHoverHandler.hpp QodeAssistHoverHandler.cpp
+    QodeAssistClient.hpp QodeAssistClient.cpp
+    QodeAssistUtils.hpp
+)
--- a/LLMClientInterface.cpp
+++ b/LLMClientInterface.cpp
@ -0,0 +1,394 @@
+/* 
+ * 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 "LLMClientInterface.hpp"
+
+#include <QJsonDocument>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+
+#include <texteditor/textdocument.h>
+
+#include "LLMProvidersManager.hpp"
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistSettings.hpp"
+#include "QodeAssistUtils.hpp"
+
+namespace QodeAssist {
+
+LLMClientInterface::LLMClientInterface()
+    : m_manager(new QNetworkAccessManager(this))
+{
+    updateProvider();
+}
+
+Utils::FilePath LLMClientInterface::serverDeviceTemplate() const
+{
+    return "Qode Assist";
+}
+
+void LLMClientInterface::startImpl()
+{
+    emit started();
+}
+
+void LLMClientInterface::sendData(const QByteArray &data)
+{
+    updateProvider();
+
+    QJsonDocument doc = QJsonDocument::fromJson(data);
+    if (!doc.isObject())
+        return;
+
+    QJsonObject request = doc.object();
+    QString method = request["method"].toString();
+
+    if (method == "initialize") {
+        handleInitialize(request);
+    } else if (method == "initialized") {
+        // TODO make initilizied handler
+    } else if (method == "shutdown") {
+        handleShutdown(request);
+    } else if (method == "textDocument/didOpen") {
+        handleTextDocumentDidOpen(request);
+    } else if (method == "getCompletionsCycling") {
+        handleCompletion(request);
+    } else if (method == "$/cancelRequest") {
+        handleCancelRequest(request);
+    } else if (method == "exit") {
+        // TODO make exit handler
+    } else {
+        logMessage(QString("Unknown method: %1").arg(method));
+    }
+}
+
+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);
+        logMessage(QString("Request %1 cancelled successfully").arg(id));
+    } else {
+        logMessage(QString("Request %1 not found").arg(id));
+    }
+}
+
+QString LLMClientInterface::сontextBefore(TextEditor::TextEditorWidget *widget,
+                                          int lineNumber,
+                                          int cursorPosition)
+{
+    if (!widget)
+        return QString();
+
+    QTextDocument *doc = widget->document();
+    int totalLines = doc->blockCount();
+    QTextBlock currentBlock = doc->findBlockByLineNumber(lineNumber);
+
+    QString beforeCursor;
+
+    if (settings().readFullFile() && totalLines < settings().maxFileThreshold()) {
+        // Read all content from the beginning of the file to the cursor
+        QTextBlock block = doc->begin();
+        while (block.isValid() && block.blockNumber() <= lineNumber) {
+            if (block.blockNumber() == lineNumber) {
+                beforeCursor += block.text().left(cursorPosition);
+                break;
+            } else {
+                beforeCursor += block.text() + "\n";
+            }
+            block = block.next();
+        }
+    } else {
+        // Read only the specified number of lines before the cursor
+        int contextLinesBefore = settings().readStringsBeforeCursor();
+        QTextBlock block = currentBlock;
+        for (int i = 0; i < contextLinesBefore && block.isValid(); ++i) {
+            if (block.blockNumber() == lineNumber) {
+                beforeCursor = block.text().left(cursorPosition) + beforeCursor;
+            } else {
+                beforeCursor = block.text() + "\n" + beforeCursor;
+            }
+            block = block.previous();
+        }
+    }
+
+    return beforeCursor;
+}
+
+QString LLMClientInterface::сontextAfter(TextEditor::TextEditorWidget *widget,
+                                         int lineNumber,
+                                         int cursorPosition)
+{
+    if (!widget)
+        return QString();
+
+    QTextDocument *doc = widget->document();
+    int totalLines = doc->blockCount();
+    QTextBlock currentBlock = doc->findBlockByLineNumber(lineNumber);
+
+    QString afterCursor;
+
+    if (settings().readFullFile() && totalLines < settings().maxFileThreshold()) {
+        // Read all content from the cursor to the end of the file
+        QTextBlock block = currentBlock;
+        bool isFirstBlock = true;
+        while (block.isValid()) {
+            if (isFirstBlock) {
+                afterCursor += block.text().mid(cursorPosition) + "\n";
+                isFirstBlock = false;
+            } else {
+                afterCursor += block.text() + "\n";
+            }
+            block = block.next();
+        }
+    } else {
+        // Read only the specified number of lines after the cursor
+        int contextLinesAfter = settings().readStringsAfterCursor();
+        QTextBlock block = currentBlock;
+        for (int i = 0; i < contextLinesAfter && block.isValid(); ++i) {
+            if (block.blockNumber() == lineNumber) {
+                afterCursor += block.text().mid(cursorPosition);
+            } else {
+                afterCursor += block.text();
+            }
+            afterCursor += "\n";
+            block = block.next();
+        }
+    }
+
+    return afterCursor;
+}
+
+void LLMClientInterface::handleInitialize(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["id"] = request["id"];
+
+    QJsonObject result;
+    QJsonObject capabilities;
+    capabilities["textDocumentSync"] = 1;
+    capabilities["completionProvider"] = QJsonObject{{"resolveProvider", false}};
+    capabilities["hoverProvider"] = true;
+    result["capabilities"] = capabilities;
+
+    QJsonObject serverInfo;
+    serverInfo["name"] = "Ollama LSP Server";
+    serverInfo["version"] = "0.1";
+    result["serverInfo"] = serverInfo;
+
+    response["result"] = result;
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleShutdown(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["id"] = request["id"];
+    response["result"] = QJsonValue();
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleTextDocumentDidOpen(const QJsonObject &request)
+{
+}
+
+void LLMClientInterface::handleInitialized(const QJsonObject &request)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response["method"] = "initialized";
+    response["params"] = QJsonObject();
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::handleExit(const QJsonObject &request)
+{
+    emit finished();
+}
+
+void LLMClientInterface::handleLLMResponse(QNetworkReply *reply, const QJsonObject &request)
+{
+    QString &accumulatedResponse = m_accumulatedResponses[reply];
+
+    auto &templateManager = PromptTemplateManager::instance();
+    const Templates::PromptTemplate *currentTemplate = templateManager.getCurrentTemplate();
+
+    auto &providerManager = LLMProvidersManager::instance();
+    bool isComplete = providerManager.getCurrentProvider()->handleResponse(reply,
+                                                                           accumulatedResponse);
+
+    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+
+    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 QString &accumulatedCompletion)
+{
+    auto updatedContext = prepareContext(request, accumulatedCompletion);
+    sendLLMRequest(request, updatedContext);
+}
+
+LLMClientInterface::ContextPair LLMClientInterface::prepareContext(
+    const QJsonObject &request, const QString &accumulatedCompletion)
+{
+    QJsonObject params = request["params"].toObject();
+    QJsonObject doc = params["doc"].toObject();
+    QJsonObject position = doc["position"].toObject();
+    QString uri = doc["uri"].toString();
+
+    Utils::FilePath filePath = Utils::FilePath::fromString(QUrl(uri).toLocalFile());
+    TextEditor::TextDocument *textDocument = TextEditor::TextDocument::textDocumentForFilePath(
+        filePath);
+
+    if (!textDocument) {
+        logMessage("Error: Document is not available for" + filePath.toString());
+        return {"", ""};
+    }
+
+    int cursorPosition = position["character"].toInt();
+    int lineNumber = position["line"].toInt();
+
+    auto textEditor = TextEditor::BaseTextEditor::currentTextEditor();
+    TextEditor::TextEditorWidget *widget = textEditor->editorWidget();
+
+    QString contextBefore = сontextBefore(widget, lineNumber, cursorPosition);
+    QString contextAfter = сontextAfter(widget, lineNumber, cursorPosition);
+
+    QString updatedContextBefore = contextBefore + accumulatedCompletion;
+
+    return {updatedContextBefore, contextAfter};
+}
+
+void LLMClientInterface::updateProvider()
+{
+    m_serverUrl = QUrl(QString("%1:%2%3")
+                           .arg(settings().url.value())
+                           .arg(settings().port.value())
+                           .arg(settings().endPoint.value()));
+}
+
+void LLMClientInterface::sendCompletionToClient(const QString &completion,
+                                                const QJsonObject &request,
+                                                const QJsonObject &position,
+                                                bool isComplete)
+{
+    QJsonObject response;
+    response["jsonrpc"] = "2.0";
+    response[LanguageServerProtocol::idKey] = request["id"];
+    QJsonObject result;
+    QJsonArray completions;
+    QJsonObject completionItem;
+    completionItem[LanguageServerProtocol::textKey] = completion;
+    QJsonObject range;
+    range["start"] = position;
+    QJsonObject end = position;
+    end["character"] = position["character"].toInt() + completion.length();
+    range["end"] = end;
+    completionItem[LanguageServerProtocol::rangeKey] = range;
+    completionItem[LanguageServerProtocol::positionKey] = position;
+    completions.append(completionItem);
+    result["completions"] = completions;
+    result[LanguageServerProtocol::isIncompleteKey] = !isComplete;
+    response[LanguageServerProtocol::resultKey] = result;
+
+    logMessage(
+        QString("Completions: \n%1")
+            .arg(QString::fromUtf8(QJsonDocument(completions).toJson(QJsonDocument::Indented))));
+
+    logMessage(QString("Full response: \n%1")
+                   .arg(QString::fromUtf8(QJsonDocument(response).toJson(QJsonDocument::Indented))));
+
+    emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
+}
+
+void LLMClientInterface::sendLLMRequest(const QJsonObject &request, const ContextPair &prompt)
+{
+    QJsonObject ollamaRequest = {{"model", settings().modelName.value()}, {"stream", true}};
+
+    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+    currentTemplate->prepareRequest(ollamaRequest, prompt.prefix, prompt.suffix);
+
+    auto &providerManager = LLMProvidersManager::instance();
+    providerManager.getCurrentProvider()->prepareRequest(ollamaRequest);
+
+    logMessage(
+        QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
+            .arg(m_serverUrl.toString())
+            .arg(QString::fromUtf8(QJsonDocument(ollamaRequest).toJson(QJsonDocument::Indented))));
+
+    QNetworkRequest networkRequest(m_serverUrl);
+    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    QNetworkReply *reply = m_manager->post(networkRequest, QJsonDocument(ollamaRequest).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 Ollama request: %1").arg(reply->errorString()));
+        } else {
+            logMessage("Request finished successfully");
+        }
+    });
+}
+
+QString LLMClientInterface::removeStopWords(const QString &completion)
+{
+    QString filteredCompletion = completion;
+
+    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+    QStringList stopWords = currentTemplate->stopWords();
+
+    for (const QString &stopWord : stopWords) {
+        filteredCompletion = filteredCompletion.replace(stopWord, "");
+    }
+
+    return filteredCompletion;
+}
+
+void LLMClientInterface::parseCurrentMessage()
+{
+}
+
+} // namespace QodeAssist
--- a/LLMClientInterface.hpp
+++ b/LLMClientInterface.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 <languageclient/languageclientinterface.h>
+#include <texteditor/texteditor.h>
+
+class QNetworkReply;
+class QNetworkAccessManager;
+
+namespace QodeAssist {
+
+class LLMClientInterface : public LanguageClient::BaseClientInterface
+{
+    Q_OBJECT
+
+public:
+    LLMClientInterface();
+
+public:
+    struct ContextPair
+    {
+        QString prefix;
+        QString suffix;
+    };
+
+    Utils::FilePath serverDeviceTemplate() const override;
+
+    void sendCompletionToClient(const QString &completion,
+                                const QJsonObject &request,
+                                const QJsonObject &position,
+                                bool isComplete);
+
+    void handleCompletion(const QJsonObject &request,
+                          const QString &accumulatedCompletion = QString());
+    void sendLLMRequest(const QJsonObject &request, const ContextPair &prompt);
+    void handleLLMResponse(QNetworkReply *reply, const QJsonObject &request);
+
+    ContextPair prepareContext(const QJsonObject &request,
+                               const QString &accumulatedCompletion = QString{});
+    void updateProvider();
+
+protected:
+    void startImpl() override;
+    void sendData(const QByteArray &data) override;
+    void parseCurrentMessage() override;
+
+private:
+    void handleInitialize(const QJsonObject &request);
+    void handleShutdown(const QJsonObject &request);
+    void handleTextDocumentDidOpen(const QJsonObject &request);
+    void handleInitialized(const QJsonObject &request);
+    void handleExit(const QJsonObject &request);
+    void handleCancelRequest(const QJsonObject &request);
+
+    QString сontextBefore(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
+    QString сontextAfter(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
+    QString removeStopWords(const QString &completion);
+
+    QUrl m_serverUrl;
+    QNetworkAccessManager *m_manager;
+    QMap<QString, QNetworkReply *> m_activeRequests;
+    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+};
+
+} // namespace QodeAssist
--- a/LLMProvidersManager.cpp
+++ b/LLMProvidersManager.cpp
@ -0,0 +1,56 @@
+/* 
+ * 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 "LLMProvidersManager.hpp"
+
+namespace QodeAssist {
+
+LLMProvidersManager &LLMProvidersManager::instance()
+{
+    static LLMProvidersManager instance;
+    return instance;
+}
+
+QStringList LLMProvidersManager::getProviderNames() const
+{
+    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()) {
+        return nullptr;
+    }
+
+    return m_providers[m_currentProviderName];
+}
+
+LLMProvidersManager::~LLMProvidersManager()
+{
+    qDeleteAll(m_providers);
+}
+
+} // namespace QodeAssist
--- a/LLMProvidersManager.hpp
+++ b/LLMProvidersManager.hpp
@ -0,0 +1,58 @@
+/* 
+ * 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 <QString>
+
+#include "providers/LLMProvider.hpp"
+
+namespace QodeAssist {
+
+class LLMProvidersManager
+{
+public:
+    static LLMProvidersManager &instance();
+
+    template<typename T>
+    void registerProvider()
+    {
+        static_assert(std::is_base_of<Providers::LLMProvider, T>::value,
+                      "T must inherit from LLMProvider");
+        T *provider = new T();
+        QString name = provider->name();
+        m_providers[name] = provider;
+    }
+
+    QStringList getProviderNames() const;
+    void setCurrentProvider(const QString &name);
+    Providers::LLMProvider *getCurrentProvider();
+
+    ~LLMProvidersManager();
+
+private:
+    LLMProvidersManager() = default;
+    LLMProvidersManager(const LLMProvidersManager &) = delete;
+    LLMProvidersManager &operator=(const LLMProvidersManager &) = delete;
+
+    QMap<QString, Providers::LLMProvider *> m_providers;
+    QString m_currentProviderName;
+};
+
+} // namespace QodeAssist
--- a/LLMSuggestion.cpp
+++ b/LLMSuggestion.cpp
@ -0,0 +1,80 @@
+/* 
+ * 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 "LLMSuggestion.hpp"
+
+namespace QodeAssist {
+
+LLMSuggestion::LLMSuggestion(const Completion &completion, QTextDocument *origin)
+    : m_completion(completion)
+{
+    int startPos = completion.range().start().toPositionInDocument(origin);
+    int endPos = completion.range().end().toPositionInDocument(origin);
+
+    startPos = qBound(0, startPos, origin->characterCount() - 1);
+    endPos = qBound(startPos, endPos, origin->characterCount() - 1);
+
+    m_start = QTextCursor(origin);
+    m_start.setPosition(startPos);
+    m_start.setKeepPositionOnInsert(true);
+
+    QTextCursor cursor(origin);
+    cursor.setPosition(startPos);
+    cursor.setPosition(endPos, QTextCursor::KeepAnchor);
+
+    QTextBlock block = cursor.block();
+    QString blockText = block.text();
+
+    int startPosInBlock = startPos - block.position();
+    int endPosInBlock = endPos - block.position();
+
+    blockText.replace(startPosInBlock, endPosInBlock - startPosInBlock, completion.text());
+
+    document()->setPlainText(blockText);
+
+    setCurrentPosition(m_start.position());
+}
+
+bool LLMSuggestion::apply()
+{
+    QTextCursor cursor = m_completion.range().toSelection(m_start.document());
+    cursor.beginEditBlock();
+    cursor.removeSelectedText();
+    cursor.insertText(m_completion.text());
+    cursor.endEditBlock();
+    return true;
+}
+
+bool LLMSuggestion::applyWord(TextEditor::TextEditorWidget *widget)
+{
+    Q_UNUSED(widget)
+    return apply();
+}
+
+void LLMSuggestion::reset()
+{
+    m_start.removeSelectedText();
+}
+
+int LLMSuggestion::position()
+{
+    return m_start.position();
+}
+
+} // namespace QodeAssist
--- a/LLMSuggestion.hpp
+++ b/LLMSuggestion.hpp
@ -0,0 +1,45 @@
+/* 
+ * 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 <texteditor/textdocumentlayout.h>
+
+#include "LSPCompletion.hpp"
+
+namespace QodeAssist {
+
+class LLMSuggestion final : public TextEditor::TextSuggestion
+{
+public:
+    LLMSuggestion(const Completion &completion, QTextDocument *origin);
+
+    bool apply() final;
+    bool applyWord(TextEditor::TextEditorWidget *widget) final;
+    void reset() final;
+    int position() final;
+
+    const Completion &completion() const { return m_completion; }
+
+private:
+    Completion m_completion;
+    QTextCursor m_start;
+};
+
+} // namespace QodeAssist
--- a/LSPCompletion.hpp
+++ b/LSPCompletion.hpp
@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <languageserverprotocol/jsonkeys.h>
+#include <languageserverprotocol/jsonrpcmessages.h>
+#include <languageserverprotocol/lsptypes.h>
+
+namespace QodeAssist {
+
+class Completion : public LanguageServerProtocol::JsonObject
+{
+    static constexpr LanguageServerProtocol::Key displayTextKey{"displayText"};
+    static constexpr LanguageServerProtocol::Key uuidKey{"uuid"};
+
+public:
+    using JsonObject::JsonObject;
+
+    QString displayText() const { return typedValue<QString>(displayTextKey); }
+    LanguageServerProtocol::Position position() const
+    {
+        return typedValue<LanguageServerProtocol::Position>(LanguageServerProtocol::positionKey);
+    }
+    LanguageServerProtocol::Range range() const
+    {
+        return typedValue<LanguageServerProtocol::Range>(LanguageServerProtocol::rangeKey);
+    }
+    QString text() const { return typedValue<QString>(LanguageServerProtocol::textKey); }
+    void setText(const QString &text) { insert(LanguageServerProtocol::textKey, text); }
+    QString uuid() const { return typedValue<QString>(uuidKey); }
+
+    bool isValid() const override
+    {
+        return contains(LanguageServerProtocol::textKey)
+               && contains(LanguageServerProtocol::rangeKey)
+               && contains(LanguageServerProtocol::positionKey);
+    }
+};
+
+class GetCompletionParams : public LanguageServerProtocol::JsonObject
+{
+public:
+    static constexpr LanguageServerProtocol::Key docKey{"doc"};
+
+    GetCompletionParams(const LanguageServerProtocol::TextDocumentIdentifier &document,
+                        int version,
+                        const LanguageServerProtocol::Position &position)
+    {
+        setTextDocument(document);
+        setVersion(version);
+        setPosition(position);
+    }
+    using JsonObject::JsonObject;
+
+    // The text document.
+    LanguageServerProtocol::TextDocumentIdentifier textDocument() const
+    {
+        return typedValue<LanguageServerProtocol::TextDocumentIdentifier>(docKey);
+    }
+    void setTextDocument(const LanguageServerProtocol::TextDocumentIdentifier &id)
+    {
+        insert(docKey, id);
+    }
+
+    // The position inside the text document.
+    LanguageServerProtocol::Position position() const
+    {
+        return LanguageServerProtocol::fromJsonValue<LanguageServerProtocol::Position>(
+            value(docKey).toObject().value(LanguageServerProtocol::positionKey));
+    }
+    void setPosition(const LanguageServerProtocol::Position &position)
+    {
+        QJsonObject result = value(docKey).toObject();
+        result[LanguageServerProtocol::positionKey] = (QJsonObject) position;
+        insert(docKey, result);
+    }
+
+    // The version
+    int version() const { return typedValue<int>(LanguageServerProtocol::versionKey); }
+    void setVersion(int version)
+    {
+        QJsonObject result = value(docKey).toObject();
+        result[LanguageServerProtocol::versionKey] = version;
+        insert(docKey, result);
+    }
+
+    bool isValid() const override
+    {
+        return contains(docKey)
+               && value(docKey).toObject().contains(LanguageServerProtocol::positionKey)
+               && value(docKey).toObject().contains(LanguageServerProtocol::versionKey);
+    }
+};
+
+class GetCompletionResponse : public LanguageServerProtocol::JsonObject
+{
+    static constexpr LanguageServerProtocol::Key completionKey{"completions"};
+
+public:
+    using JsonObject::JsonObject;
+
+    LanguageServerProtocol::LanguageClientArray<Completion> completions() const
+    {
+        return clientArray<Completion>(completionKey);
+    }
+};
+
+class GetCompletionRequest
+    : public LanguageServerProtocol::Request<GetCompletionResponse, std::nullptr_t, GetCompletionParams>
+{
+public:
+    explicit GetCompletionRequest(const GetCompletionParams &params = {})
+        : Request(methodName, params)
+    {}
+    using Request::Request;
+    constexpr static const LanguageServerProtocol::Key methodName{"getCompletionsCycling"};
+};
+} // namespace QodeAssist
--- a/PromptTemplateManager.cpp
+++ b/PromptTemplateManager.cpp
@ -0,0 +1,53 @@
+/* 
+ * 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 "PromptTemplateManager.hpp"
+
+namespace QodeAssist {
+
+PromptTemplateManager &PromptTemplateManager::instance()
+{
+    static PromptTemplateManager instance;
+    return instance;
+}
+
+void PromptTemplateManager::setCurrentTemplate(const QString &name)
+{
+    if (m_templates.contains(name)) {
+        m_currentTemplateName = name;
+    }
+}
+
+const Templates::PromptTemplate *PromptTemplateManager::getCurrentTemplate() const
+{
+    auto it = m_templates.find(m_currentTemplateName);
+    return it != m_templates.end() ? it.value() : nullptr;
+}
+
+QStringList PromptTemplateManager::getTemplateNames() const
+{
+    return m_templates.keys();
+}
+
+PromptTemplateManager::~PromptTemplateManager()
+{
+    qDeleteAll(m_templates);
+}
+
+} // namespace QodeAssist
--- a/PromptTemplateManager.hpp
+++ b/PromptTemplateManager.hpp
@ -0,0 +1,59 @@
+/* 
+ * 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 <QMap>
+#include <QString>
+
+#include "templates/PromptTemplate.hpp"
+
+namespace QodeAssist {
+
+class PromptTemplateManager
+{
+public:
+    static PromptTemplateManager &instance();
+
+    template<typename T>
+    void registerTemplate()
+    {
+        static_assert(std::is_base_of<Templates::PromptTemplate, T>::value,
+                      "T must inherit from PromptTemplate");
+        T *template_ptr = new T();
+        QString name = template_ptr->name();
+        m_templates[name] = template_ptr;
+    }
+
+    void setCurrentTemplate(const QString &name);
+    const Templates::PromptTemplate *getCurrentTemplate() const;
+    QStringList getTemplateNames() const;
+
+    ~PromptTemplateManager();
+
+private:
+    PromptTemplateManager() = default;
+    PromptTemplateManager(const PromptTemplateManager &) = delete;
+    PromptTemplateManager &operator=(const PromptTemplateManager &) = delete;
+
+    QMap<QString, Templates::PromptTemplate *> m_templates;
+    QString m_currentTemplateName;
+};
+
+} // namespace QodeAssist
--- a/QodeAssist.json.in
+++ b/QodeAssist.json.in
@ -0,0 +1,16 @@
+{
+    "Name" : "QodeAssist",
+    "Version" : "0.0.1",
+    "CompatVersion" : "${IDE_VERSION_COMPAT}",
+    "Vendor" : "Petr Mironychev",
+    "Copyright" : "(C) ${IDE_COPYRIGHT_YEAR} Petr Mironychev, (C) ${IDE_COPYRIGHT_YEAR} The Qt Company Ltd",
+    "License" : "GNU General Public License Usage
+
+Alternatively, this file may be used under the terms of the GNU General Public License version 3 as published by the Free Software Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT included in the packaging of this file. Please review the following information to ensure the GNU General Public License requirements will be met: https://www.gnu.org/licenses/gpl-3.0.html.",
+    "Description" : ["QodeAssist is an AI-powered coding assistant for Qt Creator. It provides intelligent code completion and suggestions for your code",
+    "Prerequisites:",
+        "- One of the supported LLM providers installed (e.g., Ollama or LM Studio)",
+        "- A compatible large language model downloaded for your chosen provider (e.g., CodeLlama, StarCoder2)"],
+    "Url" : "https://github.com/Palm1r",
+    ${IDE_PLUGIN_DEPENDENCIES}
+}
--- a/QodeAssist.qrc
+++ b/QodeAssist.qrc
@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/">
+        <file>resources/images/qoderassist-icon@2x.png</file>
+        <file>resources/images/qoderassist-icon.png</file>
+    </qresource>
+</RCC>
--- a/QodeAssistClient.cpp
+++ b/QodeAssistClient.cpp
@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of Qode Assist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "QodeAssistClient.hpp"
+
+#include <QTimer>
+
+#include <languageclient/languageclientsettings.h>
+#include <projectexplorer/projectmanager.h>
+
+#include "LLMClientInterface.hpp"
+#include "LLMSuggestion.hpp"
+#include "QodeAssistSettings.hpp"
+
+using namespace LanguageServerProtocol;
+using namespace TextEditor;
+using namespace Utils;
+using namespace ProjectExplorer;
+using namespace Core;
+
+namespace QodeAssist {
+
+QodeAssistClient::QodeAssistClient()
+    : LanguageClient::Client(new LLMClientInterface())
+{
+    setName("Qode Assist");
+    LanguageClient::LanguageFilter filter;
+    filter.mimeTypes = QStringList() << "*";
+    setSupportedLanguage(filter);
+
+    start();
+    setupConnections();
+}
+
+QodeAssistClient::~QodeAssistClient()
+{
+    cleanupConnections();
+}
+
+void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
+{
+    auto project = ProjectManager::projectForFile(document->filePath());
+    if (!isEnabled(project))
+        return;
+
+    Client::openDocument(document);
+    connect(document,
+            &TextDocument::contentsChangedWithPosition,
+            this,
+            [this, document](int position, int charsRemoved, int charsAdded) {
+                Q_UNUSED(charsRemoved)
+                if (!settings().enableAutoComplete())
+                    return;
+
+                auto project = ProjectManager::projectForFile(document->filePath());
+                if (!isEnabled(project))
+                    return;
+
+                auto textEditor = BaseTextEditor::currentTextEditor();
+                if (!textEditor || textEditor->document() != document)
+                    return;
+                TextEditorWidget *widget = textEditor->editorWidget();
+                if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
+                    return;
+                const int cursorPosition = widget->textCursor().position();
+                if (cursorPosition < position || cursorPosition > position + charsAdded)
+                    return;
+                scheduleRequest(widget);
+            });
+}
+
+bool QodeAssistClient::canOpenProject(ProjectExplorer::Project *project)
+{
+    return isEnabled(project);
+}
+
+void QodeAssistClient::requestCompletions(TextEditor::TextEditorWidget *editor)
+{
+    auto project = ProjectManager::projectForFile(editor->textDocument()->filePath());
+
+    if (!isEnabled(project))
+        return;
+
+    MultiTextCursor cursor = editor->multiTextCursor();
+    if (cursor.hasMultipleCursors() || cursor.hasSelection() || editor->suggestionVisible())
+        return;
+
+    const FilePath filePath = editor->textDocument()->filePath();
+    GetCompletionRequest request{{TextDocumentIdentifier(hostPathToServerUri(filePath)),
+                                  documentVersion(filePath),
+                                  Position(cursor.mainCursor())}};
+    request.setResponseCallback([this, editor = QPointer<TextEditorWidget>(editor)](
+                                    const GetCompletionRequest::Response &response) {
+        QTC_ASSERT(editor, return);
+        handleCompletions(response, editor);
+    });
+    m_runningRequests[editor] = request;
+    sendMessage(request);
+}
+
+void QodeAssistClient::scheduleRequest(TextEditor::TextEditorWidget *editor)
+{
+    cancelRunningRequest(editor);
+
+    auto it = m_scheduledRequests.find(editor);
+    if (it == m_scheduledRequests.end()) {
+        auto timer = new QTimer(this);
+        timer->setSingleShot(true);
+        connect(timer, &QTimer::timeout, this, [this, editor]() {
+            if (editor
+                && editor->textCursor().position()
+                       == m_scheduledRequests[editor]->property("cursorPosition").toInt())
+                requestCompletions(editor);
+        });
+        connect(editor, &TextEditorWidget::destroyed, this, [this, editor]() {
+            delete m_scheduledRequests.take(editor);
+            cancelRunningRequest(editor);
+        });
+        connect(editor, &TextEditorWidget::cursorPositionChanged, this, [this, editor] {
+            cancelRunningRequest(editor);
+        });
+        it = m_scheduledRequests.insert(editor, timer);
+    }
+
+    it.value()->setProperty("cursorPosition", editor->textCursor().position());
+    it.value()->start(settings().startSuggestionTimer());
+}
+
+void QodeAssistClient::handleCompletions(const GetCompletionRequest::Response &response,
+                                         TextEditor::TextEditorWidget *editor)
+{
+    if (response.error())
+        log(*response.error());
+
+    int requestPosition = -1;
+    if (const auto requestParams = m_runningRequests.take(editor).params())
+        requestPosition = requestParams->position().toPositionInDocument(editor->document());
+
+    const MultiTextCursor cursors = editor->multiTextCursor();
+    if (cursors.hasMultipleCursors())
+        return;
+
+    if (cursors.hasSelection() || cursors.mainCursor().position() != requestPosition)
+        return;
+
+    if (const std::optional<GetCompletionResponse> result = response.result()) {
+        auto isValidCompletion = [](const Completion &completion) {
+            return completion.isValid() && !completion.text().trimmed().isEmpty();
+        };
+        QList<Completion> completions = Utils::filtered(result->completions().toListOrEmpty(),
+                                                        isValidCompletion);
+
+        // remove trailing whitespaces from the end of the completions
+        for (Completion &completion : completions) {
+            const LanguageServerProtocol::Range range = completion.range();
+            if (range.start().line() != range.end().line())
+                continue; // do not remove trailing whitespaces for multi-line replacements
+
+            const QString completionText = completion.text();
+            const int end = int(completionText.size()) - 1; // empty strings have been removed above
+            int delta = 0;
+            while (delta <= end && completionText[end - delta].isSpace())
+                ++delta;
+
+            if (delta > 0)
+                completion.setText(completionText.chopped(delta));
+        }
+        if (completions.isEmpty())
+            return;
+        editor->insertSuggestion(
+            std::make_unique<LLMSuggestion>(completions.first(), editor->document()));
+        editor->addHoverHandler(&m_hoverHandler);
+    }
+}
+
+void QodeAssistClient::cancelRunningRequest(TextEditor::TextEditorWidget *editor)
+{
+    const auto it = m_runningRequests.constFind(editor);
+    if (it == m_runningRequests.constEnd())
+        return;
+    cancelRequest(it->id());
+    m_runningRequests.erase(it);
+}
+
+bool QodeAssistClient::isEnabled(ProjectExplorer::Project *project) const
+{
+    return settings().enableQodeAssist();
+}
+
+void QodeAssistClient::setupConnections()
+{
+    auto openDoc = [this](IDocument *document) {
+        if (auto *textDocument = qobject_cast<TextDocument *>(document))
+            openDocument(textDocument);
+    };
+
+    m_documentOpenedConnection = connect(EditorManager::instance(),
+                                         &EditorManager::documentOpened,
+                                         this,
+                                         openDoc);
+    m_documentClosedConnection = connect(EditorManager::instance(),
+                                         &EditorManager::documentClosed,
+                                         this,
+                                         [this](IDocument *document) {
+                                             if (auto textDocument = qobject_cast<TextDocument *>(
+                                                     document))
+                                                 closeDocument(textDocument);
+                                         });
+
+    for (IDocument *doc : DocumentModel::openedDocuments())
+        openDoc(doc);
+}
+
+void QodeAssistClient::cleanupConnections()
+{
+    disconnect(m_documentOpenedConnection);
+    disconnect(m_documentClosedConnection);
+
+    for (IEditor *editor : DocumentModel::editorsForOpenedDocuments()) {
+        if (auto textEditor = qobject_cast<BaseTextEditor *>(editor))
+            textEditor->editorWidget()->removeHoverHandler(&m_hoverHandler);
+    }
+
+    qDeleteAll(m_scheduledRequests);
+    m_scheduledRequests.clear();
+}
+
+} // namespace QodeAssist
--- a/QodeAssistClient.hpp
+++ b/QodeAssistClient.hpp
@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of Qode Assist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <languageclient/client.h>
+
+#include "LSPCompletion.hpp"
+#include "QodeAssistHoverHandler.hpp"
+
+namespace QodeAssist {
+
+class QodeAssistClient : public LanguageClient::Client
+{
+public:
+    explicit QodeAssistClient();
+    ~QodeAssistClient() override;
+
+    void openDocument(TextEditor::TextDocument *document) override;
+    bool canOpenProject(ProjectExplorer::Project *project) override;
+
+    void requestCompletions(TextEditor::TextEditorWidget *editor);
+
+private:
+    void scheduleRequest(TextEditor::TextEditorWidget *editor);
+    void handleCompletions(const GetCompletionRequest::Response &response,
+                           TextEditor::TextEditorWidget *editor);
+    void cancelRunningRequest(TextEditor::TextEditorWidget *editor);
+    bool isEnabled(ProjectExplorer::Project *project) const;
+
+    void setupConnections();
+    void cleanupConnections();
+
+    QHash<TextEditor::TextEditorWidget *, GetCompletionRequest> m_runningRequests;
+    QHash<TextEditor::TextEditorWidget *, QTimer *> m_scheduledRequests;
+    QodeAssistHoverHandler m_hoverHandler;
+    QMetaObject::Connection m_documentOpenedConnection;
+    QMetaObject::Connection m_documentClosedConnection;
+};
+
+} // namespace QodeAssist
--- a/QodeAssistConstants.hpp
+++ b/QodeAssistConstants.hpp
@ -0,0 +1,62 @@
+/* 
+ * 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
+
+namespace QodeAssist::Constants {
+
+const char ACTION_ID[] = "QodeAssist.Action";
+const char MENU_ID[] = "QodeAssist.Menu";
+
+// settings
+const char ENABLE_QODE_ASSIST[] = "QodeAssist.enableQodeAssist";
+const char ENABLE_AUTO_COMPLETE[] = "QodeAssist.enableAutoComplete";
+const char ENABLE_LOGGING[] = "QodeAssist.enableLogging";
+const char LLM_PROVIDERS[] = "QodeAssist.llmProviders";
+const char URL[] = "QodeAssist.url";
+const char PORT[] = "QodeAssist.port";
+const char END_POINT[] = "QodeAssist.endPoint";
+const char MODEL_NAME[] = "QodeAssist.modelName";
+const char SELECT_MODELS[] = "QodeAssist.selectModels";
+const char FIM_PROMPTS[] = "QodeAssist.fimPrompts";
+const char TEMPERATURE[] = "QodeAssist.temperature";
+const char MAX_TOKENS[] = "QodeAssist.maxTokens";
+const char READ_FULL_FILE[] = "QodeAssist.readFullFile";
+const char READ_STRINGS_BEFORE_CURSOR[] = "QodeAssist.readStringsBeforeCursor";
+const char READ_STRINGS_AFTER_CURSOR[] = "QodeAssist.readStringsAfterCursor";
+const char USE_TOP_P[] = "QodeAssist.useTopP";
+const char TOP_P[] = "QodeAssist.topP";
+const char USE_TOP_K[] = "QodeAssist.useTopK";
+const char TOP_K[] = "QodeAssist.topK";
+const char USE_PRESENCE_PENALTY[] = "QodeAssist.usePresencePenalty";
+const char PRESENCE_PENALTY[] = "QodeAssist.presencePenalty";
+const char USE_FREQUENCY_PENALTY[] = "QodeAssist.useFrequencyPenalty";
+const char FREQUENCY_PENALTY[] = "QodeAssist.frequencyPenalty";
+const char PROVIDER_PATHS[] = "QodeAssist.providerPaths";
+const char START_SUGGESTION_TIMER[] = "QodeAssist.startSuggestionTimer";
+const char MAX_FILE_THRESHOLD[] = "QodeAssist.maxFileThreshold";
+const char OLLAMA_LIVETIME[] = "QodeAssist.ollamaLivetime";
+
+const char QODE_ASSIST_GENERAL_OPTIONS_ID[] = "QodeAssist.GeneralOptions";
+const char QODE_ASSIST_GENERAL_OPTIONS_CATEGORY[] = "QodeAssist.Category";
+const char QODE_ASSIST_GENERAL_OPTIONS_DISPLAY_CATEGORY[] = "Qode Assist";
+
+const char QODE_ASSIST_REQUEST_SUGGESTION[] = "QodeAssist.RequestSuggestion";
+
+} // namespace QodeAssist::Constants
--- a/QodeAssistHoverHandler.cpp
+++ b/QodeAssistHoverHandler.cpp
@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of Qode Assist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "QodeAssistHoverHandler.hpp"
+
+#include <QPushButton>
+#include <QScopeGuard>
+#include <QToolBar>
+#include <QToolButton>
+
+#include <texteditor/textdocument.h>
+#include <texteditor/textdocumentlayout.h>
+#include <texteditor/texteditor.h>
+
+#include <utils/tooltip/tooltip.h>
+#include <utils/utilsicons.h>
+
+#include "LLMSuggestion.hpp"
+#include "LSPCompletion.hpp"
+#include "QodeAssisttr.h"
+
+using namespace TextEditor;
+using namespace LanguageServerProtocol;
+using namespace Utils;
+
+namespace QodeAssist {
+
+class QodeAssistCompletionToolTip : public QToolBar
+{
+public:
+    QodeAssistCompletionToolTip(TextEditorWidget *editor)
+        : m_editor(editor)
+    {
+        auto apply = addAction(Tr::tr("Apply (%1)").arg(QKeySequence(Qt::Key_Tab).toString()));
+        connect(apply, &QAction::triggered, this, &QodeAssistCompletionToolTip::apply);
+    }
+
+private:
+    void apply()
+    {
+        if (TextSuggestion *suggestion = m_editor->currentSuggestion()) {
+            if (!suggestion->apply())
+                return;
+        }
+        ToolTip::hide();
+    }
+
+    TextEditorWidget *m_editor;
+};
+
+void QodeAssistHoverHandler::identifyMatch(TextEditor::TextEditorWidget *editorWidget,
+                                           int pos,
+                                           ReportPriority report)
+{
+    QScopeGuard cleanup([&] { report(Priority_None); });
+    if (!editorWidget->suggestionVisible())
+        return;
+
+    QTextCursor cursor(editorWidget->document());
+    cursor.setPosition(pos);
+    m_block = cursor.block();
+    auto *suggestion = dynamic_cast<LLMSuggestion *>(TextDocumentLayout::suggestion(m_block));
+
+    if (!suggestion)
+        return;
+
+    const Completion completion = suggestion->completion();
+    if (completion.text().isEmpty())
+        return;
+
+    cleanup.dismiss();
+    report(Priority_Suggestion);
+}
+
+void QodeAssistHoverHandler::operateTooltip(TextEditor::TextEditorWidget *editorWidget,
+                                            const QPoint &point)
+{
+    Q_UNUSED(point)
+    auto *suggestion = dynamic_cast<LLMSuggestion *>(TextDocumentLayout::suggestion(m_block));
+
+    if (!suggestion)
+        return;
+
+    auto tooltipWidget = new QodeAssistCompletionToolTip(editorWidget);
+
+    const QRect cursorRect = editorWidget->cursorRect(editorWidget->textCursor());
+    QPoint pos = editorWidget->viewport()->mapToGlobal(cursorRect.topLeft())
+                 - Utils::ToolTip::offsetFromPosition();
+    pos.ry() -= tooltipWidget->sizeHint().height();
+    ToolTip::show(pos, tooltipWidget, editorWidget);
+}
+
+} // namespace QodeAssist
--- a/QodeAssistHoverHandler.hpp
+++ b/QodeAssistHoverHandler.hpp
@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of Qode Assist.
+ *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QTextBlock>
+#include <texteditor/basehoverhandler.h>
+
+namespace QodeAssist {
+
+class QodeAssistHoverHandler : public TextEditor::BaseHoverHandler
+{
+public:
+    QodeAssistHoverHandler() = default;
+
+protected:
+    void identifyMatch(TextEditor::TextEditorWidget *editorWidget,
+                       int pos,
+                       ReportPriority report) final;
+    void operateTooltip(TextEditor::TextEditorWidget *editorWidget, const QPoint &point) final;
+
+private:
+    QTextBlock m_block;
+};
+
+} // namespace QodeAssist
--- a/QodeAssistSettings.cpp
+++ b/QodeAssistSettings.cpp
@ -0,0 +1,378 @@
+/* 
+ * 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 "QodeAssistSettings.hpp"
+
+#include <QInputDialog>
+#include <QtWidgets/qmessagebox.h>
+#include <coreplugin/dialogs/ioptionspage.h>
+#include <coreplugin/icore.h>
+
+#include "QodeAssistConstants.hpp"
+#include "QodeAssisttr.h"
+
+#include "LLMProvidersManager.hpp"
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistUtils.hpp"
+
+namespace QodeAssist {
+
+QodeAssistSettings &settings()
+{
+    static QodeAssistSettings settings;
+    return settings;
+}
+
+QodeAssistSettings::QodeAssistSettings()
+{
+    setAutoApply(false);
+
+    enableQodeAssist.setSettingsKey(Constants::ENABLE_QODE_ASSIST);
+    enableQodeAssist.setLabelText(Tr::tr("Enable Qode Assist"));
+    enableQodeAssist.setDefaultValue(true);
+
+    enableAutoComplete.setSettingsKey(Constants::ENABLE_AUTO_COMPLETE);
+    enableAutoComplete.setLabelText(Tr::tr("Enable Auto Complete"));
+    enableAutoComplete.setDefaultValue(true);
+
+    enableLogging.setSettingsKey(Constants::ENABLE_LOGGING);
+    enableLogging.setLabelText(Tr::tr("Enable Logging"));
+    enableLogging.setDefaultValue(false);
+
+    llmProviders.setSettingsKey(Constants::LLM_PROVIDERS);
+    llmProviders.setDisplayName(Tr::tr("LLM Providers:"));
+    llmProviders.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
+    llmProviders.setDefaultValue(1);
+
+    url.setSettingsKey(Constants::URL);
+    url.setLabelText(Tr::tr("URL:"));
+    url.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    endPoint.setSettingsKey(Constants::END_POINT);
+    endPoint.setLabelText(Tr::tr("Endpoint:"));
+    endPoint.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    port.setSettingsKey(Constants::PORT);
+    port.setLabelText(Tr::tr("Port:"));
+    port.setRange(1, 65535);
+
+    modelName.setSettingsKey(Constants::MODEL_NAME);
+    modelName.setLabelText(Tr::tr("LLM Name:"));
+    modelName.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    temperature.setSettingsKey(Constants::TEMPERATURE);
+    temperature.setLabelText(Tr::tr("Temperature:"));
+    temperature.setDefaultValue(0.2);
+    temperature.setRange(0.0, 10.0);
+
+    selectModels.m_buttonText = Tr::tr("Select Models");
+
+    ollamaLivetime.setSettingsKey(Constants::OLLAMA_LIVETIME);
+    ollamaLivetime.setLabelText(
+        Tr::tr("Time to suspend Ollama after completion request (in minutes), "
+               "Only Ollama,  -1 to disable"));
+    ollamaLivetime.setDefaultValue("5m");
+    ollamaLivetime.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    fimPrompts.setDisplayName(Tr::tr("Fill-In-Middle Prompt"));
+    fimPrompts.setSettingsKey(Constants::FIM_PROMPTS);
+    fimPrompts.setDefaultValue(1);
+    fimPrompts.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
+
+    readFullFile.setSettingsKey(Constants::READ_FULL_FILE);
+    readFullFile.setLabelText(Tr::tr("Read Full File"));
+    readFullFile.setDefaultValue(true);
+
+    maxFileThreshold.setSettingsKey(Constants::MAX_FILE_THRESHOLD);
+    maxFileThreshold.setLabelText(Tr::tr("Max File Threshold:"));
+    maxFileThreshold.setRange(10, 100000);
+    maxFileThreshold.setDefaultValue(600);
+
+    readStringsBeforeCursor.setSettingsKey(Constants::READ_STRINGS_BEFORE_CURSOR);
+    readStringsBeforeCursor.setLabelText(Tr::tr("Read Strings Before Cursor"));
+    readStringsBeforeCursor.setDefaultValue(60);
+
+    readStringsAfterCursor.setSettingsKey(Constants::READ_STRINGS_AFTER_CURSOR);
+    readStringsAfterCursor.setLabelText(Tr::tr("Read Strings After Cursor"));
+    readStringsAfterCursor.setDefaultValue(40);
+
+    maxTokens.setSettingsKey(Constants::MAX_TOKENS);
+    maxTokens.setLabelText(Tr::tr("Max Tokens"));
+    maxTokens.setRange(-1, 10000);
+    maxTokens.setDefaultValue(250);
+
+    useTopP.setSettingsKey(Constants::USE_TOP_P);
+    useTopP.setDefaultValue(false);
+
+    topP.setSettingsKey(Constants::TOP_P);
+    topP.setLabelText(Tr::tr("top_p"));
+    topP.setDefaultValue(0.9);
+    topP.setRange(0.0, 10.0);
+
+    useTopK.setSettingsKey(Constants::USE_TOP_K);
+    useTopK.setDefaultValue(false);
+
+    topK.setSettingsKey(Constants::TOP_K);
+    topK.setLabelText(Tr::tr("top_k"));
+    topK.setDefaultValue(0.1);
+    topK.setRange(0, 10.0);
+
+    usePresencePenalty.setSettingsKey(Constants::USE_PRESENCE_PENALTY);
+    usePresencePenalty.setDefaultValue(false);
+
+    presencePenalty.setSettingsKey(Constants::PRESENCE_PENALTY);
+    presencePenalty.setLabelText(Tr::tr("presence_penalty"));
+    presencePenalty.setDefaultValue(0.0);
+    presencePenalty.setRange(-2.0, 2.0);
+
+    useFrequencyPenalty.setSettingsKey(Constants::USE_FREQUENCY_PENALTY);
+    useFrequencyPenalty.setDefaultValue(false);
+
+    frequencyPenalty.setSettingsKey(Constants::FREQUENCY_PENALTY);
+    frequencyPenalty.setLabelText(Tr::tr("frequency_penalty"));
+    frequencyPenalty.setDefaultValue(0.0);
+    frequencyPenalty.setRange(-2.0, 2.0);
+
+    providerPaths.setSettingsKey(Constants::PROVIDER_PATHS);
+    providerPaths.setLabelText(Tr::tr("Provider Paths:"));
+
+    startSuggestionTimer.setSettingsKey(Constants::START_SUGGESTION_TIMER);
+    startSuggestionTimer.setLabelText(Tr::tr("Start Suggestion Timer:"));
+    startSuggestionTimer.setRange(10, 10000);
+    startSuggestionTimer.setDefaultValue(500);
+
+    resetToDefaults.m_buttonText = Tr::tr("Reset to Defaults");
+
+    const auto &manager = LLMProvidersManager::instance();
+    if (!manager.getProviderNames().isEmpty()) {
+        const auto providerNames = manager.getProviderNames();
+        for (const QString &name : providerNames) {
+            llmProviders.addOption(name);
+        }
+    }
+
+    const auto &promptManager = PromptTemplateManager::instance();
+    if (!promptManager.getTemplateNames().isEmpty()) {
+        const auto promptNames = promptManager.getTemplateNames();
+        for (const QString &name : promptNames) {
+            fimPrompts.addOption(name);
+        }
+    }
+
+    readSettings();
+
+    topK.setEnabled(useTopK());
+    topP.setEnabled(useTopP());
+    presencePenalty.setEnabled(usePresencePenalty());
+    frequencyPenalty.setEnabled(useFrequencyPenalty());
+    readStringsAfterCursor.setEnabled(!readFullFile());
+    readStringsBeforeCursor.setEnabled(!readFullFile());
+    PromptTemplateManager::instance().setCurrentTemplate(fimPrompts.stringValue());
+    LLMProvidersManager::instance().setCurrentProvider(llmProviders.stringValue());
+    updateProviderSettings();
+
+    setLoggingEnabled(enableLogging());
+
+    setLayouter([this]() {
+        using namespace Layouting;
+
+        return Column{Group{title(Tr::tr("General Settings")),
+                            Form{Column{enableQodeAssist,
+                                        enableAutoComplete,
+                                        enableLogging,
+                                        Row{Stretch{1}, resetToDefaults}}}},
+                      Group{title(Tr::tr("LLM Providers")),
+                            Form{Column{llmProviders, Row{url, port, endPoint}, providerPaths}}},
+                      Group{title(Tr::tr("LLM Model Settings")),
+                            Form{Column{Row{selectModels, modelName}}}},
+                      Group{title(Tr::tr("FIM Prompt Settings")),
+                            Form{Column{fimPrompts,
+                                        readFullFile,
+                                        maxFileThreshold,
+                                        ollamaLivetime,
+                                        temperature,
+                                        maxTokens,
+                                        readStringsBeforeCursor,
+                                        readStringsAfterCursor,
+                                        startSuggestionTimer,
+                                        Row{useTopP, topP, Stretch{1}},
+                                        Row{useTopK, topK, Stretch{1}},
+                                        Row{usePresencePenalty, presencePenalty, Stretch{1}},
+                                        Row{useFrequencyPenalty, frequencyPenalty, Stretch{1}}}}},
+                      st};
+    });
+
+    setupConnections();
+}
+
+void QodeAssistSettings::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();
+    });
+
+    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));
+    });
+
+    connect(&selectModels, &ButtonAspect::clicked, this, [this]() { showModelSelectionDialog(); });
+    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(&readFullFile, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
+        readStringsAfterCursor.setEnabled(!readFullFile.volatileValue());
+        readStringsBeforeCursor.setEnabled(!readFullFile.volatileValue());
+    });
+    connect(&resetToDefaults,
+            &ButtonAspect::clicked,
+            this,
+            &QodeAssistSettings::resetSettingsToDefaults);
+    connect(&enableLogging, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
+        setLoggingEnabled(enableLogging.volatileValue());
+    });
+}
+
+void QodeAssistSettings::updateProviderSettings()
+{
+    auto *provider = LLMProvidersManager::instance().getCurrentProvider();
+
+    if (provider) {
+        logMessage(QString("currentProvider %1").arg(provider->name()));
+        url.setValue(provider->url());
+        port.setValue(provider->defaultPort());
+        endPoint.setValue(provider->completionEndpoint());
+        ollamaLivetime.setEnabled(provider->name() == "Ollama");
+    }
+}
+
+QStringList QodeAssistSettings::getInstalledModels()
+{
+    auto *provider = LLMProvidersManager::instance().getCurrentProvider();
+    if (provider) {
+        auto env = getEnvironmentWithProviderPaths();
+        return provider->getInstalledModels(env);
+    }
+    return {};
+}
+
+void QodeAssistSettings::showModelSelectionDialog()
+{
+    QStringList models = getInstalledModels();
+
+    bool ok;
+    QString selectedModel = QInputDialog::getItem(Core::ICore::dialogParent(),
+                                                  Tr::tr("Select LLM Model"),
+                                                  Tr::tr("Choose a model:"),
+                                                  models,
+                                                  0,
+                                                  false,
+                                                  &ok);
+
+    if (ok && !selectedModel.isEmpty()) {
+        modelName.setValue(selectedModel);
+        writeSettings();
+    }
+}
+
+Utils::Environment QodeAssistSettings::getEnvironmentWithProviderPaths() const
+{
+    Utils::Environment env = Utils::Environment::systemEnvironment();
+    const QStringList additionalPaths = providerPaths.volatileValue();
+    for (const QString &path : additionalPaths) {
+        env.prependOrSetPath(path);
+    }
+    return env;
+}
+
+void QodeAssistSettings::resetSettingsToDefaults()
+{
+    QMessageBox::StandardButton reply;
+    reply = QMessageBox::question(
+        Core::ICore::dialogParent(),
+        Tr::tr("Reset Settings"),
+        Tr::tr("Are you sure you want to reset all settings to default values?"),
+        QMessageBox::Yes | QMessageBox::No);
+
+    if (reply == QMessageBox::Yes) {
+        resetAspect(enableQodeAssist);
+        resetAspect(enableAutoComplete);
+        resetAspect(llmProviders);
+        resetAspect(url);
+        resetAspect(port);
+        resetAspect(endPoint);
+        resetAspect(modelName);
+        resetAspect(fimPrompts);
+        resetAspect(temperature);
+        resetAspect(maxTokens);
+        resetAspect(readFullFile);
+        resetAspect(maxFileThreshold);
+        resetAspect(readStringsBeforeCursor);
+        resetAspect(readStringsAfterCursor);
+        resetAspect(useTopP);
+        resetAspect(topP);
+        resetAspect(useTopK);
+        resetAspect(topK);
+        resetAspect(usePresencePenalty);
+        resetAspect(presencePenalty);
+        resetAspect(useFrequencyPenalty);
+        resetAspect(frequencyPenalty);
+        resetAspect(startSuggestionTimer);
+        resetAspect(enableLogging);
+        resetAspect(ollamaLivetime);
+
+        updateProviderSettings();
+        apply();
+
+        QMessageBox::information(Core::ICore::dialogParent(),
+                                 Tr::tr("Settings Reset"),
+                                 Tr::tr("All settings have been reset to their default values."));
+    }
+}
+
+class QodeAssistSettingsPage : public Core::IOptionsPage
+{
+public:
+    QodeAssistSettingsPage()
+    {
+        setId(Constants::QODE_ASSIST_GENERAL_OPTIONS_ID);
+        setDisplayName("Qode Assist");
+        setCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_CATEGORY);
+        setDisplayCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_DISPLAY_CATEGORY);
+        setCategoryIconPath(":/resources/images/qoderassist-icon.png");
+        setSettingsProvider([] { return &settings(); });
+    }
+};
+
+const QodeAssistSettingsPage settingsPage;
+
+} // namespace QodeAssist
--- a/QodeAssistSettings.hpp
+++ b/QodeAssistSettings.hpp
@ -0,0 +1,112 @@
+/* 
+ * 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 <QPushButton>
+#include <utils/aspects.h>
+#include <utils/layoutbuilder.h>
+
+namespace QodeAssist {
+
+template<typename AspectType>
+void resetAspect(AspectType &aspect)
+{
+    aspect.setValue(aspect.defaultValue());
+}
+
+class ButtonAspect : public Utils::BaseAspect
+{
+    Q_OBJECT
+
+public:
+    ButtonAspect(Utils::AspectContainer *container = nullptr)
+        : Utils::BaseAspect(container)
+    {}
+
+    void addToLayout(Layouting::Layout &parent) override
+    {
+        auto button = new QPushButton(m_buttonText);
+        connect(button, &QPushButton::clicked, this, &ButtonAspect::clicked);
+        parent.addItem(button);
+    }
+
+    QString m_buttonText;
+signals:
+    void clicked();
+};
+
+class QodeAssistSettings : public Utils::AspectContainer
+{
+public:
+    QodeAssistSettings();
+
+    Utils::BoolAspect enableQodeAssist{this};
+    Utils::BoolAspect enableAutoComplete{this};
+    Utils::BoolAspect enableLogging{this};
+
+    Utils::SelectionAspect llmProviders{this};
+    Utils::StringAspect url{this};
+    Utils::IntegerAspect port{this};
+    Utils::StringAspect endPoint{this};
+
+    Utils::StringAspect modelName{this};
+    ButtonAspect selectModels{this};
+
+    Utils::SelectionAspect fimPrompts{this};
+    Utils::DoubleAspect temperature{this};
+    Utils::IntegerAspect maxTokens{this};
+
+    Utils::BoolAspect readFullFile{this};
+    Utils::IntegerAspect readStringsBeforeCursor{this};
+    Utils::IntegerAspect readStringsAfterCursor{this};
+
+    Utils::BoolAspect useTopP{this};
+    Utils::DoubleAspect topP{this};
+
+    Utils::BoolAspect useTopK{this};
+    Utils::DoubleAspect topK{this};
+
+    Utils::BoolAspect usePresencePenalty{this};
+    Utils::DoubleAspect presencePenalty{this};
+
+    Utils::BoolAspect useFrequencyPenalty{this};
+    Utils::DoubleAspect frequencyPenalty{this};
+
+    Utils::StringListAspect providerPaths{this};
+
+    Utils::IntegerAspect startSuggestionTimer{this};
+    Utils::IntegerAspect maxFileThreshold{this};
+
+    Utils::StringAspect ollamaLivetime{this};
+
+    ButtonAspect resetToDefaults{this};
+
+private:
+    void setupConnections();
+    void updateProviderSettings();
+    QStringList getInstalledModels();
+    void showModelSelectionDialog();
+    Utils::Environment getEnvironmentWithProviderPaths() const;
+    void resetSettingsToDefaults();
+};
+
+QodeAssistSettings &settings();
+
+} // namespace QodeAssist
--- a/QodeAssistUtils.hpp
+++ b/QodeAssistUtils.hpp
@ -0,0 +1,68 @@
+/* 
+ * 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 <QString>
+#include <coreplugin/messagemanager.h>
+#include <utils/qtcassert.h>
+
+namespace QodeAssist {
+
+inline bool &loggingEnabled()
+{
+    static bool enabled = false;
+    return enabled;
+}
+
+inline void setLoggingEnabled(bool enable)
+{
+    loggingEnabled() = enable;
+}
+
+inline void logMessage(const QString &message, bool silent = true)
+{
+    if (!loggingEnabled())
+        return;
+
+    const QString prefixedMessage = QLatin1String("[QLLamaAssist] ") + message;
+    if (silent) {
+        Core::MessageManager::writeSilently(prefixedMessage);
+    } else {
+        Core::MessageManager::writeFlashing(prefixedMessage);
+    }
+}
+
+inline void logMessages(const QStringList &messages, bool silent = true)
+{
+    if (!loggingEnabled())
+        return;
+
+    QStringList prefixedMessages;
+    for (const QString &message : messages) {
+        prefixedMessages << (QLatin1String("[Qode Assist] ") + message);
+    }
+    if (silent) {
+        Core::MessageManager::writeSilently(prefixedMessages);
+    } else {
+        Core::MessageManager::writeFlashing(prefixedMessages);
+    }
+}
+
+} // namespace QodeAssist
--- a/QodeAssist_en_001.ts
+++ b/QodeAssist_en_001.ts
@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.1" language="en_001"></TS>
--- a/QodeAssisttr.h
+++ b/QodeAssisttr.h
@ -0,0 +1,31 @@
+/* 
+ * 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 <QCoreApplication>
+
+namespace QodeAssist {
+
+struct Tr
+{
+    Q_DECLARE_TR_FUNCTIONS(QtC::QodeAssist)
+};
+
+} // namespace QodeAssist
--- a/README.md
+++ b/README.md
@ -0,0 +1,85 @@
+# QodeAssist
+
+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.
+
+## Supported LLM Providers
+QodeAssist currently supports the following LLM (Large Language Model) providers:
+- [Ollama](https://ollama.com)
+- [LM Studio](https://lmstudio.ai)
+
+## Supported Models
+QodeAssist has been tested with the following language 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
+- [ ] Add chat functionality
+- [ ] Support for more providers and models
+
+## Installation Plugin
+
+1. Install [Ollama](https://ollama.com). Make sure to review the system requirements before installation.
+2. Install a language model in Ollama. For example, you can run:
+```
+ollama run starcoder2:7b
+```
+3. Download the QodeAssist plugin.
+4. Launch Qt Creator and install the plugin:
+   - Go to About -> About Plugins
+   - Click on "Install Plugin..."
+   - Select the downloaded QodeAssist plugin archive file
+
+## Configure Plugin
+
+1. Open Qt Creator settings
+2. Navigate to the "Qode Assist" tab
+3. Choose your LLM provider (e.g., Ollama)
+   - If you haven't added the provider to your system PATH, specify the path to the provider executable in the "Provider Paths" field
+4. Select the installed model
+   - If you need to enter the model name manually, it indicates that the plugin cannot locate the provider's executable file. However, this doesn't affect the plugin's functionality – it will still work correctly. This autoselector input option is provided for your convenience, allowing you to easily select and use different models
+5. Choose the prompt template that corresponds to your model
+6. Apply the settings
+
+You're all set! QodeAssist is now ready to use in Qt Creator.
+
+## Support the development of QodeAssist
+If you find QodeAssist helpful, there are several ways you can support the project:
+
+1. **Report Issues**: If you encounter any bugs or have suggestions for improvements, please [open an issue](https://github.com/Palm1r/qodeassist/issues) on our GitHub repository.
+
+2. **Contribute**: Feel free to submit pull requests with bug fixes or new features.
+
+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 cryptocurrency addresses:
+
+   - Bitcoin (BTC): `bc1qndq7f0mpnlya48vk7kugvyqj5w89xrg4wzg68t`
+   - Ethereum (ETH): `0xA5e8c37c94b24e25F9f1f292a01AF55F03099D8D`
+   - Litecoin (LTC): `ltc1qlrxnk30s2pcjchzx4qrxvdjt5gzuervy5mv0vy`
+   - USDT (TRC20): `THdZrE7d6epW6ry98GA3MLXRjha1DjKtUx`
+
+Every contribution, no matter how small, is greatly appreciated and helps keep the project alive!
+
+## How to Build
+
+Create a build directory and run
+
+    cmake -DCMAKE_PREFIX_PATH=<path_to_qtcreator> -DCMAKE_BUILD_TYPE=RelWithDebInfo <path_to_plugin_source>
+    cmake --build .
+
+where `<path_to_qtcreator>` is the relative or absolute path to a Qt Creator build directory, or to a
+combined binary and development package (Windows / Linux), or to the `Qt Creator.app/Contents/Resources/`
+directory of a combined binary and development package (macOS), and `<path_to_plugin_source>` is the
+relative or absolute path to this plugin directory.
--- a/providers/LLMProvider.hpp
+++ b/providers/LLMProvider.hpp
@ -0,0 +1,45 @@
+/* 
+ * 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 <QString>
+#include <utils/environment.h>
+
+class QNetworkReply;
+class QJsonObject;
+
+namespace QodeAssist::Providers {
+
+class LLMProvider
+{
+public:
+    virtual ~LLMProvider() = default;
+
+    virtual QString name() const = 0;
+    virtual QString url() const = 0;
+    virtual int defaultPort() const = 0;
+    virtual QString completionEndpoint() 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;
+};
+
+} // namespace QodeAssist::Providers
--- a/providers/LMStudioProvider.cpp
+++ b/providers/LMStudioProvider.cpp
@ -0,0 +1,171 @@
+/* 
+ * 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 "LMStudioProvider.hpp"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QNetworkReply>
+#include <QProcess>
+
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistSettings.hpp"
+
+namespace QodeAssist::Providers {
+
+LMStudioProvider::LMStudioProvider() {}
+
+QString LMStudioProvider::name() const
+{
+    return "LM Studio";
+}
+
+QString LMStudioProvider::url() const
+{
+    return "http://localhost";
+}
+
+int LMStudioProvider::defaultPort() const
+{
+    return 1234;
+}
+
+QString LMStudioProvider::completionEndpoint() const
+{
+    return "/v1/chat/completions";
+}
+
+void LMStudioProvider::prepareRequest(QJsonObject &request)
+{
+    const auto &currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+
+    if (request.contains("prompt")) {
+        QJsonArray messages{
+            {QJsonObject{{"role", "user"}, {"content", request.take("prompt").toString()}}}};
+        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())
+        request["top_k"] = settings().topK();
+    if (settings().useFrequencyPenalty())
+        request["frequency_penalty"] = settings().frequencyPenalty();
+    if (settings().usePresencePenalty())
+        request["presence_penalty"] = settings().presencePenalty();
+}
+
+bool LMStudioProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
+{
+    bool isComplete = false;
+    while (reply->canReadLine()) {
+        QByteArray line = reply->readLine().trimmed();
+        if (line.isEmpty()) {
+            continue;
+        }
+        if (line == "data: [DONE]") {
+            isComplete = true;
+            break;
+        }
+        if (line.startsWith("data: ")) {
+            line = line.mid(6); // Remove "data: " prefix
+        }
+        QJsonDocument jsonResponse = QJsonDocument::fromJson(line);
+        if (jsonResponse.isNull()) {
+            qWarning() << "Invalid JSON response from LM Studio:" << line;
+            continue;
+        }
+        QJsonObject responseObj = jsonResponse.object();
+        if (responseObj.contains("choices")) {
+            QJsonArray choices = responseObj["choices"].toArray();
+            if (!choices.isEmpty()) {
+                QJsonObject choice = choices.first().toObject();
+                QJsonObject delta = choice["delta"].toObject();
+                if (delta.contains("content")) {
+                    QString completion = delta["content"].toString();
+
+                    accumulatedResponse += completion;
+                }
+                if (choice["finish_reason"].toString() == "stop") {
+                    isComplete = true;
+                    break;
+                }
+            }
+        }
+    }
+    return isComplete;
+}
+
+QList<QString> LMStudioProvider::getInstalledModels(const Utils::Environment &env)
+{
+    QProcess process;
+    process.setEnvironment(env.toStringList());
+    QString lmsConsoleName;
+#ifdef Q_OS_WIN
+    lmsConsoleName = "lms.exe";
+#else
+    lmsConsoleName = "lms";
+#endif
+    auto lmsPath = env.searchInPath(lmsConsoleName).toString();
+
+    if (!QFileInfo::exists(lmsPath)) {
+        qWarning() << "LMS executable not found at" << lmsPath;
+        return {};
+    }
+
+    process.start(lmsPath, QStringList() << "ls");
+    if (!process.waitForStarted()) {
+        qWarning() << "Failed to start LMS process:" << process.errorString();
+        return {};
+    }
+
+    if (!process.waitForFinished()) {
+        qWarning() << "LMS process did not finish:" << process.errorString();
+        return {};
+    }
+
+    QStringList models;
+    if (process.exitCode() == 0) {
+        QString output = QString::fromUtf8(process.readAllStandardOutput());
+        QStringList lines = output.split('\n', Qt::SkipEmptyParts);
+
+        // Skip the header lines
+        for (int i = 2; i < lines.size(); ++i) {
+            QString line = lines[i].trimmed();
+            if (!line.isEmpty()) {
+                // The model name is the first column
+                QString modelName = line.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts)
+                                        .first();
+                models.append(modelName);
+            }
+        }
+        qDebug() << "Models:" << models;
+    } else {
+        // Handle error
+        qWarning() << "Error running 'lms list':" << process.errorString();
+    }
+
+    return models;
+}
+
+} // namespace QodeAssist::Providers
--- a/providers/LMStudioProvider.hpp
+++ b/providers/LMStudioProvider.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 "LLMProvider.hpp"
+
+namespace QodeAssist::Providers {
+
+class LMStudioProvider : public LLMProvider
+{
+public:
+    LMStudioProvider();
+
+    QString name() const override;
+    QString url() const override;
+    int defaultPort() const override;
+    QString completionEndpoint() const override;
+    void prepareRequest(QJsonObject &request) override;
+    bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
+    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+};
+
+} // namespace QodeAssist::Providers
--- a/providers/OllamaProvider.cpp
+++ b/providers/OllamaProvider.cpp
@ -0,0 +1,151 @@
+/* 
+ * 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 "OllamaProvider.hpp"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QNetworkReply>
+#include <QProcess>
+
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistSettings.hpp"
+
+namespace QodeAssist::Providers {
+
+OllamaProvider::OllamaProvider() {}
+
+QString OllamaProvider::name() const
+{
+    return "Ollama";
+}
+
+QString OllamaProvider::url() const
+{
+    return "http://localhost";
+}
+
+int OllamaProvider::defaultPort() const
+{
+    return 11434;
+}
+
+QString OllamaProvider::completionEndpoint() const
+{
+    return "/api/generate";
+}
+
+void OllamaProvider::prepareRequest(QJsonObject &request)
+{
+    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+
+    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())
+        options["top_k"] = settings().topK();
+    if (settings().useFrequencyPenalty())
+        options["frequency_penalty"] = settings().frequencyPenalty();
+    if (settings().usePresencePenalty())
+        options["presence_penalty"] = settings().presencePenalty();
+    request["options"] = options;
+}
+
+bool OllamaProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
+{
+    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;
+            continue;
+        }
+        QJsonObject responseObj = jsonResponse.object();
+        if (responseObj.contains("response")) {
+            QString completion = responseObj["response"].toString();
+
+            accumulatedResponse += completion;
+        }
+        if (responseObj["done"].toBool()) {
+            isComplete = true;
+            break;
+        }
+    }
+    return isComplete;
+}
+
+QList<QString> OllamaProvider::getInstalledModels(const Utils::Environment &env)
+{
+    QProcess process;
+    process.setEnvironment(env.toStringList());
+    QString ollamaConsoleName;
+#ifdef Q_OS_WIN
+    ollamaConsoleName = "ollama.exe";
+#else
+    ollamaConsoleName = "ollama";
+#endif
+
+    auto ollamaPath = env.searchInPath(ollamaConsoleName).toString();
+
+    if (!QFileInfo::exists(ollamaPath)) {
+        qWarning() << "Ollama executable not found at" << ollamaPath;
+        return {};
+    }
+
+    process.start(ollamaPath, QStringList() << "list");
+    if (!process.waitForStarted()) {
+        qWarning() << "Failed to start Ollama process:" << process.errorString();
+        return {};
+    }
+
+    if (!process.waitForFinished()) {
+        qWarning() << "Ollama process did not finish:" << process.errorString();
+        return {};
+    }
+
+    QStringList models;
+    if (process.exitCode() == 0) {
+        QString output = QString::fromUtf8(process.readAllStandardOutput());
+        QStringList lines = output.split('\n', Qt::SkipEmptyParts);
+
+        for (int i = 1; i < lines.size(); ++i) {
+            QString line = lines[i].trimmed();
+            if (!line.isEmpty()) {
+                QString modelName = line.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts)
+                                        .first();
+                models.append(modelName);
+            }
+        }
+    } else {
+        qWarning() << "Error running 'ollama list':" << process.errorString();
+    }
+
+    return models;
+}
+
+} // namespace QodeAssist::Providers
--- a/providers/OllamaProvider.hpp
+++ b/providers/OllamaProvider.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 "LLMProvider.hpp"
+
+namespace QodeAssist::Providers {
+
+class OllamaProvider : public LLMProvider
+{
+public:
+    OllamaProvider();
+
+    QString name() const override;
+    QString url() const override;
+    int defaultPort() const override;
+    QString completionEndpoint() const override;
+    void prepareRequest(QJsonObject &request) override;
+    bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
+    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+};
+
+} // namespace QodeAssist::Providers
--- a/qodeassist.cpp
+++ b/qodeassist.cpp
@ -0,0 +1,138 @@
+/* 
+ * 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 "QodeAssistConstants.hpp"
+#include "QodeAssisttr.h"
+
+#include <coreplugin/actionmanager/actioncontainer.h>
+#include <coreplugin/actionmanager/actionmanager.h>
+#include <coreplugin/actionmanager/command.h>
+#include <coreplugin/coreconstants.h>
+#include <coreplugin/icontext.h>
+#include <coreplugin/icore.h>
+#include <coreplugin/statusbarmanager.h>
+
+#include <extensionsystem/iplugin.h>
+#include <languageclient/languageclientmanager.h>
+
+#include <QAction>
+#include <QMainWindow>
+#include <QMenu>
+#include <QMessageBox>
+#include <texteditor/texteditor.h>
+#include <utils/icon.h>
+
+#include "LLMProvidersManager.hpp"
+#include "PromptTemplateManager.hpp"
+#include "QodeAssistClient.hpp"
+#include "providers/LMStudioProvider.hpp"
+#include "providers/OllamaProvider.hpp"
+#include "templates/CodeLLamaTemplate.hpp"
+#include "templates/StarCoder2Template.hpp"
+
+using namespace Utils;
+using namespace Core;
+using namespace ProjectExplorer;
+
+namespace QodeAssist::Internal {
+
+class QodeAssistPlugin final : public ExtensionSystem::IPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QtCreatorPlugin" FILE "QodeAssist.json")
+
+public:
+    QodeAssistPlugin()
+    {
+    }
+
+    ~QodeAssistPlugin() final
+    {
+
+    }
+
+    void initialize() final
+    {
+        auto &providerManager = LLMProvidersManager::instance();
+        providerManager.registerProvider<Providers::OllamaProvider>();
+        providerManager.registerProvider<Providers::LMStudioProvider>();
+
+        auto &templateManager = PromptTemplateManager::instance();
+        templateManager.registerTemplate<Templates::CodeLLamaTemplate>();
+        templateManager.registerTemplate<Templates::StarCoder2Template>();
+
+        Utils::Icon QCODEASSIST_ICON(
+            {{":/resources/images/qoderassist-icon.png", Utils::Theme::IconsBaseColor}});
+
+        ActionBuilder requestAction(this, Constants::QODE_ASSIST_REQUEST_SUGGESTION);
+        requestAction.setToolTip(
+            Tr::tr("Request Ollama suggestion at the current editor's cursor position."));
+        requestAction.setText(Tr::tr("Request Ollama Suggestion"));
+        requestAction.setIcon(QCODEASSIST_ICON.icon());
+        requestAction.addOnTriggered(this, [this] {
+            if (auto editor = TextEditor::TextEditorWidget::currentTextEditorWidget()) {
+                if (m_qodeAssistClient && m_qodeAssistClient->reachable()) {
+                    m_qodeAssistClient->requestCompletions(editor);
+                } else
+                    qWarning() << "The Qode Assist is not ready. Please check your connection and "
+                                  "settings.";
+            }
+        });
+
+        auto toggleButton = new QToolButton;
+        toggleButton->setDefaultAction(requestAction.contextAction());
+        StatusBarManager::addStatusBarWidget(toggleButton, StatusBarManager::RightCorner);
+    }
+
+    void extensionsInitialized() final
+    {
+    }
+
+    void restartClient()
+    {
+        LanguageClient::LanguageClientManager::shutdownClient(m_qodeAssistClient);
+
+        m_qodeAssistClient = new QodeAssistClient();
+    }
+
+    bool delayedInitialize() final
+    {
+        restartClient();
+
+        return true;
+    }
+
+    ShutdownFlag aboutToShutdown() final
+    {
+        if (!m_qodeAssistClient)
+            return SynchronousShutdown;
+        connect(m_qodeAssistClient,
+                &QObject::destroyed,
+                this,
+                &IPlugin::asynchronousShutdownFinished);
+        return AsynchronousShutdown;
+    }
+
+private:
+    QPointer<QodeAssistClient> m_qodeAssistClient;
+};
+
+} // namespace QodeAssist::Internal
+
+#include <qodeassist.moc>
--- a/resources/images/qoderassist-icon.png
+++ b/resources/images/qoderassist-icon.png
--- a/resources/images/qoderassist-icon@2x.png
+++ b/resources/images/qoderassist-icon@2x.png
--- a/templates/CodeLLamaTemplate.hpp
+++ b/templates/CodeLLamaTemplate.hpp
@ -0,0 +1,45 @@
+/* 
+ * 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 "PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class CodeLLamaTemplate : public PromptTemplate
+{
+public:
+    QString name() const override { return "CodeLlama"; }
+    QString promptTemplate() const override { return "<PRE> %1 <SUF>%2 <MID>"; }
+    QStringList stopWords() const override
+    {
+        return QStringList() << "<EOT>" << "<PRE>" << "<SUF" << "<MID>";
+    }
+
+    void prepareRequest(QJsonObject &request,
+                        const QString &prefix,
+                        const QString &suffix) const override
+    {
+        QString formattedPrompt = promptTemplate().arg(prefix, suffix);
+        request["prompt"] = formattedPrompt;
+    }
+};
+
+} // namespace QodeAssist::Templates
--- a/templates/PromptTemplate.hpp
+++ b/templates/PromptTemplate.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 <QList>
+#include <QString>
+
+namespace QodeAssist::Templates {
+
+class PromptTemplate
+{
+public:
+    virtual ~PromptTemplate() = default;
+    virtual QString name() const = 0;
+    virtual QString promptTemplate() const = 0;
+    virtual QStringList stopWords() const = 0;
+    virtual void prepareRequest(QJsonObject &request,
+                                const QString &prefix,
+                                const QString &suffix) const
+        = 0;
+};
+} // namespace QodeAssist::Templates
--- a/templates/StarCoder2Template.hpp
+++ b/templates/StarCoder2Template.hpp
@ -0,0 +1,45 @@
+/* 
+ * 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 "PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class StarCoder2Template : public PromptTemplate
+{
+public:
+    QString name() const override { return "StarCoder2"; }
+    QString promptTemplate() const override { return "<fim_prefix>%1<fim_suffix>%2<fim_middle>"; }
+    QStringList stopWords() const override
+    {
+        return QStringList() << "<|endoftext|>" << "<file_sep>" << "<fim_prefix>" << "<fim_suffix>"
+                             << "<fim_middle>";
+    }
+    void prepareRequest(QJsonObject &request,
+                        const QString &prefix,
+                        const QString &suffix) const override
+    {
+        QString formattedPrompt = promptTemplate().arg(prefix, suffix);
+        request["prompt"] = formattedPrompt;
+    }
+};
+
+} // namespace QodeAssist::Templates