🐛 fix: Fix tags

* 🐛 fix: Change plugin configs
* 🐛 fix: Update Button aspect api
* 🐛 fix: Temproary fix for LLMSuggestions
* 🐛 fix: Update github actions
* 🔖 chore: Upgrade version in README

.clang-format

@@ -0,0 +1,108 @@
+# .clang-format from Qt Creator
+# https://github.com/qt-creator/qt-creator/blob/master/.clang-format
+#
+# yaml-language-server: $schema=https://json.schemastore.org/clang-format.json
+#
+---
+Language:        Cpp
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: DontAlign
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     true
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:    100
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - forever # avoids { wrapped to next line
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories:
+  - Regex:           '^<Q.*'
+    Priority:        200
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+InsertBraces: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+# Do not add QT_BEGIN_NAMESPACE/QT_END_NAMESPACE as this will indent lines in between.
+MacroBlockBegin: ""
+MacroBlockEnd:   ""
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 4
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 88
+PenaltyBreakBeforeFirstCallParameter: 300
+PenaltyBreakComment: 500
+PenaltyBreakFirstLessLess: 400
+PenaltyBreakString: 600
+PenaltyExcessCharacter: 50
+PenaltyReturnTypeOnItsOwnLine: 300
+PointerAlignment: Right
+ReflowComments:  false
+SortIncludes: CaseSensitive
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: c++17
+TabWidth:        4
+UseTab:          Never

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: qodeassist
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/scripts/plugin.json

@@ -0,0 +1,54 @@
+{
+    "name": "QodeAssist",
+    "vendor": "Petr Mironychev",
+    "tags": [
+        "code assistant",
+        "llm",
+        "ai"
+    ],
+    "compatibility": "Qt 6.8.1",
+    "platforms": [
+        "Windows",
+        "macOS",
+        "Linux"
+    ],
+    "license": "GPLv3",
+    "version": "0.4.0",
+    "status": "draft",
+    "is_pack": false,
+    "released_at": null,
+    "version_history": [
+        {
+            "version": "0.4.0",
+            "is_latest": true,
+            "released_at": "2024-01-24T15:00:00Z"
+        }
+    ],
+    "icon": "https://github.com/user-attachments/assets/dc336712-83cb-440d-8761-8d0a31de898d",
+    "small_icon": "https://github.com/user-attachments/assets/8ec241bf-3186-452e-b8db-8d70543c2f41",
+    "description_paragraphs": [
+        {
+            "header": "Description",
+            "text": [
+                "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."
+            ]
+        }
+    ],
+    "description_links": [
+        {
+            "url": "https://github.com/Palm1r/QodeAssist",
+            "link_text": "Site"
+        }
+    ],
+    "description_images": [
+        {
+            "url": "https://github.com/user-attachments/assets/255a52f1-5cc0-4ca3-b05c-c4cf9cdbe25a",
+            "image_label": "Code Completion"
+        }
+    ],
+    "copyright": "(C) Petr Mironychev",
+    "download_history": {
+        "download_count": 0
+    },
+    "plugin_sets": []
+}

.github/scripts/registerPlugin.js

@@ -0,0 +1,147 @@
+const fs = require('fs');
+const path = require('path');
+
+const updatePluginData = (plugin, env, pluginQtcData) => {
+  const dictionary_platform = {
+    'Windows': `${env.PLUGIN_DOWNLOAD_URL}/${env.PLUGIN_NAME}-${env.QT_CREATOR_VERSION}-Windows-x64.7z`,
+    'Linux': `${env.PLUGIN_DOWNLOAD_URL}/${env.PLUGIN_NAME}-${env.QT_CREATOR_VERSION}-Linux-x64.7z`,
+    'macOS': `${env.PLUGIN_DOWNLOAD_URL}/${env.PLUGIN_NAME}-${env.QT_CREATOR_VERSION}-macOS-universal.7z`
+  };
+
+  plugin.core_compat_version = env.QT_CREATOR_VERSION_INTERNAL;
+  plugin.core_version = env.QT_CREATOR_VERSION_INTERNAL;
+  plugin.status = "draft";
+
+  plugin.plugins.forEach(pluginsEntry => {
+    pluginsEntry.url = dictionary_platform[plugin.host_os];
+    pluginsEntry.meta_data = pluginQtcData;
+  });
+  return plugin;
+};
+
+const createNewPluginData = (env, platform, pluginQtcData) => {
+  const pluginJson = {
+    "status": "draft",
+    "core_compat_version": "<placeholder>",
+    "core_version": "<placeholder>",
+    "host_os": platform,
+    "host_os_version": "0", // TODO: pass the real data
+    "host_os_architecture": "x86_64", // TODO: pass the real data
+    "plugins": [
+      {
+        "url": "",
+        "size": 5000, // TODO: check if it is needed, pass the real data
+        "meta_data": {},
+        "dependencies": []
+      }
+    ]
+  };
+
+  updatePluginData(pluginJson, env, pluginQtcData);
+  return pluginJson;
+}
+
+const updateServerPluginJson = (endJsonData, pluginQtcData, env) => {
+  // Update the global data in mainData
+  endJsonData.name = pluginQtcData.Name;
+  endJsonData.vendor = pluginQtcData.Vendor;
+  endJsonData.version = pluginQtcData.Version;
+  endJsonData.copyright = pluginQtcData.Copyright;
+  endJsonData.status = "draft";
+
+  endJsonData.version_history[0].version = pluginQtcData.Version;
+
+  endJsonData.description_paragraphs = [
+    {
+      header: "Description",
+      text: [
+        pluginQtcData.Description
+      ]
+    }
+  ];
+
+  let found = false;
+  // Update or Add the plugin data for the current Qt Creator version
+  for (const plugin of endJsonData.plugin_sets) {
+    if (plugin.core_compat_version === env.QT_CREATOR_VERSION_INTERNAL) {
+      updatePluginData(plugin, env, pluginQtcData);
+      found = true;
+    }
+  }
+
+  if (!found)  {
+    for (const platform of ['Windows', 'Linux', 'macOS']) {
+      endJsonData.plugin_sets.push(createNewPluginData(env, platform, pluginQtcData));
+    }
+  }
+
+  // Save the updated JSON file
+  const serverPluginJsonPath = path.join(__dirname, `${env.PLUGIN_NAME}.json`);
+  fs.writeFileSync(serverPluginJsonPath, JSON.stringify(endJsonData, null, 2), 'utf8');
+};
+
+const request = async (type, url, token, data) => {
+  const response = await fetch(url, {
+    method: type,
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'accept': 'application/json',
+      'Content-Type': 'application/json'
+    },
+    body: data ? JSON.stringify(data) : undefined
+  });
+  if (!response.ok) {
+    const errorResponse = await response.json();
+    console.error(`${type} Request Error Response:`, errorResponse); // Log the error response
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  return await response.json();
+}
+
+const put = (url, token, data) => request('PUT', url, token, data)
+const post = (url, token, data) => request('POST', url, token, data)
+const get = (url, token) => request('GET', url, token)
+
+const purgeCache = async (env) => {
+  try {
+    await post(`${env.API_URL}api/v1/cache/purgeall`, env.TOKEN, {});
+    console.log('Cache purged successfully');
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};
+
+async function main() {
+  const env = {
+    PLUGIN_DOWNLOAD_URL: process.env.PLUGIN_DOWNLOAD_URL || process.argv[2],
+    PLUGIN_NAME: process.env.PLUGIN_NAME || process.argv[3],
+    QT_CREATOR_VERSION: process.env.QT_CREATOR_VERSION || process.argv[4],
+    QT_CREATOR_VERSION_INTERNAL: process.env.QT_CREATOR_VERSION_INTERNAL || process.argv[5],
+    TOKEN: process.env.TOKEN || process.argv[6],
+    API_URL: process.env.API_URL || process.argv[7] || ''
+  };
+
+  const pluginQtcData = require(`../../${env.PLUGIN_NAME}-origin/${env.PLUGIN_NAME}.json`);
+  const templateFileData = require('./plugin.json');
+
+  if (env.API_URL === '') {
+    updateServerPluginJson(templateFileData, pluginQtcData, env);
+    process.exit(0);
+  }
+
+  const response = await get(`${env.API_URL}api/v1/admin/extensions?search=${env.PLUGIN_NAME}`, env.TOKEN);
+  if (response.items.length > 0 && response.items[0].extension_id !== '') {
+    const pluginId = response.items[0].extension_id;
+    console.log('Plugin found. Updating the plugin');
+    updateServerPluginJson(response.items[0], pluginQtcData, env);
+
+    await put(`${env.API_URL}api/v1/admin/extensions/${pluginId}`, env.TOKEN, response.items[0]);
+  } else {
+    console.log('No plugin found. Creating a new plugin');
+    updateServerPluginJson(templateFileData, pluginQtcData, env);
+    await post(`${env.API_URL}api/v1/admin/extensions`, env.TOKEN, templateFileData);
+  }
+  // await purgeCache(env);
+}
+
+main().then(() => console.log('JSON file updated successfully'));

.github/workflows/build_cmake.yml

@@ -1,12 +1,20 @@
 name: Build plugin
 
-on: [push]
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - main
 
 env:
   PLUGIN_NAME: QodeAssist
-  QT_VERSION: 6.7.2
-  QT_CREATOR_VERSION: 14.0.0
-  QT_CREATOR_SNAPSHOT: NO
+  QT_VERSION: 6.8.1
+  QT_CREATOR_VERSION: 15.0.0
+  QT_CREATOR_VERSION_INTERNAL: 15.0.0
   MACOS_DEPLOYMENT_TARGET: "11.0"
   CMAKE_VERSION: "3.29.6"
   NINJA_VERSION: "1.12.1"
@@ -23,74 +31,44 @@ jobs:
         - {
             name: "Windows Latest MSVC", artifact: "Windows-x64",
             os: windows-latest,
+            platform: windows_x64,
             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,
+            platform: linux_x64,
             cc: "gcc", cxx: "g++"
           }
         - {
             name: "macOS Latest Clang", artifact: "macOS-universal",
             os: macos-latest,
+            platform: mac_x64,
             cc: "clang", cxx: "clang++"
           }
 
     steps:
     - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+
     - 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")
+            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${CMAKE_MATCH_1}")
         else()
-            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${{github.run_id}}\n")
+            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${{github.run_id}}")
         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()
+      uses: lukka/get-cmake@latest
+      with:
+        cmakeVersion: ${{ env.CMAKE_VERSION }}
+        ninjaVersion: ${{ env.NINJA_VERSION }}
 
     - name: Install system libs
       shell: cmake -P {0}
@@ -117,9 +95,9 @@ jobs:
         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")
+          set(qt_package_arch_suffix "win64_msvc2022_64")
+          set(qt_dir_prefix "${qt_version}/msvc2022_64")
+          set(qt_package_suffix "-Windows-Windows_11_23H2-MSVC2022-Windows-Windows_11_23H2-X86_64")
         elseif ("${{ runner.os }}" STREQUAL "Linux")
           set(url_os "linux_x64")
           if (qt_version VERSION_LESS "6.7.0")
@@ -128,15 +106,15 @@ jobs:
             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")
+          set(qt_package_suffix "-Linux-RHEL_8_10-GCC-Linux-RHEL_8_10-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")
+          set(qt_package_suffix "-MacOS-MacOS_14-Clang-MacOS-MacOS_14-X86_64-ARM64")
         endif()
 
-        set(qt_base_url "https://download.qt.io/online/qtsdkrepository/${url_os}/desktop/qt6_${qt_version_dotless}")
+        set(qt_base_url "https://download.qt.io/online/qtsdkrepository/${url_os}/desktop/qt6_${qt_version_dotless}/qt6_${qt_version_dotless}")
         file(DOWNLOAD "${qt_base_url}/Updates.xml" ./Updates.xml SHOW_PROGRESS)
 
         file(READ ./Updates.xml updates_xml)
@@ -146,7 +124,7 @@ jobs:
         file(MAKE_DIRECTORY qt6)
 
         # Save the path for other steps
-        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/qt6/${qt_dir_prefix}" qt_dir)
+        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/qt6" qt_dir)
         file(APPEND "$ENV{GITHUB_OUTPUT}" "qt_dir=${qt_dir}")
 
         message("Downloading Qt to ${qt_dir}")
@@ -165,11 +143,17 @@ jobs:
 
         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"
+            "${qt_base_url}/qt.qt6.${qt_version_dotless}.addons.${package}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
             ${package}.7z
           )
         endforeach()
 
+        function(downloadAndExtractLibicu url archive)
+          message("Downloading ${url}")
+          file(DOWNLOAD "${url}" ./${archive} SHOW_PROGRESS)
+          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../../${archive} WORKING_DIRECTORY qt6/lib)
+        endfunction()
+
         # uic depends on libicu*.so
         if ("${{ runner.os }}" STREQUAL "Linux")
           if (qt_version VERSION_LESS "6.7.0")
@@ -177,47 +161,25 @@ jobs:
           else()
             set(uic_suffix "Rhel8.6-x86_64")
           endif()
-          downloadAndExtract(
+          downloadAndExtractLibicu(
             "${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
+      uses: qt-creator/install-dev-package@v1.2
+      with:
+        version: ${{ env.QT_CREATOR_VERSION }}
+        unzip-to: 'qtcreator'
+
+    - name: Extract 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: |
@@ -276,11 +238,59 @@ jobs:
         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:
+    # The json is the same for all platforms, but we need to save one
+    - name: Upload plugin json
+      if: matrix.config.os == 'ubuntu-latest'
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ env.PLUGIN_NAME }}-origin-json
+        path: ./build/build/${{ env.PLUGIN_NAME }}.json
+
+  update_json:
     if: contains(github.ref, 'tags/v')
     runs-on: ubuntu-latest
     needs: build
 
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+
+    - name: Download the JSON file
+      uses: actions/download-artifact@v4
+      with:
+        name: ${{ env.PLUGIN_NAME }}-origin-json
+        path: ./${{ env.PLUGIN_NAME }}-origin
+
+    - name: Store Release upload_url
+      run: |
+        RELEASE_HTML_URL=$(echo "${{github.event.repository.html_url}}/releases/download/v${{ needs.build.outputs.tag }}")
+        echo "RELEASE_HTML_URL=${RELEASE_HTML_URL}" >> $GITHUB_ENV
+
+    - name: Run the Node.js script to update JSON
+      env:
+        QT_TOKEN: ${{ secrets.TOKEN }}
+        API_URL: ${{ secrets.API_URL }}
+      run: |
+        node .github/scripts/registerPlugin.js         ${{ env.RELEASE_HTML_URL }} ${{ env.PLUGIN_NAME }}         ${{ env.QT_CREATOR_VERSION }} ${{ env.QT_CREATOR_VERSION_INTERNAL }}         ${{ env.QT_TOKEN }} ${{ env.API_URL }}
+
+    - name: Delete previous json artifacts
+      uses: geekyeggo/delete-artifact@v5
+      with:
+        name: ${{ env.PLUGIN_NAME }}*-json
+
+    - name: Upload the modified JSON file as an artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: plugin-json
+        path: .github/scripts/${{ env.PLUGIN_NAME }}.json
+
+  release:
+    if: contains(github.ref, 'tags/v')
+    runs-on: ubuntu-latest
+    needs: [build, update_json]
+
     steps:
     - name: Download artifacts
       uses: actions/download-artifact@v4

.gitignore

@@ -34,6 +34,7 @@ Thumbs.db
 *.rc
 /.qmake.cache
 /.qmake.stash
+.qmlls.ini
 
 # qtcreator generated files
 *.pro.user*

.qmlformat.ini

@@ -0,0 +1,3 @@
+[General]
+IndentWidth=4
+NewlineType=native

CMakeLists.txt

@@ -10,18 +10,28 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 find_package(QtCreator REQUIRED COMPONENTS Core)
-find_package(Qt6 COMPONENTS Widgets REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Quick Widgets Network REQUIRED)
+
+add_subdirectory(llmcore)
+add_subdirectory(settings)
+add_subdirectory(logger)
+add_subdirectory(ChatView)
 
 add_qtc_plugin(QodeAssist
   PLUGIN_DEPENDS
     QtCreator::Core
     QtCreator::LanguageClient
     QtCreator::TextEditor
+    QtCreator::ProjectExplorer
   DEPENDS
+    Qt::Core
+    Qt::Gui
+    Qt::Quick
     Qt::Widgets
+    Qt::Network
     QtCreator::ExtensionSystem
     QtCreator::Utils
-    QtCreator::ProjectExplorer
+    QodeAssistChatViewplugin
   SOURCES
     .github/workflows/build_cmake.yml
     .github/workflows/README.md
@@ -30,22 +40,30 @@ add_qtc_plugin(QodeAssist
     QodeAssistConstants.hpp
     QodeAssisttr.h
     LLMClientInterface.hpp LLMClientInterface.cpp
-    PromptTemplateManager.hpp PromptTemplateManager.cpp
-    templates/PromptTemplate.hpp
-    templates/CodeLLamaTemplate.hpp
-    templates/StarCoder2Template.hpp
-    templates/CodeQwenChat.hpp
-    providers/LLMProvider.hpp
+    templates/Templates.hpp
+    templates/CodeLlamaFim.hpp
+    templates/StarCoder2Fim.hpp
+    templates/DeepSeekCoderFim.hpp
+    templates/CustomFimTemplate.hpp
+    templates/Qwen.hpp
+    templates/Ollama.hpp
+    templates/BasicChat.hpp
+    templates/Llama3.hpp
+    templates/ChatML.hpp
+    templates/Alpaca.hpp
+    templates/Llama2.hpp
+    providers/Providers.hpp
     providers/OllamaProvider.hpp providers/OllamaProvider.cpp
     providers/LMStudioProvider.hpp providers/LMStudioProvider.cpp
-    providers/OpenAICompatProvider.h providers/OpenAICompatProvider.cpp
-    LLMProvidersManager.hpp LLMProvidersManager.cpp
-    QodeAssistSettings.hpp QodeAssistSettings.cpp
+    providers/OpenAICompatProvider.hpp providers/OpenAICompatProvider.cpp
     QodeAssist.qrc
     LSPCompletion.hpp
     LLMSuggestion.hpp LLMSuggestion.cpp
-    QodeAssistHoverHandler.hpp QodeAssistHoverHandler.cpp
     QodeAssistClient.hpp QodeAssistClient.cpp
-    QodeAssistUtils.hpp
     DocumentContextReader.hpp DocumentContextReader.cpp
+    utils/CounterTooltip.hpp utils/CounterTooltip.cpp
+    core/ChangesManager.h core/ChangesManager.cpp
+    chat/ChatOutputPane.h chat/ChatOutputPane.cpp
+    chat/NavigationPanel.hpp chat/NavigationPanel.cpp
+    ConfigurationManager.hpp ConfigurationManager.cpp
 )

ChatView/CMakeLists.txt

@@ -0,0 +1,39 @@
+qt_add_library(QodeAssistChatView STATIC)
+
+qt_policy(SET QTP0001 NEW)
+
+# URI name should match the subdirectory name to suppress the warning
+qt_add_qml_module(QodeAssistChatView
+    URI ChatView
+    VERSION 1.0
+    DEPENDENCIES QtQuick
+    QML_FILES
+    qml/RootItem.qml
+    qml/ChatItem.qml
+    qml/Badge.qml
+    qml/dialog/CodeBlock.qml
+    qml/dialog/TextBlock.qml
+    SOURCES
+    ChatWidget.hpp ChatWidget.cpp
+    ChatModel.hpp ChatModel.cpp
+    ChatRootView.hpp ChatRootView.cpp
+    ClientInterface.hpp ClientInterface.cpp
+    MessagePart.hpp
+    ChatUtils.h ChatUtils.cpp
+)
+
+target_link_libraries(QodeAssistChatView
+    PUBLIC
+    Qt::Widgets
+    Qt::Quick
+    Qt::QuickWidgets
+    Qt::Network
+    QtCreator::Core
+    QtCreator::Utils
+    LLMCore
+    QodeAssistSettings
+)
+
+target_include_directories(QodeAssistChatView
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+)

ChatView/ChatModel.cpp

@@ -0,0 +1,195 @@
+/*
+ * 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 "ChatModel.hpp"
+#include <QtCore/qjsonobject.h>
+#include <QtQml>
+#include <utils/aspects.h>
+
+#include "ChatAssistantSettings.hpp"
+
+namespace QodeAssist::Chat {
+
+ChatModel::ChatModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , m_totalTokens(0)
+{
+    auto &settings = Settings::chatAssistantSettings();
+
+    connect(&settings.chatTokensThreshold,
+            &Utils::BaseAspect::changed,
+            this,
+            &ChatModel::tokensThresholdChanged);
+}
+
+int ChatModel::rowCount(const QModelIndex &parent) const
+{
+    return m_messages.size();
+}
+
+QVariant ChatModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_messages.size())
+        return QVariant();
+
+    const Message &message = m_messages[index.row()];
+    switch (static_cast<Roles>(role)) {
+    case Roles::RoleType:
+        return QVariant::fromValue(message.role);
+    case Roles::Content: {
+        return message.content;
+    }
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> ChatModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[Roles::RoleType] = "roleType";
+    roles[Roles::Content] = "content";
+    return roles;
+}
+
+void ChatModel::addMessage(const QString &content, ChatRole role, const QString &id)
+{
+    int tokenCount = estimateTokenCount(content);
+
+    if (!m_messages.isEmpty() && !id.isEmpty() && m_messages.last().id == id) {
+        Message &lastMessage = m_messages.last();
+        int oldTokenCount = lastMessage.tokenCount;
+        lastMessage.content = content;
+        lastMessage.tokenCount = tokenCount;
+        m_totalTokens += (tokenCount - oldTokenCount);
+        emit dataChanged(index(m_messages.size() - 1), index(m_messages.size() - 1));
+    } else {
+        beginInsertRows(QModelIndex(), m_messages.size(), m_messages.size());
+        m_messages.append({role, content, tokenCount, id});
+        m_totalTokens += tokenCount;
+        endInsertRows();
+    }
+
+    trim();
+    emit totalTokensChanged();
+}
+
+QVector<ChatModel::Message> ChatModel::getChatHistory() const
+{
+    return m_messages;
+}
+
+void ChatModel::trim()
+{
+    while (m_totalTokens > tokensThreshold()) {
+        if (!m_messages.isEmpty()) {
+            m_totalTokens -= m_messages.first().tokenCount;
+            beginRemoveRows(QModelIndex(), 0, 0);
+            m_messages.removeFirst();
+            endRemoveRows();
+        } else {
+            break;
+        }
+    }
+}
+
+int ChatModel::estimateTokenCount(const QString &text) const
+{
+    return text.length() / 4;
+}
+
+void ChatModel::clear()
+{
+    beginResetModel();
+    m_messages.clear();
+    m_totalTokens = 0;
+    endResetModel();
+    emit totalTokensChanged();
+}
+
+QList<MessagePart> ChatModel::processMessageContent(const QString &content) const
+{
+    QList<MessagePart> parts;
+    QRegularExpression codeBlockRegex("```(\\w*)\\n?([\\s\\S]*?)```");
+    int lastIndex = 0;
+    auto blockMatches = codeBlockRegex.globalMatch(content);
+
+    while (blockMatches.hasNext()) {
+        auto match = blockMatches.next();
+        if (match.capturedStart() > lastIndex) {
+            QString textBetween = content.mid(lastIndex, match.capturedStart() - lastIndex).trimmed();
+            if (!textBetween.isEmpty()) {
+                parts.append({MessagePart::Text, textBetween, ""});
+            }
+        }
+        parts.append({MessagePart::Code, match.captured(2).trimmed(), match.captured(1)});
+        lastIndex = match.capturedEnd();
+    }
+
+    if (lastIndex < content.length()) {
+        QString remainingText = content.mid(lastIndex).trimmed();
+        if (!remainingText.isEmpty()) {
+            parts.append({MessagePart::Text, remainingText, ""});
+        }
+    }
+
+    return parts;
+}
+
+QJsonArray ChatModel::prepareMessagesForRequest(const QString &systemPrompt) const
+{
+    QJsonArray messages;
+
+    messages.append(QJsonObject{{"role", "system"}, {"content", systemPrompt}});
+
+    for (const auto &message : m_messages) {
+        QString role;
+        switch (message.role) {
+        case ChatRole::User:
+            role = "user";
+            break;
+        case ChatRole::Assistant:
+            role = "assistant";
+            break;
+        default:
+            continue;
+        }
+        messages.append(QJsonObject{{"role", role}, {"content", message.content}});
+    }
+
+    return messages;
+}
+
+int ChatModel::totalTokens() const
+{
+    return m_totalTokens;
+}
+
+int ChatModel::tokensThreshold() const
+{
+    auto &settings = Settings::chatAssistantSettings();
+    return settings.chatTokensThreshold();
+}
+
+QString ChatModel::lastMessageId() const
+{
+    return !m_messages.isEmpty() ? m_messages.last().id : "";
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatModel.hpp

@@ -0,0 +1,85 @@
+/*
+ * 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 "ContextData.hpp"
+#include "MessagePart.hpp"
+
+#include <QAbstractListModel>
+#include <QJsonArray>
+#include <QtQmlIntegration>
+
+namespace QodeAssist::Chat {
+
+class ChatModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int totalTokens READ totalTokens NOTIFY totalTokensChanged FINAL)
+    Q_PROPERTY(int tokensThreshold READ tokensThreshold NOTIFY tokensThresholdChanged FINAL)
+    QML_ELEMENT
+
+public:
+    enum Roles { RoleType = Qt::UserRole, Content };
+
+    enum ChatRole { System, User, Assistant };
+    Q_ENUM(ChatRole)
+
+    struct Message
+    {
+        ChatRole role;
+        QString content;
+        int tokenCount;
+        QString id;
+    };
+
+    explicit ChatModel(QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE void addMessage(const QString &content, ChatRole role, const QString &id);
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE QList<MessagePart> processMessageContent(const QString &content) const;
+
+    QVector<Message> getChatHistory() const;
+    QJsonArray prepareMessagesForRequest(const QString &systemPrompt) const;
+
+    int totalTokens() const;
+    int tokensThreshold() const;
+
+    QString currentModel() const;
+    QString lastMessageId() const;
+
+signals:
+    void totalTokensChanged();
+    void tokensThresholdChanged();
+
+private:
+    void trim();
+    int estimateTokenCount(const QString &text) const;
+
+    QVector<Message> m_messages;
+    int m_totalTokens = 0;
+};
+
+} // namespace QodeAssist::Chat
+Q_DECLARE_METATYPE(QodeAssist::Chat::ChatModel::Message)
+Q_DECLARE_METATYPE(QodeAssist::Chat::MessagePart)

ChatView/ChatRootView.cpp

@@ -0,0 +1,144 @@
+/*
+ * 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 "ChatRootView.hpp"
+#include <QtGui/qclipboard.h>
+#include <utils/theme/theme.h>
+#include <utils/utilsicons.h>
+
+#include "ChatAssistantSettings.hpp"
+#include "GeneralSettings.hpp"
+
+namespace QodeAssist::Chat {
+
+ChatRootView::ChatRootView(QQuickItem *parent)
+    : QQuickItem(parent)
+    , m_chatModel(new ChatModel(this))
+    , m_clientInterface(new ClientInterface(m_chatModel, this))
+{
+    auto &settings = Settings::generalSettings();
+
+    connect(&settings.caModel,
+            &Utils::BaseAspect::changed,
+            this,
+            &ChatRootView::currentTemplateChanged);
+
+    connect(&Settings::chatAssistantSettings().sharingCurrentFile,
+            &Utils::BaseAspect::changed,
+            this,
+            &ChatRootView::isSharingCurrentFileChanged);
+
+    generateColors();
+}
+
+ChatModel *ChatRootView::chatModel() const
+{
+    return m_chatModel;
+}
+
+QColor ChatRootView::backgroundColor() const
+{
+    return Utils::creatorColor(Utils::Theme::BackgroundColorNormal);
+}
+
+void ChatRootView::sendMessage(const QString &message, bool sharingCurrentFile) const
+{
+    m_clientInterface->sendMessage(message, sharingCurrentFile);
+}
+
+void ChatRootView::copyToClipboard(const QString &text)
+{
+    QGuiApplication::clipboard()->setText(text);
+}
+
+void ChatRootView::cancelRequest()
+{
+    m_clientInterface->cancelRequest();
+}
+
+void ChatRootView::generateColors()
+{
+    QColor baseColor = backgroundColor();
+    bool isDarkTheme = baseColor.lightness() < 128;
+
+    if (isDarkTheme) {
+        m_primaryColor = generateColor(baseColor, 0.1, 1.2, 1.4);
+        m_secondaryColor = generateColor(baseColor, -0.1, 1.1, 1.2);
+        m_codeColor = generateColor(baseColor, 0.05, 0.8, 1.1);
+    } else {
+        m_primaryColor = generateColor(baseColor, 0.05, 1.05, 1.1);
+        m_secondaryColor = generateColor(baseColor, -0.05, 1.1, 1.2);
+        m_codeColor = generateColor(baseColor, 0.02, 0.95, 1.05);
+    }
+}
+
+QColor ChatRootView::generateColor(const QColor &baseColor,
+                                   float hueShift,
+                                   float saturationMod,
+                                   float lightnessMod)
+{
+    float h, s, l, a;
+    baseColor.getHslF(&h, &s, &l, &a);
+    bool isDarkTheme = l < 0.5;
+
+    h = fmod(h + hueShift + 1.0, 1.0);
+
+    s = qBound(0.0f, s * saturationMod, 1.0f);
+
+    if (isDarkTheme) {
+        l = qBound(0.0f, l * lightnessMod, 1.0f);
+    } else {
+        l = qBound(0.0f, l / lightnessMod, 1.0f);
+    }
+
+    h = qBound(0.0f, h, 1.0f);
+    s = qBound(0.0f, s, 1.0f);
+    l = qBound(0.0f, l, 1.0f);
+    a = qBound(0.0f, a, 1.0f);
+
+    return QColor::fromHslF(h, s, l, a);
+}
+
+QString ChatRootView::currentTemplate() const
+{
+    auto &settings = Settings::generalSettings();
+    return settings.caModel();
+}
+
+QColor ChatRootView::primaryColor() const
+{
+    return m_primaryColor;
+}
+
+QColor ChatRootView::secondaryColor() const
+{
+    return m_secondaryColor;
+}
+
+QColor ChatRootView::codeColor() const
+{
+    return m_codeColor;
+}
+
+bool ChatRootView::isSharingCurrentFile() const
+{
+    return Settings::chatAssistantSettings().sharingCurrentFile();
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatRootView.hpp

@@ -0,0 +1,86 @@
+/*
+ * 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 <QQuickItem>
+
+#include "ChatModel.hpp"
+#include "ClientInterface.hpp"
+
+namespace QodeAssist::Chat {
+
+class ChatRootView : public QQuickItem
+{
+    Q_OBJECT
+    // Possibly Qt bug: QTBUG-131004
+    // The class type name must be fully qualified
+    // including the namespace.
+    // Otherwise qmlls can't find it.
+    Q_PROPERTY(QodeAssist::Chat::ChatModel *chatModel READ chatModel NOTIFY chatModelChanged FINAL)
+    Q_PROPERTY(QString currentTemplate READ currentTemplate NOTIFY currentTemplateChanged FINAL)
+    Q_PROPERTY(QColor backgroundColor READ backgroundColor CONSTANT FINAL)
+    Q_PROPERTY(QColor primaryColor READ primaryColor CONSTANT FINAL)
+    Q_PROPERTY(QColor secondaryColor READ secondaryColor CONSTANT FINAL)
+    Q_PROPERTY(QColor codeColor READ codeColor CONSTANT FINAL)
+    Q_PROPERTY(bool isSharingCurrentFile READ isSharingCurrentFile NOTIFY
+                   isSharingCurrentFileChanged FINAL)
+    QML_ELEMENT
+
+public:
+    ChatRootView(QQuickItem *parent = nullptr);
+
+    ChatModel *chatModel() const;
+    QString currentTemplate() const;
+
+    QColor backgroundColor() const;
+    QColor primaryColor() const;
+    QColor secondaryColor() const;
+
+    QColor codeColor() const;
+
+    bool isSharingCurrentFile() const;
+
+public slots:
+    void sendMessage(const QString &message, bool sharingCurrentFile = false) const;
+    void copyToClipboard(const QString &text);
+    void cancelRequest();
+
+signals:
+    void chatModelChanged();
+    void currentTemplateChanged();
+
+    void isSharingCurrentFileChanged();
+
+private:
+    void generateColors();
+    QColor generateColor(const QColor &baseColor,
+                         float hueShift,
+                         float saturationMod,
+                         float lightnessMod);
+
+    ChatModel *m_chatModel;
+    ClientInterface *m_clientInterface;
+    QString m_currentTemplate;
+    QColor m_primaryColor;
+    QColor m_secondaryColor;
+    QColor m_codeColor;
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatUtils.cpp

@@ -0,0 +1,32 @@
+/* 
+ * 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 "ChatUtils.h"
+
+#include <QClipboard>
+#include <QGuiApplication>
+
+namespace QodeAssist::Chat {
+
+void ChatUtils::copyToClipboard(const QString &text)
+{
+    QGuiApplication::clipboard()->setText(text);
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatUtils.h

@@ -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 <qobject.h>
+#include <qqmlintegration.h>
+
+namespace QodeAssist::Chat {
+// Q_NAMESPACE
+
+class ChatUtils : public QObject
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(ChatUtils)
+
+public:
+    explicit ChatUtils(QObject *parent = nullptr)
+        : QObject(parent) {};
+
+    Q_INVOKABLE void copyToClipboard(const QString &text);
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatWidget.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ChatWidget.hpp"
+
+#include <QQmlContext>
+#include <QQmlEngine>
+
+namespace QodeAssist::Chat {
+
+ChatWidget::ChatWidget(QWidget *parent)
+    : QQuickWidget(parent)
+{
+    setSource(QUrl("qrc:/qt/qml/ChatView/qml/RootItem.qml"));
+    setResizeMode(QQuickWidget::SizeRootObjectToView);
+}
+
+void ChatWidget::clear()
+{
+    QMetaObject::invokeMethod(rootObject(), "clearChat");
+}
+
+void ChatWidget::scrollToBottom()
+{
+    QMetaObject::invokeMethod(rootObject(), "scrollToBottom");
+}
+}

ChatView/ChatWidget.hpp

@@ -0,0 +1,41 @@
+/*
+ * 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 <QtQuickWidgets/QtQuickWidgets>
+
+namespace QodeAssist::Chat {
+
+class ChatWidget : public QQuickWidget
+{
+    Q_OBJECT
+
+public:
+    explicit ChatWidget(QWidget *parent = nullptr);
+    ~ChatWidget() = default;
+
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE void scrollToBottom();
+
+signals:
+    void clearPressed();
+};
+
+}

ChatView/ClientInterface.cpp

@@ -0,0 +1,190 @@
+/* 
+ * 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 "ClientInterface.hpp"
+
+#include <QFileInfo>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QUuid>
+#include <texteditor/textdocument.h>
+
+#include <coreplugin/editormanager/editormanager.h>
+#include <coreplugin/editormanager/ieditor.h>
+#include <coreplugin/idocument.h>
+
+#include <texteditor/textdocument.h>
+#include <texteditor/texteditor.h>
+
+#include "ChatAssistantSettings.hpp"
+#include "GeneralSettings.hpp"
+#include "Logger.hpp"
+#include "PromptTemplateManager.hpp"
+#include "ProvidersManager.hpp"
+
+namespace QodeAssist::Chat {
+
+ClientInterface::ClientInterface(ChatModel *chatModel, QObject *parent)
+    : QObject(parent)
+    , m_requestHandler(new LLMCore::RequestHandler(this))
+    , m_chatModel(chatModel)
+{
+    connect(m_requestHandler,
+            &LLMCore::RequestHandler::completionReceived,
+            this,
+            [this](const QString &completion, const QJsonObject &request, bool isComplete) {
+                handleLLMResponse(completion, request, isComplete);
+            });
+
+    connect(m_requestHandler,
+            &LLMCore::RequestHandler::requestFinished,
+            this,
+            [this](const QString &, bool success, const QString &errorString) {
+                if (!success) {
+                    emit errorOccurred(errorString);
+                }
+            });
+}
+
+ClientInterface::~ClientInterface() = default;
+
+void ClientInterface::sendMessage(const QString &message, bool includeCurrentFile)
+{
+    cancelRequest();
+
+    m_chatModel->addMessage(message, ChatModel::ChatRole::User, "");
+
+    auto &chatAssistantSettings = Settings::chatAssistantSettings();
+
+    auto providerName = Settings::generalSettings().caProvider();
+    auto provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
+
+    if (!provider) {
+        LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
+        return;
+    }
+
+    auto templateName = Settings::generalSettings().caTemplate();
+    auto promptTemplate = LLMCore::PromptTemplateManager::instance().getChatTemplateByName(
+        templateName);
+
+    if (!promptTemplate) {
+        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+        return;
+    }
+
+    LLMCore::ContextData context;
+    context.prefix = message;
+    context.suffix = "";
+
+    QString systemPrompt;
+    if (chatAssistantSettings.useSystemPrompt())
+        systemPrompt = chatAssistantSettings.systemPrompt();
+
+    if (includeCurrentFile) {
+        QString fileContext = getCurrentFileContext();
+        if (!fileContext.isEmpty()) {
+            systemPrompt = systemPrompt.append(fileContext);
+        }
+    }
+
+    QJsonObject providerRequest;
+    providerRequest["model"] = Settings::generalSettings().caModel();
+    providerRequest["stream"] = true;
+    providerRequest["messages"] = m_chatModel->prepareMessagesForRequest(systemPrompt);
+
+    if (promptTemplate)
+        promptTemplate->prepareRequest(providerRequest, context);
+    else
+        qWarning("No prompt template found");
+
+    if (provider)
+        provider->prepareRequest(providerRequest, LLMCore::RequestType::Chat);
+    else
+        qWarning("No provider found");
+
+    LLMCore::LLMConfig config;
+    config.requestType = LLMCore::RequestType::Chat;
+    config.provider = provider;
+    config.promptTemplate = promptTemplate;
+    config.url = QString("%1%2").arg(Settings::generalSettings().caUrl(), provider->chatEndpoint());
+    config.providerRequest = providerRequest;
+    config.multiLineCompletion = false;
+    config.apiKey = Settings::chatAssistantSettings().apiKey();
+
+    QJsonObject request;
+    request["id"] = QUuid::createUuid().toString();
+
+    m_requestHandler->sendLLMRequest(config, request);
+}
+
+void ClientInterface::clearMessages()
+{
+    m_chatModel->clear();
+    LOG_MESSAGE("Chat history cleared");
+}
+
+void ClientInterface::cancelRequest()
+{
+    auto id = m_chatModel->lastMessageId();
+    m_requestHandler->cancelRequest(id);
+}
+
+void ClientInterface::handleLLMResponse(const QString &response,
+                                        const QJsonObject &request,
+                                        bool isComplete)
+{
+    const auto message = response.trimmed();
+
+    if (!message.isEmpty()) {
+        QString messageId = request["id"].toString();
+        m_chatModel->addMessage(message, ChatModel::ChatRole::Assistant, messageId);
+
+        if (isComplete) {
+            LOG_MESSAGE(
+                "Message completed. Final response for message " + messageId + ": " + response);
+        }
+    }
+}
+
+QString ClientInterface::getCurrentFileContext() const
+{
+    auto currentEditor = Core::EditorManager::currentEditor();
+    if (!currentEditor) {
+        LOG_MESSAGE("No active editor found");
+        return QString();
+    }
+
+    auto textDocument = qobject_cast<TextEditor::TextDocument *>(currentEditor->document());
+    if (!textDocument) {
+        LOG_MESSAGE("Current document is not a text document");
+        return QString();
+    }
+
+    QString fileInfo = QString("Language: %1\nFile: %2\n\n")
+                           .arg(textDocument->mimeType(), textDocument->filePath().toString());
+
+    QString content = textDocument->document()->toPlainText();
+
+    LOG_MESSAGE(QString("Got context from file: %1").arg(textDocument->filePath().toString()));
+
+    return QString("Current file context:\n%1\nFile content:\n%2").arg(fileInfo, content);
+}
+
+} // namespace QodeAssist::Chat

ChatView/ClientInterface.hpp

@@ -0,0 +1,54 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QVector>
+
+#include "ChatModel.hpp"
+#include "RequestHandler.hpp"
+
+namespace QodeAssist::Chat {
+
+class ClientInterface : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ClientInterface(ChatModel *chatModel, QObject *parent = nullptr);
+    ~ClientInterface();
+
+    void sendMessage(const QString &message, bool includeCurrentFile = false);
+    void clearMessages();
+    void cancelRequest();
+
+signals:
+    void errorOccurred(const QString &error);
+
+private:
+    void handleLLMResponse(const QString &response, const QJsonObject &request, bool isComplete);
+    QString getCurrentFileContext() const;
+
+    LLMCore::RequestHandler *m_requestHandler;
+    ChatModel *m_chatModel;
+};
+
+} // namespace QodeAssist::Chat

ChatView/MessagePart.hpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+
+namespace QodeAssist::Chat {
+Q_NAMESPACE
+
+class MessagePart
+{
+    Q_GADGET
+    Q_PROPERTY(PartType type MEMBER type CONSTANT FINAL)
+    Q_PROPERTY(QString text MEMBER text CONSTANT FINAL)
+    Q_PROPERTY(QString language MEMBER language CONSTANT FINAL)
+    QML_VALUE_TYPE(messagePart)
+public:
+    enum PartType { Code, Text };
+    Q_ENUM(PartType)
+
+    PartType type;
+    QString text;
+    QString language;
+};
+
+class MessagePartType : public MessagePart
+{
+    Q_GADGET
+};
+
+QML_NAMED_ELEMENT(MessagePart)
+QML_FOREIGN_NAMESPACE(QodeAssist::Chat::MessagePartType)
+} // namespace QodeAssist::Chat

ChatView/qml/Badge.qml

@@ -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/>.
+ */
+
+import QtQuick
+
+Rectangle {
+    id: root
+
+    property alias text: badgeText.text
+    property alias fontColor: badgeText.color
+
+    width: badgeText.implicitWidth + radius
+    height: badgeText.implicitHeight + 6
+    color: "lightgreen"
+    radius: height / 2
+    border.width: 1
+    border.color: "gray"
+
+    Text {
+        id: badgeText
+
+        anchors.centerIn: parent
+    }
+}

ChatView/qml/ChatItem.qml

@@ -0,0 +1,111 @@
+/*
+ * 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 ComponentBehavior: Bound
+
+import QtQuick
+import ChatView
+import "./dialog"
+
+Rectangle {
+    id: root
+
+    property alias msgModel: msgCreator.model
+    property color fontColor
+    property color codeBgColor
+    property color selectionColor
+
+    height: msgColumn.height
+    radius: 8
+
+    Column {
+        id: msgColumn
+
+        anchors.verticalCenter: parent.verticalCenter
+        width: parent.width
+        spacing: 5
+
+        Repeater {
+            id: msgCreator
+            delegate: Loader {
+                id: msgCreatorDelegate
+                // Fix me:
+                // why does `required property MessagePart modelData` not work?
+                required property var modelData
+
+                width: parent.width
+                sourceComponent: {
+                    // If `required property MessagePart modelData` is used
+                    // and conversion to MessagePart fails, you're left
+                    // with a nullptr. This tests that to prevent crashing.
+                    if(!modelData) {
+                        return undefined;
+                    }
+
+                    switch(modelData.type) {
+                        case MessagePart.Text: return textComponent;
+                        case MessagePart.Code: return codeBlockComponent;
+                        default: return textComponent;
+                    }
+                }
+
+                Component {
+                    id: textComponent
+                    TextComponent {
+                        itemData: msgCreatorDelegate.modelData
+                    }
+                }
+
+                Component {
+                    id: codeBlockComponent
+                    CodeBlockComponent {
+                        itemData: msgCreatorDelegate.modelData
+                    }
+                }
+            }
+        }
+    }
+
+    component TextComponent : TextBlock {
+        required property var itemData
+        height: implicitHeight + 10
+        verticalAlignment: Text.AlignVCenter
+        leftPadding: 10
+        text: itemData.text
+        color: root.fontColor
+        selectionColor: root.selectionColor
+    }
+
+
+    component CodeBlockComponent : CodeBlock {
+        required property var itemData
+        anchors {
+            left: parent.left
+            leftMargin: 10
+            right: parent.right
+            rightMargin: 10
+        }
+
+        code: itemData.text
+        language: itemData.language
+        color: root.codeBgColor
+        selectionColor: root.selectionColor
+    }
+
+}

ChatView/qml/RootItem.qml

@@ -0,0 +1,186 @@
+/*
+ * 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 ComponentBehavior: Bound
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic as QQC
+import QtQuick.Layouts
+import ChatView
+
+ChatRootView {
+    id: root
+
+    Rectangle {
+        id: bg
+        anchors.fill: parent
+        color: root.backgroundColor
+    }
+
+    ColumnLayout {
+        anchors {
+            fill: parent
+        }
+        spacing: 10
+
+        ListView {
+            id: chatListView
+
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            leftMargin: 5
+            model: root.chatModel
+            clip: true
+            spacing: 10
+            boundsBehavior: Flickable.StopAtBounds
+            cacheBuffer: 2000
+
+            delegate: ChatItem {
+                required property var model
+                width: ListView.view.width - scroll.width
+                msgModel: root.chatModel.processMessageContent(model.content)
+                color: model.roleType === ChatModel.User ? root.primaryColor : root.secondaryColor
+                fontColor: root.primaryColor.hslLightness > 0.5 ? "black" : "white"
+                codeBgColor: root.codeColor
+                selectionColor: root.primaryColor.hslLightness > 0.5 ? Qt.darker(root.primaryColor, 1.5)
+                                                                     : Qt.lighter(root.primaryColor, 1.5)
+
+            }
+
+            header: Item {
+                width: ListView.view.width - scroll.width
+                height: 30
+            }
+
+            ScrollBar.vertical: ScrollBar {
+                id: scroll
+            }
+
+            onCountChanged: {
+                root.scrollToBottom()
+            }
+
+            onContentHeightChanged: {
+                if (atYEnd) {
+                    root.scrollToBottom()
+                }
+            }
+        }
+
+        ScrollView {
+            id: view
+
+            Layout.fillWidth: true
+            Layout.minimumHeight: 30
+            Layout.maximumHeight: root.height / 2
+
+            QQC.TextArea {
+                id: messageInput
+
+                placeholderText: qsTr("Type your message here...")
+                placeholderTextColor: "#888"
+                color: root.primaryColor.hslLightness > 0.5 ? "black" : "white"
+                background: Rectangle {
+                    radius: 2
+                    color: root.primaryColor
+                    border.color: root.primaryColor.hslLightness > 0.5 ? Qt.lighter(root.primaryColor, 1.5)
+                                                                       : Qt.darker(root.primaryColor, 1.5)
+                    border.width: 1
+                }
+                Keys.onPressed: function(event) {
+                    if ((event.key === Qt.Key_Return || event.key === Qt.Key_Enter) && !(event.modifiers & Qt.ShiftModifier)) {
+                        root.sendChatMessage()
+                        event.accepted = true;
+                    }
+                }
+            }
+        }
+
+        RowLayout {
+            Layout.fillWidth: true
+            spacing: 5
+
+            Button {
+                id: sendButton
+
+                Layout.alignment: Qt.AlignBottom
+                text: qsTr("Send")
+                onClicked: root.sendChatMessage()
+            }
+
+            Button {
+                id: stopButton
+
+                Layout.alignment: Qt.AlignBottom
+                text: qsTr("Stop")
+                onClicked: root.cancelRequest()
+            }
+
+            Button {
+                id: clearButton
+
+                Layout.alignment: Qt.AlignBottom
+                text: qsTr("Clear Chat")
+                onClicked: root.clearChat()
+            }
+
+            CheckBox {
+                id: sharingCurrentFile
+
+                text: "Share current file with models"
+                checked: root.isSharingCurrentFile
+            }
+        }
+    }
+
+    Row {
+        id: bar
+
+        layoutDirection: Qt.RightToLeft
+
+        anchors {
+            left: parent.left
+            leftMargin: 5
+            right: parent.right
+            rightMargin: scroll.width
+        }
+        spacing: 10
+
+        Badge {
+            text: qsTr("tokens:%1/%2").arg(root.chatModel.totalTokens).arg(root.chatModel.tokensThreshold)
+            color: root.codeColor
+            fontColor: root.primaryColor.hslLightness > 0.5 ? "black" : "white"
+        }
+    }
+
+    function clearChat() {
+        root.chatModel.clear()
+    }
+
+    function scrollToBottom() {
+        Qt.callLater(chatListView.positionViewAtEnd)
+    }
+
+    function sendChatMessage() {
+        root.sendMessage(messageInput.text, sharingCurrentFile.checked)
+        messageInput.text = ""
+        scrollToBottom()
+    }
+}

ChatView/qml/dialog/CodeBlock.qml

@@ -0,0 +1,100 @@
+/*
+ * 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/>.
+ */
+
+import QtQuick
+import QtQuick.Controls
+import ChatView
+
+Rectangle {
+    id: root
+
+    property string code: ""
+    property string language: ""
+    property color selectionColor
+
+    readonly property string monospaceFont: {
+        switch (Qt.platform.os) {
+            case "windows":
+                return "Consolas";
+            case "osx":
+                return "Menlo";
+            case "linux":
+                return "DejaVu Sans Mono";
+            default:
+                return "monospace";
+        }
+    }
+
+    border.color: root.color.hslLightness > 0.5 ? Qt.darker(root.color, 1.3)
+                                                : Qt.lighter(root.color, 1.3)
+    border.width: 2
+    radius: 4
+
+    implicitWidth: parent.width
+    implicitHeight: codeText.implicitHeight + 20
+
+    ChatUtils {
+        id: utils
+    }
+
+    TextEdit {
+        id: codeText
+
+        anchors.fill: parent
+        anchors.margins: 10
+        text: root.code
+        readOnly: true
+        selectByMouse: true
+        font.family: root.monospaceFont
+        font.pointSize: 12
+        color: parent.color.hslLightness > 0.5 ? "black" : "white"
+        wrapMode: Text.WordWrap
+        selectionColor: root.selectionColor
+    }
+
+    TextEdit {
+        anchors.top: parent.top
+        anchors.right: parent.right
+        anchors.margins: 5
+        readOnly: true
+        selectByMouse: true
+        text: root.language
+        color: root.color.hslLightness > 0.5 ? Qt.darker(root.color, 1.1)
+                                             : Qt.lighter(root.color, 1.1)
+        font.pointSize: 8
+    }
+
+    Button {
+        anchors.top: parent.top
+        anchors.right: parent.right
+        anchors.margins: 5
+        text: "Copy"
+        onClicked: {
+            utils.copyToClipboard(root.code)
+            text = qsTr("Copied")
+            copyTimer.start()
+        }
+
+        Timer {
+            id: copyTimer
+            interval: 2000
+            onTriggered: parent.text = qsTr("Copy")
+        }
+    }
+}

ChatView/qml/dialog/TextBlock.qml

@@ -0,0 +1,29 @@
+/*
+ * 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/>.
+ */
+
+import QtQuick
+
+TextEdit {
+    id: root
+
+    readOnly: true
+    selectByMouse: true
+    wrapMode: Text.WordWrap
+    textFormat: Text.StyledText
+}

ConfigurationManager.cpp

@@ -0,0 +1,162 @@
+/* 
+ * 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 "ConfigurationManager.hpp"
+
+#include <QTimer>
+#include <settings/ButtonAspect.hpp>
+
+#include "QodeAssisttr.h"
+
+namespace QodeAssist {
+
+ConfigurationManager &ConfigurationManager::instance()
+{
+    static ConfigurationManager instance;
+    return instance;
+}
+
+void ConfigurationManager::init()
+{
+    setupConnections();
+}
+
+ConfigurationManager::ConfigurationManager(QObject *parent)
+    : QObject(parent)
+    , m_generalSettings(Settings::generalSettings())
+    , m_providersManager(LLMCore::ProvidersManager::instance())
+    , m_templateManger(LLMCore::PromptTemplateManager::instance())
+{}
+
+void ConfigurationManager::setupConnections()
+{
+    using Config = ConfigurationManager;
+    using Button = ButtonAspect;
+
+    connect(&m_generalSettings.ccSelectProvider, &Button::clicked, this, &Config::selectProvider);
+    connect(&m_generalSettings.caSelectProvider, &Button::clicked, this, &Config::selectProvider);
+    connect(&m_generalSettings.ccSelectModel, &Button::clicked, this, &Config::selectModel);
+    connect(&m_generalSettings.caSelectModel, &Button::clicked, this, &Config::selectModel);
+    connect(&m_generalSettings.ccSelectTemplate, &Button::clicked, this, &Config::selectTemplate);
+    connect(&m_generalSettings.caSelectTemplate, &Button::clicked, this, &Config::selectTemplate);
+    connect(&m_generalSettings.ccSetUrl, &Button::clicked, this, &Config::selectUrl);
+    connect(&m_generalSettings.caSetUrl, &Button::clicked, this, &Config::selectUrl);
+}
+
+void ConfigurationManager::selectProvider()
+{
+    const auto providersList = m_providersManager.providersNames();
+
+    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
+    if (!settingsButton)
+        return;
+
+    auto &targetSettings = (settingsButton == &m_generalSettings.ccSelectProvider)
+                               ? m_generalSettings.ccProvider
+                               : m_generalSettings.caProvider;
+
+    QTimer::singleShot(0, this, [this, providersList, &targetSettings] {
+        m_generalSettings.showSelectionDialog(providersList,
+                                              targetSettings,
+                                              Tr::tr("Select LLM Provider"),
+                                              Tr::tr("Providers:"));
+    });
+}
+
+void ConfigurationManager::selectModel()
+{
+    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
+    if (!settingsButton)
+        return;
+
+    const bool isCodeCompletion = (settingsButton == &m_generalSettings.ccSelectModel);
+
+    const QString providerName = isCodeCompletion ? m_generalSettings.ccProvider.volatileValue()
+                                                  : m_generalSettings.caProvider.volatileValue();
+
+    const auto providerUrl = isCodeCompletion ? m_generalSettings.ccUrl.volatileValue()
+                                              : m_generalSettings.caUrl.volatileValue();
+
+    auto &targetSettings = isCodeCompletion ? m_generalSettings.ccModel : m_generalSettings.caModel;
+
+    if (auto provider = m_providersManager.getProviderByName(providerName)) {
+        if (!provider->supportsModelListing()) {
+            m_generalSettings.showModelsNotSupportedDialog(targetSettings);
+            return;
+        }
+
+        const auto modelList = provider->getInstalledModels(providerUrl);
+
+        if (modelList.isEmpty()) {
+            m_generalSettings.showModelsNotFoundDialog(targetSettings);
+            return;
+        }
+
+        QTimer::singleShot(0, &m_generalSettings, [this, modelList, &targetSettings]() {
+            m_generalSettings.showSelectionDialog(
+                modelList, targetSettings, Tr::tr("Select LLM Model"), Tr::tr("Models:"));
+        });
+    }
+}
+
+void ConfigurationManager::selectTemplate()
+{
+    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
+    if (!settingsButton)
+        return;
+
+    const bool isCodeCompletion = (settingsButton == &m_generalSettings.ccSelectTemplate);
+
+    const auto templateList = isCodeCompletion ? m_templateManger.fimTemplatesNames()
+                                               : m_templateManger.chatTemplatesNames();
+
+    auto &targetSettings = isCodeCompletion ? m_generalSettings.ccTemplate
+                                            : m_generalSettings.caTemplate;
+
+    QTimer::singleShot(0, &m_generalSettings, [this, templateList, &targetSettings]() {
+        m_generalSettings.showSelectionDialog(templateList,
+                                              targetSettings,
+                                              Tr::tr("Select Template"),
+                                              Tr::tr("Templates:"));
+    });
+}
+
+void ConfigurationManager::selectUrl()
+{
+    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
+    if (!settingsButton)
+        return;
+
+    QStringList urls;
+    for (const auto &name : m_providersManager.providersNames()) {
+        const auto url = m_providersManager.getProviderByName(name)->url();
+        if (!urls.contains(url))
+            urls.append(url);
+    }
+
+    auto &targetSettings = (settingsButton == &m_generalSettings.ccSetUrl)
+                               ? m_generalSettings.ccUrl
+                               : m_generalSettings.caUrl;
+
+    QTimer::singleShot(0, &m_generalSettings, [this, urls, &targetSettings]() {
+        m_generalSettings.showUrlSelectionDialog(targetSettings, urls);
+    });
+}
+
+} // namespace QodeAssist

ConfigurationManager.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 <QObject>
+
+#include "llmcore/PromptTemplateManager.hpp"
+#include "llmcore/ProvidersManager.hpp"
+#include "settings/GeneralSettings.hpp"
+
+namespace QodeAssist {
+
+class ConfigurationManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    static ConfigurationManager &instance();
+
+    void init();
+
+public slots:
+    void selectProvider();
+    void selectModel();
+    void selectTemplate();
+    void selectUrl();
+
+private:
+    explicit ConfigurationManager(QObject *parent = nullptr);
+    ~ConfigurationManager() = default;
+    ConfigurationManager(const ConfigurationManager &) = delete;
+    ConfigurationManager &operator=(const ConfigurationManager &) = delete;
+
+    Settings::GeneralSettings &m_generalSettings;
+    LLMCore::ProvidersManager &m_providersManager;
+    LLMCore::PromptTemplateManager &m_templateManger;
+
+    void setupConnections();
+};
+
+} // namespace QodeAssist

DocumentContextReader.cpp

@@ -23,7 +23,8 @@
 #include <QTextBlock>
 #include <languageserverprotocol/lsptypes.h>
 
-#include "QodeAssistSettings.hpp"
+#include "core/ChangesManager.h"
+#include "settings/CodeCompletionSettings.hpp"
 
 const QRegularExpression &getYearRegex()
 {
@@ -130,17 +131,10 @@ QString DocumentContextReader::getLanguageAndFileInfo() const
     QString filePath = m_textDocument->filePath().toString();
     QString fileExtension = QFileInfo(filePath).suffix();
 
-    return QString("//Language: %1 (MIME: %2) filepath: %3(%4)\n\n")
+    return QString("Language: %1 (MIME: %2) filepath: %3(%4)\n\n")
         .arg(language, mimeType, filePath, fileExtension);
 }
 
-QString DocumentContextReader::getSpecificInstructions() const
-{
-    QString specificInstruction = settings().specificInstractions().arg(
-        LanguageServerProtocol::TextDocumentItem::mimeTypeToLanguageId(m_textDocument->mimeType()));
-    return QString("//Instructions: %1").arg(specificInstruction);
-}
-
 CopyrightInfo DocumentContextReader::findCopyright()
 {
     CopyrightInfo result = {-1, -1, false};
@@ -209,4 +203,47 @@ CopyrightInfo DocumentContextReader::copyrightInfo() const
     return m_copyrightInfo;
 }
 
+LLMCore::ContextData DocumentContextReader::prepareContext(int lineNumber, int cursorPosition) const
+{
+    QString contextBefore = getContextBefore(lineNumber, cursorPosition);
+    QString contextAfter = getContextAfter(lineNumber, cursorPosition);
+
+    QString fileContext;
+    if (Settings::codeCompletionSettings().useFilePathInContext())
+        fileContext.append("\n ").append(getLanguageAndFileInfo());
+
+    if (Settings::codeCompletionSettings().useProjectChangesCache())
+        fileContext.append("\n ").append(
+            ChangesManager::instance().getRecentChangesContext(m_textDocument));
+
+    return {contextBefore, contextAfter, fileContext};
+}
+
+QString DocumentContextReader::getContextBefore(int lineNumber, int cursorPosition) const
+{
+    if (Settings::codeCompletionSettings().readFullFile()) {
+        return readWholeFileBefore(lineNumber, cursorPosition);
+    } else {
+        int effectiveStartLine;
+        int beforeCursor = Settings::codeCompletionSettings().readStringsBeforeCursor();
+        if (m_copyrightInfo.found) {
+            effectiveStartLine = qMax(m_copyrightInfo.endLine + 1, lineNumber - beforeCursor);
+        } else {
+            effectiveStartLine = qMax(0, lineNumber - beforeCursor);
+        }
+        return getContextBetween(effectiveStartLine, lineNumber, cursorPosition);
+    }
+}
+
+QString DocumentContextReader::getContextAfter(int lineNumber, int cursorPosition) const
+{
+    if (Settings::codeCompletionSettings().readFullFile()) {
+        return readWholeFileAfter(lineNumber, cursorPosition);
+    } else {
+        int endLine = qMin(m_document->blockCount() - 1,
+                           lineNumber + Settings::codeCompletionSettings().readStringsAfterCursor());
+        return getContextBetween(lineNumber + 1, endLine, -1);
+    }
+}
+
 } // namespace QodeAssist

DocumentContextReader.hpp

@@ -22,6 +22,8 @@
 #include <QTextDocument>
 #include <texteditor/textdocument.h>
 
+#include <llmcore/ContextData.hpp>
+
 namespace QodeAssist {
 
 struct CopyrightInfo
@@ -42,12 +44,17 @@ public:
     QString readWholeFileBefore(int lineNumber, int cursorPosition) const;
     QString readWholeFileAfter(int lineNumber, int cursorPosition) const;
     QString getLanguageAndFileInfo() const;
-    QString getSpecificInstructions() const;
     CopyrightInfo findCopyright();
     QString getContextBetween(int startLine, int endLine, int cursorPosition) const;
 
     CopyrightInfo copyrightInfo() const;
 
+    LLMCore::ContextData prepareContext(int lineNumber, int cursorPosition) const;
+
+private:
+    QString getContextBefore(int lineNumber, int cursorPosition) const;
+    QString getContextAfter(int lineNumber, int cursorPosition) const;
+
 private:
     TextEditor::TextDocument *m_textDocument;
     QTextDocument *m_document;

LLMClientInterface.cpp

@@ -23,20 +23,25 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 
+#include <llmcore/RequestConfig.hpp>
 #include <texteditor/textdocument.h>
 
 #include "DocumentContextReader.hpp"
-#include "LLMProvidersManager.hpp"
-#include "PromptTemplateManager.hpp"
-#include "QodeAssistSettings.hpp"
-#include "QodeAssistUtils.hpp"
+#include "llmcore/PromptTemplateManager.hpp"
+#include "llmcore/ProvidersManager.hpp"
+#include "logger/Logger.hpp"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
 
 namespace QodeAssist {
 
 LLMClientInterface::LLMClientInterface()
-    : m_manager(new QNetworkAccessManager(this))
+    : m_requestHandler(this)
 {
-    updateProvider();
+    connect(&m_requestHandler,
+            &LLMCore::RequestHandler::completionReceived,
+            this,
+            &LLMClientInterface::sendCompletionToClient);
 }
 
 Utils::FilePath LLMClientInterface::serverDeviceTemplate() const
@@ -51,8 +56,6 @@ void LLMClientInterface::startImpl()
 
 void LLMClientInterface::sendData(const QByteArray &data)
 {
-    updateProvider();
-
     QJsonDocument doc = QJsonDocument::fromJson(data);
     if (!doc.isObject())
         return;
@@ -69,100 +72,28 @@ void LLMClientInterface::sendData(const QByteArray &data)
     } else if (method == "textDocument/didOpen") {
         handleTextDocumentDidOpen(request);
     } else if (method == "getCompletionsCycling") {
+        QString requestId = request["id"].toString();
+        startTimeMeasurement(requestId);
         handleCompletion(request);
     } else if (method == "$/cancelRequest") {
         handleCancelRequest(request);
     } else if (method == "exit") {
         // TODO make exit handler
     } else {
-        logMessage(QString("Unknown method: %1").arg(method));
+        LOG_MESSAGE(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));
+    if (m_requestHandler.cancelRequest(id)) {
+        LOG_MESSAGE(QString("Request %1 cancelled successfully").arg(id));
     } else {
-        logMessage(QString("Request %1 not found").arg(id));
+        LOG_MESSAGE(QString("Request %1 not found").arg(id));
     }
 }
 
-bool LLMClientInterface::processSingleLineCompletion(QNetworkReply *reply,
-                                                     const QJsonObject &request,
-                                                     const QString &accumulatedCompletion)
-{
-    int newlinePos = accumulatedCompletion.indexOf('\n');
-
-    if (newlinePos != -1) {
-        QString singleLineCompletion = accumulatedCompletion.left(newlinePos).trimmed();
-        singleLineCompletion = removeStopWords(singleLineCompletion);
-
-        QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
-
-        sendCompletionToClient(singleLineCompletion, request, position, true);
-        m_accumulatedResponses.remove(reply);
-        reply->abort();
-
-        return true;
-    }
-    return false;
-}
-
-QString LLMClientInterface::сontextBefore(TextEditor::TextEditorWidget *widget,
-                                          int lineNumber,
-                                          int cursorPosition)
-{
-    if (!widget)
-        return QString();
-
-    DocumentContextReader reader(widget->textDocument());
-    const auto &copyright = reader.copyrightInfo();
-
-    logMessage(QString{"Line Number: %1"}.arg(lineNumber));
-    logMessage(QString("Copyright found %1 %2").arg(copyright.found).arg(copyright.endLine));
-    if (lineNumber < reader.findCopyright().endLine)
-        return QString();
-
-    QString contextBefore;
-    if (settings().readFullFile()) {
-        contextBefore = reader.readWholeFileBefore(lineNumber, cursorPosition);
-    } else {
-        contextBefore = reader.getContextBefore(lineNumber,
-                                                cursorPosition,
-                                                settings().readStringsBeforeCursor());
-    }
-
-    return QString("%1\n%2\n%3")
-        .arg(reader.getSpecificInstructions(), reader.getLanguageAndFileInfo(), contextBefore);
-}
-
-QString LLMClientInterface::сontextAfter(TextEditor::TextEditorWidget *widget,
-                                         int lineNumber,
-                                         int cursorPosition)
-{
-    if (!widget)
-        return QString();
-
-    DocumentContextReader reader(widget->textDocument());
-    if (lineNumber < reader.findCopyright().endLine)
-        return QString();
-
-    QString contextAfter;
-    if (settings().readFullFile()) {
-        contextAfter = reader.readWholeFileAfter(lineNumber, cursorPosition);
-    } else {
-        contextAfter = reader.getContextAfter(lineNumber,
-                                              cursorPosition,
-                                              settings().readStringsAfterCursor());
-    }
-
-    return contextAfter;
-}
-
 void LLMClientInterface::handleInitialize(const QJsonObject &request)
 {
     QJsonObject response;
@@ -213,44 +144,60 @@ void LLMClientInterface::handleExit(const QJsonObject &request)
     emit finished();
 }
 
-void LLMClientInterface::handleLLMResponse(QNetworkReply *reply, const QJsonObject &request)
+void LLMClientInterface::handleCompletion(const QJsonObject &request)
 {
-    QString &accumulatedResponse = m_accumulatedResponses[reply];
+    auto updatedContext = prepareContext(request);
+    auto &completeSettings = Settings::codeCompletionSettings();
 
-    auto &templateManager = PromptTemplateManager::instance();
-    const Templates::PromptTemplate *currentTemplate = templateManager.getCurrentTemplate();
+    auto providerName = Settings::generalSettings().ccProvider();
+    auto provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
 
-    auto &providerManager = LLMProvidersManager::instance();
-    bool isComplete = providerManager.getCurrentProvider()->handleResponse(reply,
-                                                                           accumulatedResponse);
-
-    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
-
-    if (!settings().multiLineCompletion()
-        && processSingleLineCompletion(reply, request, accumulatedResponse)) {
+    if (!provider) {
+        LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
         return;
     }
 
-    if (isComplete || reply->isFinished()) {
-        if (isComplete) {
-            auto cleanedCompletion = removeStopWords(accumulatedResponse);
-            sendCompletionToClient(cleanedCompletion, request, position, true);
-        } else {
-            handleCompletion(request, accumulatedResponse);
-        }
-        m_accumulatedResponses.remove(reply);
+    auto templateName = Settings::generalSettings().ccTemplate();
+    auto promptTemplate = LLMCore::PromptTemplateManager::instance().getFimTemplateByName(
+        templateName);
+
+    if (!promptTemplate) {
+        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+        return;
     }
+
+    LLMCore::LLMConfig config;
+    config.requestType = LLMCore::RequestType::Fim;
+    config.provider = provider;
+    config.promptTemplate = promptTemplate;
+    config.url = QUrl(
+        QString("%1%2").arg(Settings::generalSettings().ccUrl(), provider->completionEndpoint()));
+    config.apiKey = Settings::codeCompletionSettings().apiKey();
+
+    config.providerRequest = {{"model", Settings::generalSettings().ccModel()}, {"stream", true}};
+
+    config.multiLineCompletion = completeSettings.multiLineCompletion();
+
+    QString systemPrompt;
+    if (completeSettings.useSystemPrompt())
+        systemPrompt.append(completeSettings.systemPrompt());
+    if (!updatedContext.fileContext.isEmpty())
+        systemPrompt.append(updatedContext.fileContext);
+    if (!systemPrompt.isEmpty())
+        config.providerRequest["system"] = systemPrompt;
+
+    const auto stopWords = QJsonArray::fromStringList(config.promptTemplate->stopWords());
+    if (!stopWords.isEmpty())
+        config.providerRequest["stop"] = stopWords;
+
+    config.promptTemplate->prepareRequest(config.providerRequest, updatedContext);
+    config.provider->prepareRequest(config.providerRequest, LLMCore::RequestType::Fim);
+
+    m_requestHandler.sendLLMRequest(config, request);
 }
 
-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)
+LLMCore::ContextData LLMClientInterface::prepareContext(const QJsonObject &request,
+                                                        const QStringView &accumulatedCompletion)
 {
     QJsonObject params = request["params"].toObject();
     QJsonObject doc = params["doc"].toObject();
@@ -262,37 +209,23 @@ LLMClientInterface::ContextPair LLMClientInterface::prepareContext(
         filePath);
 
     if (!textDocument) {
-        logMessage("Error: Document is not available for" + filePath.toString());
-        return {"", ""};
+        LOG_MESSAGE("Error: Document is not available for" + filePath.toString());
+        return LLMCore::ContextData{};
     }
 
     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()));
+    DocumentContextReader reader(textDocument);
+    return reader.prepareContext(lineNumber, cursorPosition);
 }
 
 void LLMClientInterface::sendCompletionToClient(const QString &completion,
                                                 const QJsonObject &request,
-                                                const QJsonObject &position,
                                                 bool isComplete)
 {
+    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+
     QJsonObject response;
     response["jsonrpc"] = "2.0";
     response[LanguageServerProtocol::idKey] = request["id"];
@@ -312,69 +245,39 @@ void LLMClientInterface::sendCompletionToClient(const QString &completion,
     result[LanguageServerProtocol::isIncompleteKey] = !isComplete;
     response[LanguageServerProtocol::resultKey] = result;
 
-    logMessage(
+    LOG_MESSAGE(
         QString("Completions: \n%1")
             .arg(QString::fromUtf8(QJsonDocument(completions).toJson(QJsonDocument::Indented))));
 
-    logMessage(QString("Full response: \n%1")
+    LOG_MESSAGE(QString("Full response: \n%1")
                    .arg(QString::fromUtf8(QJsonDocument(response).toJson(QJsonDocument::Indented))));
 
+    QString requestId = request["id"].toString();
+    endTimeMeasurement(requestId);
     emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
 }
 
-void LLMClientInterface::sendLLMRequest(const QJsonObject &request, const ContextPair &prompt)
+void LLMClientInterface::startTimeMeasurement(const QString &requestId)
 {
-    QJsonObject qodeRequest = {{"model", settings().modelName.value()}, {"stream", true}};
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    currentTemplate->prepareRequest(qodeRequest, prompt.prefix, prompt.suffix);
-
-    auto &providerManager = LLMProvidersManager::instance();
-    providerManager.getCurrentProvider()->prepareRequest(qodeRequest);
-
-    logMessage(
-        QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
-            .arg(m_serverUrl.toString())
-            .arg(QString::fromUtf8(QJsonDocument(qodeRequest).toJson(QJsonDocument::Indented))));
-
-    QNetworkRequest networkRequest(m_serverUrl);
-    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    QNetworkReply *reply = m_manager->post(networkRequest, QJsonDocument(qodeRequest).toJson());
-    if (!reply) {
-        logMessage("Error: Failed to create network reply");
-        return;
-    }
-
-    QString requestId = request["id"].toString();
-    m_activeRequests[requestId] = reply;
-
-    connect(reply, &QNetworkReply::readyRead, this, [this, reply, request]() {
-        handleLLMResponse(reply, request);
-    });
-
-    connect(reply, &QNetworkReply::finished, this, [this, reply, requestId]() {
-        reply->deleteLater();
-        m_activeRequests.remove(requestId);
-        if (reply->error() != QNetworkReply::NoError) {
-            logMessage(QString("Error in QodeAssist request: %1").arg(reply->errorString()));
-        } else {
-            logMessage("Request finished successfully");
-        }
-    });
+    m_requestStartTimes[requestId] = QDateTime::currentMSecsSinceEpoch();
 }
 
-QString LLMClientInterface::removeStopWords(const QString &completion)
+void LLMClientInterface::endTimeMeasurement(const QString &requestId)
 {
-    QString filteredCompletion = completion;
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    QStringList stopWords = currentTemplate->stopWords();
-
-    for (const QString &stopWord : stopWords) {
-        filteredCompletion = filteredCompletion.replace(stopWord, "");
+    if (m_requestStartTimes.contains(requestId)) {
+        qint64 startTime = m_requestStartTimes[requestId];
+        qint64 endTime = QDateTime::currentMSecsSinceEpoch();
+        qint64 totalTime = endTime - startTime;
+        logPerformance(requestId, "TotalCompletionTime", totalTime);
+        m_requestStartTimes.remove(requestId);
     }
+}
 
-    return filteredCompletion;
+void LLMClientInterface::logPerformance(const QString &requestId,
+                                        const QString &operation,
+                                        qint64 elapsedMs)
+{
+    LOG_MESSAGE(QString("Performance: %1 %2 took %3 ms").arg(requestId, operation).arg(elapsedMs));
 }
 
 void LLMClientInterface::parseCurrentMessage() {}

LLMClientInterface.hpp

@@ -22,6 +22,9 @@
 #include <languageclient/languageclientinterface.h>
 #include <texteditor/texteditor.h>
 
+#include <llmcore/ContextData.hpp>
+#include <llmcore/RequestHandler.hpp>
+
 class QNetworkReply;
 class QNetworkAccessManager;
 
@@ -34,28 +37,13 @@ class LLMClientInterface : public LanguageClient::BaseClientInterface
 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();
+    void handleCompletion(const QJsonObject &request);
 
 protected:
     void startImpl() override;
@@ -69,18 +57,17 @@ private:
     void handleInitialized(const QJsonObject &request);
     void handleExit(const QJsonObject &request);
     void handleCancelRequest(const QJsonObject &request);
-    bool processSingleLineCompletion(QNetworkReply *reply,
-                                     const QJsonObject &request,
-                                     const QString &accumulatedCompletion);
 
-    QString сontextBefore(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
-    QString сontextAfter(TextEditor::TextEditorWidget *widget, int lineNumber, int cursorPosition);
-    QString removeStopWords(const QString &completion);
+    LLMCore::ContextData prepareContext(const QJsonObject &request,
+                                        const QStringView &accumulatedCompletion = QString{});
 
-    QUrl m_serverUrl;
-    QNetworkAccessManager *m_manager;
-    QMap<QString, QNetworkReply *> m_activeRequests;
-    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+    LLMCore::RequestHandler m_requestHandler;
+    QElapsedTimer m_completionTimer;
+    QMap<QString, qint64> m_requestStartTimes;
+
+    void startTimeMeasurement(const QString &requestId);
+    void endTimeMeasurement(const QString &requestId);
+    void logPerformance(const QString &requestId, const QString &operation, qint64 elapsedMs);
 };
 
 } // namespace QodeAssist

LLMSuggestion.cpp

@@ -19,21 +19,25 @@
 
 #include "LLMSuggestion.hpp"
 
+#include <QTextCursor>
+#include <QtWidgets/qtoolbar.h>
+#include <texteditor/texteditor.h>
+#include <utils/stringutils.h>
+#include <utils/tooltip/tooltip.h>
+
 namespace QodeAssist {
 
-LLMSuggestion::LLMSuggestion(const Completion &completion, QTextDocument *origin)
-    : m_completion(completion)
+LLMSuggestion::LLMSuggestion(const TextEditor::TextSuggestion::Data &data, QTextDocument *origin)
+    : TextEditor::TextSuggestion(data, origin)
+    , m_linesCount(0)
+    , m_suggestion(data)
 {
-    int startPos = completion.range().start().toPositionInDocument(origin);
-    int endPos = completion.range().end().toPositionInDocument(origin);
+    int startPos = data.range.begin.toPositionInDocument(origin);
+    int endPos = data.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);
@@ -44,37 +48,65 @@ LLMSuggestion::LLMSuggestion(const Completion &completion, QTextDocument *origin
     int startPosInBlock = startPos - block.position();
     int endPosInBlock = endPos - block.position();
 
-    blockText.replace(startPosInBlock, endPosInBlock - startPosInBlock, completion.text());
+    blockText.replace(startPosInBlock, endPosInBlock - startPosInBlock, data.text);
 
-    document()->setPlainText(blockText);
-
-    setCurrentPosition(m_start.position());
+    replacementDocument()->setPlainText(blockText);
 }
 
 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;
+    return TextEditor::TextSuggestion::apply();
 }
 
 bool LLMSuggestion::applyWord(TextEditor::TextEditorWidget *widget)
 {
-    Q_UNUSED(widget)
-    return apply();
+    return TextEditor::TextSuggestion::applyWord(widget);
+}
+
+bool LLMSuggestion::applyLine(TextEditor::TextEditorWidget *widget)
+{
+    return TextEditor::TextSuggestion::applyLine(widget);
 }
 
 void LLMSuggestion::reset()
 {
-    m_start.removeSelectedText();
+    reset();
+    m_linesCount = 0;
 }
 
-int LLMSuggestion::position()
+void LLMSuggestion::onCounterFinished(int count)
 {
-    return m_start.position();
+    Utils::ToolTip::hide();
+    m_linesCount = 0;
+    QTextCursor cursor = m_completion.range().toSelection(m_start.document());
+    cursor.beginEditBlock();
+    cursor.removeSelectedText();
+
+    QStringList lines = m_completion.text().split('\n');
+    QString textToInsert = lines.mid(0, count).join('\n');
+
+    cursor.insertText(textToInsert);
+    cursor.endEditBlock();
+}
+
+// void LLMSuggestion::reset()
+// {
+//     m_start.removeSelectedText();
+// }
+
+// int LLMSuggestion::position()
+// {
+//     return m_start.position();
+// }
+
+void LLMSuggestion::showTooltip(TextEditor::TextEditorWidget *widget, int count)
+{
+    // Utils::ToolTip::hide();
+    // QPoint pos = widget->mapToGlobal(widget->cursorRect().topRight());
+    // pos += QPoint(-10, -50);
+    // m_counterTooltip = new CounterTooltip(count);
+    // Utils::ToolTip::show(pos, m_counterTooltip, widget);
+    // connect(m_counterTooltip, &CounterTooltip::finished, this, &LLMSuggestion::onCounterFinished);
 }
 
 } // namespace QodeAssist

LLMSuggestion.hpp

@@ -19,27 +19,36 @@
 
 #pragma once
 
+#include <QObject>
+#include "LSPCompletion.hpp"
 #include <texteditor/textdocumentlayout.h>
 
-#include "LSPCompletion.hpp"
+#include "utils/CounterTooltip.hpp"
 
 namespace QodeAssist {
 
-class LLMSuggestion final : public TextEditor::TextSuggestion
+class LLMSuggestion final : public QObject, public TextEditor::TextSuggestion
 {
+    Q_OBJECT
 public:
-    LLMSuggestion(const Completion &completion, QTextDocument *origin);
+    LLMSuggestion(const TextEditor::TextSuggestion::Data &data, QTextDocument *origin);
 
-    bool apply() final;
-    bool applyWord(TextEditor::TextEditorWidget *widget) final;
-    void reset() final;
-    int position() final;
+    bool apply() override;
+    bool applyWord(TextEditor::TextEditorWidget *widget) override;
+    bool applyLine(TextEditor::TextEditorWidget *widget) override;
+    void reset();
 
-    const Completion &completion() const { return m_completion; }
+    void showTooltip(TextEditor::TextEditorWidget *widget, int count);
+    void onCounterFinished(int count);
 
 private:
     Completion m_completion;
     QTextCursor m_start;
+    int m_linesCount;
+
+    CounterTooltip *m_counterTooltip = nullptr;
+    int m_startPosition;
+    TextEditor::TextSuggestion::Data m_suggestion;
 };
 
 } // namespace QodeAssist

LSPCompletion.hpp

@@ -43,6 +43,10 @@ public:
     {
         return typedValue<LanguageServerProtocol::Position>(LanguageServerProtocol::positionKey);
     }
+    void setRange(const LanguageServerProtocol::Range &range)
+    {
+        insert(LanguageServerProtocol::rangeKey, range);
+    }
     LanguageServerProtocol::Range range() const
     {
         return typedValue<LanguageServerProtocol::Range>(LanguageServerProtocol::rangeKey);

QodeAssist.json.in

@@ -1,16 +1,13 @@
 {
+    "Id" : "qodeassist",
     "Name" : "QodeAssist",
-    "Version" : "0.0.5",
-    "CompatVersion" : "${IDE_VERSION_COMPAT}",
+    "Version" : "0.4.0",
     "Vendor" : "Petr Mironychev",
+    "VendorId" : "petrmironychev",
     "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)"],
+    "License" : "GPLv3",
+    "Description": "QodeAssist is an AI-powered coding assistant for Qt Creator. It provides intelligent code completion and suggestions for your code. Prerequisites: Requires one of the supported LLM providers installed (e.g., Ollama or LM Studio) and a compatible large language model downloaded for your chosen provider (e.g., CodeLlama, StarCoder2).",
     "Url" : "https://github.com/Palm1r/QodeAssist",
+    "DocumentationUrl" : "",
     ${IDE_PLUGIN_DEPENDENCIES}
 }

QodeAssistClient.cpp

@@ -31,7 +31,9 @@
 
 #include "LLMClientInterface.hpp"
 #include "LLMSuggestion.hpp"
-#include "QodeAssistSettings.hpp"
+#include "core/ChangesManager.h"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
 
 using namespace LanguageServerProtocol;
 using namespace TextEditor;
@@ -43,6 +45,7 @@ namespace QodeAssist {
 
 QodeAssistClient::QodeAssistClient()
     : LanguageClient::Client(new LLMClientInterface())
+    , m_recentCharCount(0)
 {
     setName("Qode Assist");
     LanguageClient::LanguageFilter filter;
@@ -51,6 +54,8 @@ QodeAssistClient::QodeAssistClient()
 
     start();
     setupConnections();
+
+    m_typingTimer.start();
 }
 
 QodeAssistClient::~QodeAssistClient()
@@ -70,7 +75,7 @@ void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
             this,
             [this, document](int position, int charsRemoved, int charsAdded) {
                 Q_UNUSED(charsRemoved)
-                if (!settings().enableAutoComplete())
+                if (!Settings::codeCompletionSettings().autoCompletion())
                     return;
 
                 auto project = ProjectManager::projectForFile(document->filePath());
@@ -80,13 +85,32 @@ void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
                 auto textEditor = BaseTextEditor::currentTextEditor();
                 if (!textEditor || textEditor->document() != document)
                     return;
+
+                if (Settings::codeCompletionSettings().useProjectChangesCache())
+                    ChangesManager::instance().addChange(document,
+                                                         position,
+                                                         charsRemoved,
+                                                         charsAdded);
+
                 TextEditorWidget *widget = textEditor->editorWidget();
                 if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
                     return;
                 const int cursorPosition = widget->textCursor().position();
                 if (cursorPosition < position || cursorPosition > position + charsAdded)
                     return;
-                scheduleRequest(widget);
+
+                m_recentCharCount += charsAdded;
+
+                if (m_typingTimer.elapsed()
+                    > Settings::codeCompletionSettings().autoCompletionTypingInterval()) {
+                    m_recentCharCount = charsAdded;
+                    m_typingTimer.restart();
+                }
+
+                if (m_recentCharCount
+                    > Settings::codeCompletionSettings().autoCompletionCharThreshold()) {
+                    scheduleRequest(widget);
+                }
             });
 }
 
@@ -130,7 +154,9 @@ void QodeAssistClient::scheduleRequest(TextEditor::TextEditorWidget *editor)
         connect(timer, &QTimer::timeout, this, [this, editor]() {
             if (editor
                 && editor->textCursor().position()
-                       == m_scheduledRequests[editor]->property("cursorPosition").toInt())
+                       == m_scheduledRequests[editor]->property("cursorPosition").toInt()
+                && m_recentCharCount
+                       > Settings::codeCompletionSettings().autoCompletionCharThreshold())
                 requestCompletions(editor);
         });
         connect(editor, &TextEditorWidget::destroyed, this, [this, editor]() {
@@ -144,9 +170,8 @@ void QodeAssistClient::scheduleRequest(TextEditor::TextEditorWidget *editor)
     }
 
     it.value()->setProperty("cursorPosition", editor->textCursor().position());
-    it.value()->start(settings().startSuggestionTimer());
+    it.value()->start(Settings::codeCompletionSettings().startSuggestionTimer());
 }
-
 void QodeAssistClient::handleCompletions(const GetCompletionRequest::Response &response,
                                          TextEditor::TextEditorWidget *editor)
 {
@@ -188,9 +213,19 @@ void QodeAssistClient::handleCompletions(const GetCompletionRequest::Response &r
         }
         if (completions.isEmpty())
             return;
+
+        auto suggestions = Utils::transform(completions, [](const Completion &c) {
+            auto toTextPos = [](const LanguageServerProtocol::Position pos) {
+                return Text::Position{pos.line() + 1, pos.character()};
+            };
+
+            Text::Range range{toTextPos(c.range().start()), toTextPos(c.range().end())};
+            Text::Position pos{toTextPos(c.position())};
+            return TextSuggestion::Data{range, pos, c.text()};
+        });
+
         editor->insertSuggestion(
-            std::make_unique<LLMSuggestion>(completions.first(), editor->document()));
-        editor->addHoverHandler(&m_hoverHandler);
+            std::make_unique<LLMSuggestion>(suggestions.first(), editor->document()));
     }
 }
 
@@ -205,7 +240,7 @@ void QodeAssistClient::cancelRunningRequest(TextEditor::TextEditorWidget *editor
 
 bool QodeAssistClient::isEnabled(ProjectExplorer::Project *project) const
 {
-    return settings().enableQodeAssist();
+    return Settings::generalSettings().enableQodeAssist();
 }
 
 void QodeAssistClient::setupConnections()
@@ -237,11 +272,6 @@ 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();
 }

QodeAssistClient.hpp

@@ -27,7 +27,6 @@
 #include <languageclient/client.h>
 
 #include "LSPCompletion.hpp"
-#include "QodeAssistHoverHandler.hpp"
 
 namespace QodeAssist {
 
@@ -54,9 +53,11 @@ private:
 
     QHash<TextEditor::TextEditorWidget *, GetCompletionRequest> m_runningRequests;
     QHash<TextEditor::TextEditorWidget *, QTimer *> m_scheduledRequests;
-    QodeAssistHoverHandler m_hoverHandler;
     QMetaObject::Connection m_documentOpenedConnection;
     QMetaObject::Connection m_documentClosedConnection;
+
+    QElapsedTimer m_typingTimer;
+    int m_recentCharCount;
 };
 
 } // namespace QodeAssist

QodeAssistConstants.hpp

@@ -24,42 +24,6 @@ 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 SPECIFIC_INSTRUCTIONS[] = "QodeAssist.specificInstractions";
-const char MULTILINE_COMPLETION[] = "QodeAssist.multilineCompletion";
-const char API_KEY[] = "QodeAssist.apiKey";
-
-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

QodeAssistHoverHandler.cpp

@@ -1,114 +0,0 @@
-/*
- * 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

QodeAssistHoverHandler.hpp

@@ -1,47 +0,0 @@
-/*
- * 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

QodeAssistSettings.cpp

@@ -1,398 +0,0 @@
-/* 
- * 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(false);
-
-    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(50);
-
-    readStringsAfterCursor.setSettingsKey(Constants::READ_STRINGS_AFTER_CURSOR);
-    readStringsAfterCursor.setLabelText(Tr::tr("Read Strings After Cursor"));
-    readStringsAfterCursor.setDefaultValue(30);
-
-    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, 1.0);
-
-    useTopK.setSettingsKey(Constants::USE_TOP_K);
-    useTopK.setDefaultValue(false);
-
-    topK.setSettingsKey(Constants::TOP_K);
-    topK.setLabelText(Tr::tr("top_k"));
-    topK.setDefaultValue(50);
-    topK.setRange(1, 1000);
-
-    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);
-
-    specificInstractions.setSettingsKey(Constants::SPECIFIC_INSTRUCTIONS);
-    specificInstractions.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
-    specificInstractions.setLabelText(
-        Tr::tr("Instructions: Please keep %1 for languge name, warning, it shouldn't too big"));
-    specificInstractions.setDefaultValue(
-        "You are an expert %1 code completion AI."
-        "CRITICAL: Please provide minimal the best possible code completion suggestions.\n");
-
-    resetToDefaults.m_buttonText = Tr::tr("Reset to Defaults");
-    multiLineCompletion.setSettingsKey(Constants::MULTILINE_COMPLETION);
-    multiLineCompletion.setDefaultValue(true);
-    multiLineCompletion.setLabelText(Tr::tr("Enable Multiline Completion"));
-
-    apiKey.setSettingsKey(Constants::API_KEY);
-    apiKey.setLabelText(Tr::tr("API Key:"));
-    apiKey.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
-    apiKey.setPlaceHolderText(Tr::tr("Enter your API key here"));
-
-    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,
-                                        multiLineCompletion,
-                                        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,
-                                        readStringsBeforeCursor,
-                                        readStringsAfterCursor,
-                                        ollamaLivetime,
-                                        apiKey,
-                                        specificInstractions,
-                                        temperature,
-                                        maxTokens,
-                                        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);
-        resetAspect(specificInstractions);
-
-        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

QodeAssistUtils.hpp

@@ -1,68 +0,0 @@
-/* 
- * 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("[Qode Assist] ") + 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

README.md

@@ -1,43 +1,74 @@
-# QodeAssist
+# QodeAssist - AI-powered coding assistant plugin for Qt Creator
+[![Discord](https://dcbadge.limes.pink/api/server/https://discord.gg/DGgMtTteAD?style=flat?theme=discord)](https://discord.gg/DGgMtTteAD)
 [![Build plugin](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml/badge.svg?branch=main)](https://github.com/Palm1r/QodeAssist/actions/workflows/build_cmake.yml)
+![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/Palm1r/QodeAssist/total?color=41%2C173%2C71)
+![GitHub Tag](https://img.shields.io/github/v/tag/Palm1r/QodeAssist)
+![Static Badge](https://img.shields.io/badge/QtCreator-14.0.2-brightgreen)
+![Static Badge](https://img.shields.io/badge/donations:0-brightgreen)
 
-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.
+![qodeassist-icon](https://github.com/user-attachments/assets/dc336712-83cb-440d-8761-8d0a31de898d) 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)
+## Table of Contents
+1. [Overview](#overview)
+2. [Installation](#installation)
+3. [Configure Plugin](#configure-plugin)
+4. [Supported LLM Providers](#supported-llm-providers)
+5. [Recommended Models](#recommended-models)
+   - [Ollama](#ollama)
+6. [QtCreator Version Compatibility](#qtcreator-version-compatibility)
+7. [Development Progress](#development-progress)
+8. [Hotkeys](#hotkeys)
+9. [Troubleshooting](#troubleshooting)
+10. [Support the Development](#support-the-development-of-qodeassist)
+11. [How to Build](#how-to-build)
 
-## Supported Models
-QodeAssist has been tested with the following language models:
+## Overview
 
-Ollama:
-- [starcoder2](https://ollama.com/library/starcoder2)
-- [codellama](https://ollama.com/library/codellama)
+- AI-powered code completion
+- Chat functionality:
+  - Side and Bottom panels
+- Support for multiple LLM providers:
+  - Ollama
+  - LM Studio
+  - OpenAI-compatible providers(eg. https://openrouter.ai)
+- Extensive library of model-specific templates
+- Custom template support
+- Easy configuration and model selection
 
-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)
+<details>
+  <summary>Code completion: (click to expand)</summary>
+  <img src="https://github.com/user-attachments/assets/255a52f1-5cc0-4ca3-b05c-c4cf9cdbe25a" width="600" alt="QodeAssistPreview">
+</details>
 
-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.
+<details>
+  <summary>Chat with LLM models in side panels: (click to expand)</summary>
+  <img src="https://github.com/user-attachments/assets/ead5a5d9-b40a-4f17-af05-77fa2bcb3a61" width="600" alt="QodeAssistChat">
+</details>
 
-## Development Progress
+<details>
+  <summary>Chat with LLM models in bottom panel: (click to expand)</summary>
+  <img width="326" alt="QodeAssistBottomPanel" src="https://github.com/user-attachments/assets/4cc64c23-a294-4df8-9153-39ad6fdab34b">
+</details>
 
-- [x] Basic plugin with code autocomplete functionality
-- [ ] Improve and automate settings
-- [ ] Add chat functionality
-- [ ] Support for more providers and models
+## Installation
 
-## Installation Plugin
-
-1. Install QtCreator 14.0
+1. Install Latest QtCreator
 2. Install [Ollama](https://ollama.com). Make sure to review the system requirements before installation.
-3. Install a language model in Ollama. For example, you can run:
+3. Install a language models in Ollama via terminal. For example, you can run:
+
+For standard computers (minimum 8GB RAM):
 ```
-ollama run starcoder2:7b
+ollama run qwen2.5-coder:7b
 ```
-4. Download the QodeAssist plugin.
+For better performance (16GB+ RAM):
+```
+ollama run qwen2.5-coder:14b
+```
+For high-end systems (32GB+ RAM):
+```
+ollama run qwen2.5-coder:32b
+```
+4. Download the QodeAssist plugin for your QtCreator.
 5. Launch Qt Creator and install the plugin:
    - Go to MacOS: Qt Creator -> About Plugins...
            Windows\Linux: Help -> About Plugins...
@@ -46,17 +77,124 @@ ollama run starcoder2:7b
 
 ## Configure Plugin
 
-1. Open Qt Creator settings
+QodeAssist comes with default settings that should work immediately after installing a language model. The plugin is pre-configured to use Ollama with standard templates, so you may only need to verify the settings.
+
+1. Open Qt Creator settings (Edit > Preferences on Linux/Windows, Qt Creator > Preferences on macOS)
 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
+3. On the "General" page, verify:
+    - Ollama is selected as your LLM provider
+    - The URL is set to http://localhost:11434
+    - Your installed model appears in the model selection
+    - The prompt template is Ollama Auto FIM
+4. Click Apply if you made any changes
 
 You're all set! QodeAssist is now ready to use in Qt Creator.
 
+## Supported LLM Providers
+QodeAssist currently supports the following LLM (Large Language Model) providers:
+- [Ollama](https://ollama.com)
+- [LM Studio](https://lmstudio.ai) (experimental)
+- OpenAI compatible providers (experimental)
+
+## Recommended Models:
+QodeAssist has been thoroughly tested and optimized for use with the following language models:
+
+- Qwen2.5-coder
+- CodeLlama
+- StarCoder2
+- DeepSeek-Coder-V2
+
+### Ollama:
+### For autocomplete(FIM)
+```
+ollama run codellama:7b-code
+ollama run starcoder2:7b
+ollama run qwen2.5-coder:7b-base
+ollama run deepseek-coder-v2:16b-lite-base-q3_K_M
+```
+### For chat
+```
+ollama run codellama:7b-instruct
+ollama run starcoder2:instruct
+ollama run qwen2.5-coder:7b-instruct
+ollama run deepseek-coder-v2
+```
+
+### Template-Model Compatibility
+
+| Template | Compatible Models | Purpose |
+|----------|------------------|----------|
+| CodeLlama FIM | `codellama:code` | Code completion |
+| DeepSeekCoder FIM | `deepseek-coder-v2`, `deepseek-v2.5` | Code completion |
+| Ollama Auto FIM | `Any Ollama base model` | Code completion |
+| Qwen FIM | `Qwen 2.5 models` | Code completion |
+| StarCoder2 FIM | `starcoder2 base model` | Code completion |
+| Alpaca | `starcoder2:instruct` | Chat assistance |
+| Basic Chat| `Messages without tokens` | Chat assistance |
+| ChatML | `Qwen 2.5 models` | Chat assistance |
+| Llama2 | `llama2 model family`, `codellama:instruct` | Chat assistance |
+| Llama3 | `llama3 model family` | Chat assistance |
+| Ollama Auto Chat | `Any Ollama chat model` | Chat assistance |
+
+> Note: 
+> - FIM (Fill-in-Middle) templates are optimized for code completion
+> - Chat templates are designed for interactive dialogue
+> - The Ollama Auto templates automatically adapt to most Ollama models
+> - Custom Template allows you to define your own prompt format
+
+## QtCreator Version Compatibility
+
+- QtCreator 15.0.0 - 0.4.x 
+- QtCreator 14.0.2 - 0.2.3 - 0.3.x 
+- QtCreator 14.0.1 - 0.2.2 plugin version and below
+
+## Development Progress
+
+- [x] Basic plugin with code autocomplete functionality
+- [x] Improve and automate settings
+- [x] Add chat functionality
+- [x] Sharing diff with model
+- [ ] Sharing project source with model
+- [ ] Support for more providers and models
+
+## Hotkeys
+
+- To call manual request to suggestion, you can use or change it in settings
+    - on Mac: Option + Command + Q
+    - on Windows: Ctrl + Alt + Q
+- To insert the full suggestion, you can use the TAB key
+- To insert line by line, you can use the "Move cursor word right" shortcut:
+    - On Mac: Option + Right Arrow
+    - On Windows: Alt + Right Arrow
+    
+## Troubleshooting
+
+If QodeAssist is having problems connecting to the LLM provider, please check the following:
+
+1. Verify the IP address and port:
+
+    - For Ollama, the default is usually http://localhost:11434
+    - For LM Studio, the default is usually http://localhost:1234
+
+2. Check the endpoint:
+
+Make sure the endpoint in the settings matches the one required by your provider
+    - For Ollama, it should be /api/generate
+    - For LM Studio and OpenAI compatible providers, it's usually /v1/chat/completions
+
+3. Confirm that the selected model and template are compatible:
+
+Ensure you've chosen the correct model in the "Select Models" option
+Verify that the selected prompt template matches the model you're using
+
+If you're still experiencing issues with QodeAssist, you can try resetting the settings to their default values:
+1. Open Qt Creator settings
+2. Navigate to the "Qode Assist" tab
+3. Pick settings page for reset
+4. Click on the "Reset Page to Defaults" button
+    - The API key will not reset
+    - Select model after reset
+
 ## Support the development of QodeAssist
 If you find QodeAssist helpful, there are several ways you can support the project:
 
@@ -66,8 +204,7 @@ If you find QodeAssist helpful, there are several ways you can support the proje
 
 3. **Spread the Word**: Star our GitHub repository and share QodeAssist with your fellow developers.
 
-4. **Financial Support**: If you'd like to support the development financially, you can make a donation using one of the following cryptocurrency addresses:
-
+4. **Financial Support**: If you'd like to support the development financially, you can make a donation using one of the following:
    - Bitcoin (BTC): `bc1qndq7f0mpnlya48vk7kugvyqj5w89xrg4wzg68t`
    - Ethereum (ETH): `0xA5e8c37c94b24e25F9f1f292a01AF55F03099D8D`
    - Litecoin (LTC): `ltc1qlrxnk30s2pcjchzx4qrxvdjt5gzuervy5mv0vy`
@@ -86,3 +223,12 @@ where `<path_to_qtcreator>` is the relative or absolute path to a Qt Creator bui
 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.
+
+## For Contributors
+
+QML code style: Preferably follow the following guidelines https://github.com/Furkanzmc/QML-Coding-Guide, thank you @Furkanzmc for collect them
+C++ code style: check use .clang-fortmat in project
+
+![qodeassist-icon](https://github.com/user-attachments/assets/dc336712-83cb-440d-8761-8d0a31de898d)
+![qodeassist-icon-small](https://github.com/user-attachments/assets/8ec241bf-3186-452e-b8db-8d70543c2f41)
+

chat/ChatOutputPane.cpp

@@ -0,0 +1,95 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ChatOutputPane.h"
+
+#include "QodeAssisttr.h"
+
+namespace QodeAssist::Chat {
+
+ChatOutputPane::ChatOutputPane(QObject *parent)
+    : Core::IOutputPane(parent)
+    , m_chatWidget(new ChatWidget)
+{
+    setId("QodeAssistChat");
+    setDisplayName(Tr::tr("QodeAssist Chat"));
+    setPriorityInStatusBar(-40);
+}
+
+ChatOutputPane::~ChatOutputPane()
+{
+    delete m_chatWidget;
+}
+
+QWidget *ChatOutputPane::outputWidget(QWidget *)
+{
+    return m_chatWidget;
+}
+
+QList<QWidget *> ChatOutputPane::toolBarWidgets() const
+{
+    return {};
+}
+
+void ChatOutputPane::clearContents()
+{
+    m_chatWidget->clear();
+}
+
+void ChatOutputPane::visibilityChanged(bool visible)
+{
+    if (visible)
+        m_chatWidget->scrollToBottom();
+}
+
+void ChatOutputPane::setFocus()
+{
+    m_chatWidget->setFocus();
+}
+
+bool ChatOutputPane::hasFocus() const
+{
+    return m_chatWidget->hasFocus();
+}
+
+bool ChatOutputPane::canFocus() const
+{
+    return true;
+}
+
+bool ChatOutputPane::canNavigate() const
+{
+    return false;
+}
+
+bool ChatOutputPane::canNext() const
+{
+    return false;
+}
+
+bool ChatOutputPane::canPrevious() const
+{
+    return false;
+}
+
+void ChatOutputPane::goToNext() {}
+
+void ChatOutputPane::goToPrev() {}
+
+} // namespace QodeAssist::Chat

chat/ChatOutputPane.h

@@ -0,0 +1,52 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ChatView/ChatWidget.hpp"
+#include <coreplugin/ioutputpane.h>
+
+namespace QodeAssist::Chat {
+
+class ChatOutputPane : public Core::IOutputPane
+{
+    Q_OBJECT
+
+public:
+    explicit ChatOutputPane(QObject *parent = nullptr);
+    ~ChatOutputPane() override;
+
+    QWidget *outputWidget(QWidget *parent) override;
+    QList<QWidget *> toolBarWidgets() const override;
+    void clearContents() override;
+    void visibilityChanged(bool visible) override;
+    void setFocus() override;
+    bool hasFocus() const override;
+    bool canFocus() const override;
+    bool canNavigate() const override;
+    bool canNext() const override;
+    bool canPrevious() const override;
+    void goToNext() override;
+    void goToPrev() override;
+
+private:
+    ChatWidget *m_chatWidget;
+};
+
+} // namespace QodeAssist::Chat

chat/NavigationPanel.cpp

@@ -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/>.
+ */
+
+#include "NavigationPanel.hpp"
+
+#include "ChatView/ChatWidget.hpp"
+
+namespace QodeAssist::Chat {
+
+NavigationPanel::NavigationPanel() {
+    setDisplayName(tr("QodeAssist Chat"));
+    setPriority(500);
+    setId("QodeAssistChat");
+    setActivationSequence(QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_C));
+}
+
+NavigationPanel::~NavigationPanel()
+{
+}
+
+Core::NavigationView NavigationPanel::createWidget()
+{
+    Core::NavigationView view;
+    view.widget = new ChatWidget;
+
+    return view;
+}
+
+}

chat/NavigationPanel.hpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QObject>
+#include <coreplugin/inavigationwidgetfactory.h>
+
+namespace QodeAssist::Chat {
+
+class NavigationPanel : public Core::INavigationWidgetFactory
+{
+    Q_OBJECT
+public:
+    explicit NavigationPanel();
+    ~NavigationPanel();
+
+    Core::NavigationView createWidget() override;
+};
+
+}

core/ChangesManager.cpp

@@ -0,0 +1,82 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "ChangesManager.h"
+#include "settings/CodeCompletionSettings.hpp"
+
+namespace QodeAssist {
+
+ChangesManager &ChangesManager::instance()
+{
+    static ChangesManager instance;
+    return instance;
+}
+
+ChangesManager::ChangesManager()
+    : QObject(nullptr)
+{
+}
+
+ChangesManager::~ChangesManager()
+{
+}
+
+void ChangesManager::addChange(TextEditor::TextDocument *document,
+                               int position,
+                               int charsRemoved,
+                               int charsAdded)
+{
+    auto &documentQueue = m_documentChanges[document];
+
+    QTextBlock block = document->document()->findBlock(position);
+    int lineNumber = block.blockNumber();
+    QString lineContent = block.text();
+    QString fileName = document->filePath().fileName();
+
+    ChangeInfo change{fileName, lineNumber, lineContent};
+
+    auto it = std::find_if(documentQueue.begin(),
+                           documentQueue.end(),
+                           [lineNumber](const ChangeInfo &c) { return c.lineNumber == lineNumber; });
+
+    if (it != documentQueue.end()) {
+        it->lineContent = lineContent;
+    } else {
+        documentQueue.enqueue(change);
+
+        if (documentQueue.size() > Settings::codeCompletionSettings().maxChangesCacheSize()) {
+            documentQueue.dequeue();
+        }
+    }
+}
+
+QString ChangesManager::getRecentChangesContext(const TextEditor::TextDocument *currentDocument) const
+{
+    QString context;
+    for (auto it = m_documentChanges.constBegin(); it != m_documentChanges.constEnd(); ++it) {
+        if (it.key() != currentDocument) {
+            for (const auto &change : it.value()) {
+                context += change.lineContent + "\n";
+            }
+        }
+    }
+    return context;
+}
+
+} // namespace QodeAssist

core/ChangesManager.h

@@ -0,0 +1,61 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QDateTime>
+#include <QHash>
+#include <QQueue>
+#include <QTimer>
+#include <texteditor/textdocument.h>
+
+namespace QodeAssist {
+
+class ChangesManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    struct ChangeInfo
+    {
+        QString fileName;
+        int lineNumber;
+        QString lineContent;
+    };
+
+    static ChangesManager &instance();
+
+    void addChange(TextEditor::TextDocument *document,
+                   int position,
+                   int charsRemoved,
+                   int charsAdded);
+    QString getRecentChangesContext(const TextEditor::TextDocument *currentDocument) const;
+
+private:
+    ChangesManager();
+    ~ChangesManager();
+    ChangesManager(const ChangesManager &) = delete;
+    ChangesManager &operator=(const ChangesManager &) = delete;
+
+    void cleanupOldChanges();
+
+    QHash<TextEditor::TextDocument *, QQueue<ChangeInfo>> m_documentChanges;
+};
+
+} // namespace QodeAssist

llmcore/CMakeLists.txt

@@ -0,0 +1,23 @@
+add_library(LLMCore STATIC
+    RequestType.hpp
+    Provider.hpp
+    ProvidersManager.hpp ProvidersManager.cpp
+    ContextData.hpp
+    PromptTemplate.hpp
+    PromptTemplateManager.hpp PromptTemplateManager.cpp
+    RequestConfig.hpp
+    RequestHandler.hpp RequestHandler.cpp
+)
+
+target_link_libraries(LLMCore
+    PUBLIC
+    Qt::Core
+    Qt::Network
+    QtCreator::Core
+    QtCreator::Utils
+    QtCreator::ExtensionSystem
+    PRIVATE
+    QodeAssistLogger
+)
+
+target_include_directories(LLMCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

llmcore/ContextData.hpp

@@ -0,0 +1,33 @@
+/* 
+ * 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>
+
+namespace QodeAssist::LLMCore {
+
+struct ContextData
+{
+    QString prefix;
+    QString suffix;
+    QString fileContext;
+};
+
+} // namespace QodeAssist::LLMCore

llmcore/PromptTemplate.hpp

@@ -23,18 +23,21 @@
 #include <QList>
 #include <QString>
 
-namespace QodeAssist::Templates {
+#include "ContextData.hpp"
+
+namespace QodeAssist::LLMCore {
+
+enum class TemplateType { Chat, Fim };
 
 class PromptTemplate
 {
 public:
     virtual ~PromptTemplate() = default;
+    virtual TemplateType type() const = 0;
     virtual QString name() const = 0;
     virtual QString promptTemplate() const = 0;
     virtual QStringList stopWords() const = 0;
-    virtual void prepareRequest(QJsonObject &request,
-                                const QString &prefix,
-                                const QString &suffix) const
-        = 0;
+    virtual void prepareRequest(QJsonObject &request, const ContextData &context) const = 0;
+    virtual QString description() const = 0;
 };
-} // namespace QodeAssist::Templates
+} // namespace QodeAssist::LLMCore

llmcore/PromptTemplateManager.cpp

@@ -19,7 +19,7 @@
 
 #include "PromptTemplateManager.hpp"
 
-namespace QodeAssist {
+namespace QodeAssist::LLMCore {
 
 PromptTemplateManager &PromptTemplateManager::instance()
 {
@@ -27,27 +27,30 @@ PromptTemplateManager &PromptTemplateManager::instance()
     return instance;
 }
 
-void PromptTemplateManager::setCurrentTemplate(const QString &name)
+QStringList PromptTemplateManager::fimTemplatesNames() const
 {
-    if (m_templates.contains(name)) {
-        m_currentTemplateName = name;
-    }
+    return m_fimTemplates.keys();
 }
 
-const Templates::PromptTemplate *PromptTemplateManager::getCurrentTemplate() const
+QStringList PromptTemplateManager::chatTemplatesNames() const
 {
-    auto it = m_templates.find(m_currentTemplateName);
-    return it != m_templates.end() ? it.value() : nullptr;
-}
-
-QStringList PromptTemplateManager::getTemplateNames() const
-{
-    return m_templates.keys();
+    return m_chatTemplates.keys();
 }
 
 PromptTemplateManager::~PromptTemplateManager()
 {
-    qDeleteAll(m_templates);
+    qDeleteAll(m_fimTemplates);
+    qDeleteAll(m_chatTemplates);
 }
 
-} // namespace QodeAssist
+PromptTemplate *PromptTemplateManager::getFimTemplateByName(const QString &templateName)
+{
+    return m_fimTemplates[templateName];
+}
+
+PromptTemplate *PromptTemplateManager::getChatTemplateByName(const QString &templateName)
+{
+    return m_chatTemplates[templateName];
+}
+
+} // namespace QodeAssist::LLMCore

llmcore/PromptTemplateManager.hpp

@@ -22,38 +22,43 @@
 #include <QMap>
 #include <QString>
 
-#include "templates/PromptTemplate.hpp"
+#include "PromptTemplate.hpp"
 
-namespace QodeAssist {
+namespace QodeAssist::LLMCore {
 
 class PromptTemplateManager
 {
 public:
     static PromptTemplateManager &instance();
+    ~PromptTemplateManager();
 
     template<typename T>
     void registerTemplate()
     {
-        static_assert(std::is_base_of<Templates::PromptTemplate, T>::value,
+        static_assert(std::is_base_of<PromptTemplate, T>::value,
                       "T must inherit from PromptTemplate");
         T *template_ptr = new T();
         QString name = template_ptr->name();
-        m_templates[name] = template_ptr;
+        if (template_ptr->type() == TemplateType::Fim) {
+            m_fimTemplates[name] = template_ptr;
+        } else if (template_ptr->type() == TemplateType::Chat) {
+            m_chatTemplates[name] = template_ptr;
+        }
     }
 
-    void setCurrentTemplate(const QString &name);
-    const Templates::PromptTemplate *getCurrentTemplate() const;
-    QStringList getTemplateNames() const;
+    PromptTemplate *getFimTemplateByName(const QString &templateName);
+    PromptTemplate *getChatTemplateByName(const QString &templateName);
 
-    ~PromptTemplateManager();
+    QStringList fimTemplatesNames() const;
+    QStringList chatTemplatesNames() const;
 
 private:
     PromptTemplateManager() = default;
     PromptTemplateManager(const PromptTemplateManager &) = delete;
     PromptTemplateManager &operator=(const PromptTemplateManager &) = delete;
 
-    QMap<QString, Templates::PromptTemplate *> m_templates;
-    QString m_currentTemplateName;
+    QMap<QString, PromptTemplate *> m_fimTemplates;
+    QMap<QString, PromptTemplate *> m_chatTemplates;
 };
 
-} // namespace QodeAssist
+} // namespace QodeAssist::LLMCore

llmcore/Provider.hpp

@@ -20,26 +20,28 @@
 #pragma once
 
 #include <QString>
+#include "RequestType.hpp"
 #include <utils/environment.h>
 
 class QNetworkReply;
 class QJsonObject;
 
-namespace QodeAssist::Providers {
+namespace QodeAssist::LLMCore {
 
-class LLMProvider
+class Provider
 {
 public:
-    virtual ~LLMProvider() = default;
+    virtual ~Provider() = default;
 
     virtual QString name() const = 0;
     virtual QString url() const = 0;
-    virtual int defaultPort() const = 0;
     virtual QString completionEndpoint() const = 0;
+    virtual QString chatEndpoint() const = 0;
+    virtual bool supportsModelListing() const = 0;
 
-    virtual void prepareRequest(QJsonObject &request) = 0;
+    virtual void prepareRequest(QJsonObject &request, RequestType type) = 0;
     virtual bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) = 0;
-    virtual QList<QString> getInstalledModels(const Utils::Environment &env) = 0;
+    virtual QList<QString> getInstalledModels(const QString &url) = 0;
 };
 
-} // namespace QodeAssist::Providers
+} // namespace QodeAssist::LLMCore

llmcore/ProvidersManager.cpp

@@ -17,40 +17,29 @@
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
  */
 
-#include "LLMProvidersManager.hpp"
+#include "ProvidersManager.hpp"
 
-namespace QodeAssist {
+namespace QodeAssist::LLMCore {
 
-LLMProvidersManager &LLMProvidersManager::instance()
+ProvidersManager &ProvidersManager::instance()
 {
-    static LLMProvidersManager instance;
+    static ProvidersManager instance;
     return instance;
 }
 
-QStringList LLMProvidersManager::getProviderNames() const
+QStringList ProvidersManager::providersNames() 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()
+ProvidersManager::~ProvidersManager()
 {
     qDeleteAll(m_providers);
 }
 
-} // namespace QodeAssist
+Provider *ProvidersManager::getProviderByName(const QString &providerName)
+{
+    return m_providers[providerName];
+}
+
+} // namespace QodeAssist::LLMCore

llmcore/ProvidersManager.hpp

@@ -21,38 +21,36 @@
 
 #include <QString>
 
-#include "providers/LLMProvider.hpp"
+#include <QMap>
+#include "Provider.hpp"
 
-namespace QodeAssist {
+namespace QodeAssist::LLMCore {
 
-class LLMProvidersManager
+class ProvidersManager
 {
 public:
-    static LLMProvidersManager &instance();
+    static ProvidersManager &instance();
+    ~ProvidersManager();
 
     template<typename T>
     void registerProvider()
     {
-        static_assert(std::is_base_of<Providers::LLMProvider, T>::value,
-                      "T must inherit from LLMProvider");
+        static_assert(std::is_base_of<Provider, T>::value, "T must inherit from Provider");
         T *provider = new T();
         QString name = provider->name();
         m_providers[name] = provider;
     }
 
-    QStringList getProviderNames() const;
-    void setCurrentProvider(const QString &name);
-    Providers::LLMProvider *getCurrentProvider();
+    Provider *getProviderByName(const QString &providerName);
 
-    ~LLMProvidersManager();
+    QStringList providersNames() const;
 
 private:
-    LLMProvidersManager() = default;
-    LLMProvidersManager(const LLMProvidersManager &) = delete;
-    LLMProvidersManager &operator=(const LLMProvidersManager &) = delete;
+    ProvidersManager() = default;
+    ProvidersManager(const ProvidersManager &) = delete;
+    ProvidersManager &operator=(const ProvidersManager &) = delete;
 
-    QMap<QString, Providers::LLMProvider *> m_providers;
-    QString m_currentProviderName;
+    QMap<QString, Provider *> m_providers;
 };
 
-} // namespace QodeAssist
+} // namespace QodeAssist::LLMCore

llmcore/RequestConfig.hpp

@@ -0,0 +1,41 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QJsonObject>
+#include <QUrl>
+#include "PromptTemplate.hpp"
+#include "Provider.hpp"
+#include "RequestType.hpp"
+
+namespace QodeAssist::LLMCore {
+
+struct LLMConfig
+{
+    QUrl url;
+    Provider *provider;
+    PromptTemplate *promptTemplate;
+    QJsonObject providerRequest;
+    RequestType requestType;
+    bool multiLineCompletion;
+    QString apiKey;
+};
+
+} // namespace QodeAssist::LLMCore

llmcore/RequestHandler.cpp

@@ -0,0 +1,185 @@
+/* 
+ * 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 "RequestHandler.hpp"
+#include "Logger.hpp"
+
+#include <QJsonDocument>
+#include <QNetworkReply>
+
+namespace QodeAssist::LLMCore {
+
+RequestHandler::RequestHandler(QObject *parent)
+    : QObject(parent)
+    , m_manager(new QNetworkAccessManager(this))
+{}
+
+void RequestHandler::sendLLMRequest(const LLMConfig &config, const QJsonObject &request)
+{
+    LOG_MESSAGE(QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
+                   .arg(config.url.toString(),
+                        QString::fromUtf8(
+                            QJsonDocument(config.providerRequest).toJson(QJsonDocument::Indented))));
+
+    QNetworkRequest networkRequest(config.url);
+    if (!config.apiKey.isEmpty())
+        prepareNetworkRequest(networkRequest, config.apiKey);
+
+    QNetworkReply *reply = m_manager->post(networkRequest,
+                                           QJsonDocument(config.providerRequest).toJson());
+    if (!reply) {
+        LOG_MESSAGE("Error: Failed to create network reply");
+        return;
+    }
+
+    QString requestId = request["id"].toString();
+    m_activeRequests[requestId] = reply;
+
+    connect(reply, &QNetworkReply::readyRead, this, [this, reply, request, config]() {
+        handleLLMResponse(reply, request, config);
+    });
+
+    connect(reply, &QNetworkReply::finished, this, [this, reply, requestId]() {
+        reply->deleteLater();
+        m_activeRequests.remove(requestId);
+        if (reply->error() != QNetworkReply::NoError) {
+            LOG_MESSAGE(QString("Error in QodeAssist request: %1").arg(reply->errorString()));
+            emit requestFinished(requestId, false, reply->errorString());
+        } else {
+            LOG_MESSAGE("Request finished successfully");
+            emit requestFinished(requestId, true, QString());
+        }
+    });
+}
+
+void RequestHandler::handleLLMResponse(QNetworkReply *reply,
+                                       const QJsonObject &request,
+                                       const LLMConfig &config)
+{
+    QString &accumulatedResponse = m_accumulatedResponses[reply];
+
+    bool isComplete = config.provider->handleResponse(reply, accumulatedResponse);
+
+    if (config.requestType == RequestType::Fim) {
+        if (!config.multiLineCompletion
+            && processSingleLineCompletion(reply, request, accumulatedResponse, config)) {
+            return;
+        }
+
+        if (isComplete) {
+            auto cleanedCompletion = removeStopWords(accumulatedResponse,
+                                                     config.promptTemplate->stopWords());
+            removeCodeBlockWrappers(cleanedCompletion);
+
+            emit completionReceived(cleanedCompletion, request, true);
+        }
+    } else if (config.requestType == RequestType::Chat) {
+        emit completionReceived(accumulatedResponse, request, isComplete);
+    }
+
+    if (isComplete)
+        m_accumulatedResponses.remove(reply);
+}
+
+bool RequestHandler::cancelRequest(const QString &id)
+{
+    if (m_activeRequests.contains(id)) {
+        QNetworkReply *reply = m_activeRequests[id];
+        reply->abort();
+        m_activeRequests.remove(id);
+        m_accumulatedResponses.remove(reply);
+        emit requestCancelled(id);
+        return true;
+    }
+    return false;
+}
+
+void RequestHandler::prepareNetworkRequest(
+    QNetworkRequest &networkRequest, const QString &apiKey) const
+{
+    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey).toUtf8());
+}
+
+bool RequestHandler::processSingleLineCompletion(
+    QNetworkReply *reply,
+    const QJsonObject &request,
+    const QString &accumulatedResponse,
+    const LLMConfig &config)
+{
+    QString cleanedResponse = accumulatedResponse;
+    removeCodeBlockWrappers(cleanedResponse);
+
+    int newlinePos = cleanedResponse.indexOf('\n');
+    if (newlinePos != -1) {
+        QString singleLineCompletion = cleanedResponse.left(newlinePos).trimmed();
+        singleLineCompletion
+            = removeStopWords(singleLineCompletion, config.promptTemplate->stopWords());
+        emit completionReceived(singleLineCompletion, request, true);
+        m_accumulatedResponses.remove(reply);
+        reply->abort();
+        return true;
+    }
+    return false;
+}
+
+QString RequestHandler::removeStopWords(const QStringView &completion, const QStringList &stopWords)
+{
+    QString filteredCompletion = completion.toString();
+
+    for (const QString &stopWord : stopWords) {
+        filteredCompletion = filteredCompletion.replace(stopWord, "");
+    }
+
+    return filteredCompletion;
+}
+
+void RequestHandler::removeCodeBlockWrappers(QString &response)
+{
+    static const QRegularExpression
+        fullCodeBlockRegex(R"(```[\w\s]*\n([\s\S]*?)```)", QRegularExpression::MultilineOption);
+    static const QRegularExpression
+        partialStartBlockRegex(R"(```[\w\s]*\n([\s\S]*?)$)", QRegularExpression::MultilineOption);
+    static const QRegularExpression
+        partialEndBlockRegex(R"(^([\s\S]*?)```)", QRegularExpression::MultilineOption);
+
+    QRegularExpressionMatchIterator matchIterator = fullCodeBlockRegex.globalMatch(response);
+    while (matchIterator.hasNext()) {
+        QRegularExpressionMatch match = matchIterator.next();
+        QString codeBlock = match.captured(0);
+        QString codeContent = match.captured(1).trimmed();
+        response.replace(codeBlock, codeContent);
+    }
+
+    QRegularExpressionMatch startMatch = partialStartBlockRegex.match(response);
+    if (startMatch.hasMatch()) {
+        QString partialBlock = startMatch.captured(0);
+        QString codeContent = startMatch.captured(1).trimmed();
+        response.replace(partialBlock, codeContent);
+    }
+
+    QRegularExpressionMatch endMatch = partialEndBlockRegex.match(response);
+    if (endMatch.hasMatch()) {
+        QString partialBlock = endMatch.captured(0);
+        QString codeContent = endMatch.captured(1).trimmed();
+        response.replace(partialBlock, codeContent);
+    }
+}
+
+} // namespace QodeAssist::LLMCore

llmcore/RequestHandler.hpp

@@ -0,0 +1,64 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QJsonObject>
+#include <QNetworkAccessManager>
+#include <QObject>
+
+#include "RequestConfig.hpp"
+
+class QNetworkReply;
+
+namespace QodeAssist::LLMCore {
+
+class RequestHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit RequestHandler(QObject *parent = nullptr);
+
+    void sendLLMRequest(const LLMConfig &config, const QJsonObject &request);
+    void handleLLMResponse(QNetworkReply *reply,
+                           const QJsonObject &request,
+                           const LLMConfig &config);
+    bool cancelRequest(const QString &id);
+
+signals:
+    void completionReceived(const QString &completion, const QJsonObject &request, bool isComplete);
+    void requestFinished(const QString &requestId, bool success, const QString &errorString);
+    void requestCancelled(const QString &id);
+
+private:
+    QNetworkAccessManager *m_manager;
+    QMap<QString, QNetworkReply *> m_activeRequests;
+    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+
+    void prepareNetworkRequest(QNetworkRequest &networkRequest, const QString &apiKey) const;
+    bool processSingleLineCompletion(QNetworkReply *reply,
+                                     const QJsonObject &request,
+                                     const QString &accumulatedResponse,
+                                     const LLMConfig &config);
+    QString removeStopWords(const QStringView &completion, const QStringList &stopWords);
+    void removeCodeBlockWrappers(QString &response);
+};
+
+} // namespace QodeAssist::LLMCore

llmcore/RequestType.hpp

@@ -0,0 +1,25 @@
+/* 
+ * 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::LLMCore {
+
+enum RequestType { Fim, Chat };
+}

logger/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_library(QodeAssistLogger STATIC
+    Logger.cpp
+    Logger.hpp
+)
+
+target_link_libraries(QodeAssistLogger
+    PUBLIC
+    Qt::Core
+    QtCreator::Core
+)
+
+target_include_directories(QodeAssistLogger
+    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
+)

logger/Logger.cpp

@@ -0,0 +1,55 @@
+#include "Logger.hpp"
+#include <coreplugin/messagemanager.h>
+
+namespace QodeAssist {
+
+Logger &Logger::instance()
+{
+    static Logger instance;
+    return instance;
+}
+
+Logger::Logger()
+    : m_loggingEnabled(false)
+{}
+
+void Logger::setLoggingEnabled(bool enable)
+{
+    m_loggingEnabled = enable;
+}
+
+bool Logger::isLoggingEnabled() const
+{
+    return m_loggingEnabled;
+}
+
+void Logger::log(const QString &message, bool silent)
+{
+    if (!m_loggingEnabled)
+        return;
+
+    const QString prefixedMessage = QLatin1String("[Qode Assist] ") + message;
+    if (silent) {
+        Core::MessageManager::writeSilently(prefixedMessage);
+    } else {
+        Core::MessageManager::writeFlashing(prefixedMessage);
+    }
+}
+
+void Logger::logMessages(const QStringList &messages, bool silent)
+{
+    if (!m_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

logger/Logger.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <QObject>
+#include <QString>
+
+namespace QodeAssist {
+
+class Logger : public QObject
+{
+    Q_OBJECT
+
+public:
+    static Logger &instance();
+
+    void setLoggingEnabled(bool enable);
+    bool isLoggingEnabled() const;
+
+    void log(const QString &message, bool silent = true);
+    void logMessages(const QStringList &messages, bool silent = true);
+
+private:
+    Logger();
+    ~Logger() = default;
+    Logger(const Logger &) = delete;
+    Logger &operator=(const Logger &) = delete;
+
+    bool m_loggingEnabled;
+};
+
+#define LOG_MESSAGE(msg) QodeAssist::Logger::instance().log(msg)
+#define LOG_MESSAGES(msgs) QodeAssist::Logger::instance().logMessages(msgs)
+
+} // namespace QodeAssist

providers/LMStudioProvider.cpp

@@ -19,14 +19,15 @@
 
 #include "LMStudioProvider.hpp"
 
+#include <QEventLoop>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QNetworkReply>
-#include <QProcess>
 
-#include "PromptTemplateManager.hpp"
-#include "QodeAssistSettings.hpp"
+#include "logger/Logger.hpp"
+#include "settings/ChatAssistantSettings.hpp"
+#include "settings/CodeCompletionSettings.hpp"
 
 namespace QodeAssist::Providers {
 
@@ -39,12 +40,7 @@ QString LMStudioProvider::name() const
 
 QString LMStudioProvider::url() const
 {
-    return "http://localhost";
-}
-
-int LMStudioProvider::defaultPort() const
-{
-    return 1234;
+    return "http://localhost:1234";
 }
 
 QString LMStudioProvider::completionEndpoint() const
@@ -52,27 +48,55 @@ QString LMStudioProvider::completionEndpoint() const
     return "/v1/chat/completions";
 }
 
-void LMStudioProvider::prepareRequest(QJsonObject &request)
+QString LMStudioProvider::chatEndpoint() const
 {
-    const auto &currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+    return "/v1/chat/completions";
+}
 
-    if (request.contains("prompt")) {
-        QJsonArray messages{
-            {QJsonObject{{"role", "user"}, {"content", request.take("prompt").toString()}}}};
+bool LMStudioProvider::supportsModelListing() const
+{
+    return true;
+}
+
+void LMStudioProvider::prepareRequest(QJsonObject &request, LLMCore::RequestType type)
+{
+    auto prepareMessages = [](QJsonObject &req) -> QJsonArray {
+        QJsonArray messages;
+        if (req.contains("system")) {
+            messages.append(
+                QJsonObject{{"role", "system"}, {"content", req.take("system").toString()}});
+        }
+        if (req.contains("prompt")) {
+            messages.append(
+                QJsonObject{{"role", "user"}, {"content", req.take("prompt").toString()}});
+        }
+        return messages;
+    };
+
+    auto applyModelParams = [&request](const auto &settings) {
+        request["max_tokens"] = settings.maxTokens();
+        request["temperature"] = settings.temperature();
+
+        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();
+    };
+
+    QJsonArray messages = prepareMessages(request);
+    if (!messages.isEmpty()) {
         request["messages"] = std::move(messages);
     }
 
-    request["max_tokens"] = settings().maxTokens();
-    request["temperature"] = settings().temperature();
-    request["stop"] = QJsonArray::fromStringList(currentTemplate->stopWords());
-    if (settings().useTopP())
-        request["top_p"] = settings().topP();
-    if (settings().useTopK())
-        request["top_k"] = settings().topK();
-    if (settings().useFrequencyPenalty())
-        request["frequency_penalty"] = settings().frequencyPenalty();
-    if (settings().usePresencePenalty())
-        request["presence_penalty"] = settings().presencePenalty();
+    if (type == LLMCore::RequestType::Fim) {
+        applyModelParams(Settings::codeCompletionSettings());
+    } else {
+        applyModelParams(Settings::chatAssistantSettings());
+    }
 }
 
 bool LMStudioProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
@@ -116,55 +140,34 @@ bool LMStudioProvider::handleResponse(QNetworkReply *reply, QString &accumulated
     return isComplete;
 }
 
-QList<QString> LMStudioProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> LMStudioProvider::getInstalledModels(const QString &url)
 {
-    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();
+    QList<QString> models;
+    QNetworkAccessManager manager;
+    QNetworkRequest request(QString("%1%2").arg(url, "/v1/models"));
 
-    if (!QFileInfo::exists(lmsPath)) {
-        qWarning() << "LMS executable not found at" << lmsPath;
-        return {};
-    }
+    QNetworkReply *reply = manager.get(request);
 
-    process.start(lmsPath, QStringList() << "ls");
-    if (!process.waitForStarted()) {
-        qWarning() << "Failed to start LMS process:" << process.errorString();
-        return {};
-    }
+    QEventLoop loop;
+    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    loop.exec();
 
-    if (!process.waitForFinished()) {
-        qWarning() << "LMS process did not finish:" << process.errorString();
-        return {};
-    }
+    if (reply->error() == QNetworkReply::NoError) {
+        QByteArray responseData = reply->readAll();
+        QJsonDocument jsonResponse = QJsonDocument::fromJson(responseData);
+        QJsonObject jsonObject = jsonResponse.object();
+        QJsonArray modelArray = jsonObject["data"].toArray();
 
-    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);
-            }
+        for (const QJsonValue &value : modelArray) {
+            QJsonObject modelObject = value.toObject();
+            QString modelId = modelObject["id"].toString();
+            models.append(modelId);
         }
-        qDebug() << "Models:" << models;
     } else {
-        // Handle error
-        qWarning() << "Error running 'lms list':" << process.errorString();
+        LOG_MESSAGE(QString("Error fetching models: %1").arg(reply->errorString()));
     }
 
+    reply->deleteLater();
     return models;
 }
 

providers/LMStudioProvider.hpp

@@ -19,22 +19,23 @@
 
 #pragma once
 
-#include "LLMProvider.hpp"
+#include "llmcore/Provider.hpp"
 
 namespace QodeAssist::Providers {
 
-class LMStudioProvider : public LLMProvider
+class LMStudioProvider : public LLMCore::Provider
 {
 public:
     LMStudioProvider();
 
     QString name() const override;
     QString url() const override;
-    int defaultPort() const override;
     QString completionEndpoint() const override;
-    void prepareRequest(QJsonObject &request) override;
+    QString chatEndpoint() const override;
+    bool supportsModelListing() const override;
+    void prepareRequest(QJsonObject &request, LLMCore::RequestType type) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

providers/OllamaProvider.cpp

@@ -23,10 +23,11 @@
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QNetworkReply>
-#include <QProcess>
+#include <QtCore/qeventloop.h>
 
-#include "PromptTemplateManager.hpp"
-#include "QodeAssistSettings.hpp"
+#include "logger/Logger.hpp"
+#include "settings/ChatAssistantSettings.hpp"
+#include "settings/CodeCompletionSettings.hpp"
 
 namespace QodeAssist::Providers {
 
@@ -39,12 +40,7 @@ QString OllamaProvider::name() const
 
 QString OllamaProvider::url() const
 {
-    return "http://localhost";
-}
-
-int OllamaProvider::defaultPort() const
-{
-    return 11434;
+    return "http://localhost:11434";
 }
 
 QString OllamaProvider::completionEndpoint() const
@@ -52,99 +48,121 @@ QString OllamaProvider::completionEndpoint() const
     return "/api/generate";
 }
 
-void OllamaProvider::prepareRequest(QJsonObject &request)
+QString OllamaProvider::chatEndpoint() const
 {
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+    return "/api/chat";
+}
 
-    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::supportsModelListing() const
+{
+    return true;
+}
+
+void OllamaProvider::prepareRequest(QJsonObject &request, LLMCore::RequestType type)
+{
+    auto applySettings = [&request](const auto &settings) {
+        QJsonObject options;
+        options["num_predict"] = settings.maxTokens();
+        options["temperature"] = settings.temperature();
+
+        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;
+        request["keep_alive"] = settings.ollamaLivetime();
+    };
+
+    if (type == LLMCore::RequestType::Fim) {
+        applySettings(Settings::codeCompletionSettings());
+    } else {
+        applySettings(Settings::chatAssistantSettings());
+    }
 }
 
 bool OllamaProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
 {
+    QString endpoint = reply->url().path();
+
     bool isComplete = false;
     while (reply->canReadLine()) {
         QByteArray line = reply->readLine().trimmed();
         if (line.isEmpty()) {
             continue;
         }
-        QJsonDocument jsonResponse = QJsonDocument::fromJson(line);
-        if (jsonResponse.isNull()) {
-            qWarning() << "Invalid JSON response from Ollama:" << line;
+
+        QJsonDocument doc = QJsonDocument::fromJson(line);
+        if (doc.isNull()) {
+            LOG_MESSAGE("Invalid JSON response from Ollama: " + QString::fromUtf8(line));
             continue;
         }
-        QJsonObject responseObj = jsonResponse.object();
-        if (responseObj.contains("response")) {
-            QString completion = responseObj["response"].toString();
 
-            accumulatedResponse += completion;
+        QJsonObject responseObj = doc.object();
+
+        if (responseObj.contains("error")) {
+            QString errorMessage = responseObj["error"].toString();
+            LOG_MESSAGE("Error in Ollama response: " + errorMessage);
+            return false;
         }
-        if (responseObj["done"].toBool()) {
+
+        if (endpoint == completionEndpoint()) {
+            if (responseObj.contains("response")) {
+                QString completion = responseObj["response"].toString();
+                accumulatedResponse += completion;
+            }
+        } else if (endpoint == chatEndpoint()) {
+            if (responseObj.contains("message")) {
+                QJsonObject message = responseObj["message"].toObject();
+                if (message.contains("content")) {
+                    QString content = message["content"].toString();
+                    accumulatedResponse += content;
+                }
+            }
+        } else {
+            LOG_MESSAGE("Unknown endpoint: " + endpoint);
+        }
+
+        if (responseObj.contains("done") && responseObj["done"].toBool()) {
             isComplete = true;
             break;
         }
     }
+
     return isComplete;
 }
 
-QList<QString> OllamaProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> OllamaProvider::getInstalledModels(const QString &url)
 {
-    QProcess process;
-    process.setEnvironment(env.toStringList());
-    QString ollamaConsoleName;
-#ifdef Q_OS_WIN
-    ollamaConsoleName = "ollama.exe";
-#else
-    ollamaConsoleName = "ollama";
-#endif
+    QList<QString> models;
+    QNetworkAccessManager manager;
+    QNetworkRequest request(QString("%1%2").arg(url, "/api/tags"));
+    QNetworkReply *reply = manager.get(request);
 
-    auto ollamaPath = env.searchInPath(ollamaConsoleName).toString();
+    QEventLoop loop;
+    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    loop.exec();
 
-    if (!QFileInfo::exists(ollamaPath)) {
-        qWarning() << "Ollama executable not found at" << ollamaPath;
-        return {};
-    }
+    if (reply->error() == QNetworkReply::NoError) {
+        QByteArray responseData = reply->readAll();
+        QJsonDocument jsonResponse = QJsonDocument::fromJson(responseData);
+        QJsonObject jsonObject = jsonResponse.object();
+        QJsonArray modelArray = jsonObject["models"].toArray();
 
-    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);
-            }
+        for (const QJsonValue &value : modelArray) {
+            QJsonObject modelObject = value.toObject();
+            QString modelName = modelObject["name"].toString();
+            models.append(modelName);
         }
     } else {
-        qWarning() << "Error running 'ollama list':" << process.errorString();
+        LOG_MESSAGE(QString("Error fetching models: %1").arg(reply->errorString()));
     }
 
+    reply->deleteLater();
     return models;
 }
 

providers/OllamaProvider.hpp

@@ -19,22 +19,23 @@
 
 #pragma once
 
-#include "LLMProvider.hpp"
+#include "llmcore/Provider.hpp"
 
 namespace QodeAssist::Providers {
 
-class OllamaProvider : public LLMProvider
+class OllamaProvider : public LLMCore::Provider
 {
 public:
     OllamaProvider();
 
     QString name() const override;
     QString url() const override;
-    int defaultPort() const override;
     QString completionEndpoint() const override;
-    void prepareRequest(QJsonObject &request) override;
+    QString chatEndpoint() const override;
+    bool supportsModelListing() const override;
+    void prepareRequest(QJsonObject &request, LLMCore::RequestType type) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

providers/OpenAICompatProvider.cpp

@@ -17,16 +17,16 @@
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
  */
 
-#include "OpenAICompatProvider.h"
+#include "OpenAICompatProvider.hpp"
+#include "settings/ChatAssistantSettings.hpp"
+#include "settings/CodeCompletionSettings.hpp"
 
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QNetworkReply>
-#include <QProcess>
 
-#include "PromptTemplateManager.hpp"
-#include "QodeAssistSettings.hpp"
+#include "logger/Logger.hpp"
 
 namespace QodeAssist::Providers {
 
@@ -34,17 +34,12 @@ OpenAICompatProvider::OpenAICompatProvider() {}
 
 QString OpenAICompatProvider::name() const
 {
-    return "OpenAI Compatible (experimental)";
+    return "OpenAI Compatible";
 }
 
 QString OpenAICompatProvider::url() const
 {
-    return "http://localhost";
-}
-
-int OpenAICompatProvider::defaultPort() const
-{
-    return 1234;
+    return "http://localhost:1234";
 }
 
 QString OpenAICompatProvider::completionEndpoint() const
@@ -52,55 +47,95 @@ QString OpenAICompatProvider::completionEndpoint() const
     return "/v1/chat/completions";
 }
 
-void OpenAICompatProvider::prepareRequest(QJsonObject &request)
+QString OpenAICompatProvider::chatEndpoint() const
 {
-    const auto &currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
+    return "/v1/chat/completions";
+}
 
-    if (request.contains("prompt")) {
-        QJsonArray messages{
-            {QJsonObject{{"role", "user"}, {"content", request.take("prompt").toString()}}}};
+bool OpenAICompatProvider::supportsModelListing() const
+{
+    return false;
+}
+
+void OpenAICompatProvider::prepareRequest(QJsonObject &request, LLMCore::RequestType type)
+{
+    auto prepareMessages = [](QJsonObject &req) -> QJsonArray {
+        QJsonArray messages;
+        if (req.contains("system")) {
+            messages.append(
+                QJsonObject{{"role", "system"}, {"content", req.take("system").toString()}});
+        }
+        if (req.contains("prompt")) {
+            messages.append(
+                QJsonObject{{"role", "user"}, {"content", req.take("prompt").toString()}});
+        }
+        return messages;
+    };
+
+    auto applyModelParams = [&request](const auto &settings) {
+        request["max_tokens"] = settings.maxTokens();
+        request["temperature"] = settings.temperature();
+
+        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();
+    };
+
+    QJsonArray messages = prepareMessages(request);
+    if (!messages.isEmpty()) {
         request["messages"] = std::move(messages);
     }
 
-    request["max_tokens"] = settings().maxTokens();
-    request["temperature"] = settings().temperature();
-    request["stop"] = QJsonArray::fromStringList(currentTemplate->stopWords());
-    if (settings().useTopP())
-        request["top_p"] = settings().topP();
-    if (settings().useTopK())
-        request["top_k"] = settings().topK();
-    if (settings().useFrequencyPenalty())
-        request["frequency_penalty"] = settings().frequencyPenalty();
-    if (settings().usePresencePenalty())
-        request["presence_penalty"] = settings().presencePenalty();
-
-    const QString &apiKey = settings().apiKey.value();
-    if (!apiKey.isEmpty()) {
-        request["api_key"] = apiKey;
+    if (type == LLMCore::RequestType::Fim) {
+        applyModelParams(Settings::codeCompletionSettings());
+    } else {
+        applyModelParams(Settings::chatAssistantSettings());
     }
 }
 
 bool OpenAICompatProvider::handleResponse(QNetworkReply *reply, QString &accumulatedResponse)
 {
     bool isComplete = false;
+    QString tempResponse = accumulatedResponse;
+
     while (reply->canReadLine()) {
         QByteArray line = reply->readLine().trimmed();
         if (line.isEmpty()) {
             continue;
         }
-        if (line == "data: [DONE]") {
+
+        if (!line.startsWith("data:")) {
+            continue;
+        }
+
+        line = line.mid(6);
+
+        if (line == "[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;
+            LOG_MESSAGE(
+                "Invalid JSON response from OpenAI compatible provider: " + QString::fromUtf8(line));
             continue;
         }
+
         QJsonObject responseObj = jsonResponse.object();
+
+        if (responseObj.contains("error")) {
+            LOG_MESSAGE(
+                "OpenAI compatible provider error: "
+                + QString::fromUtf8(QJsonDocument(responseObj).toJson(QJsonDocument::Indented)));
+            return false;
+        }
+
         if (responseObj.contains("choices")) {
             QJsonArray choices = responseObj["choices"].toArray();
             if (!choices.isEmpty()) {
@@ -108,20 +143,34 @@ bool OpenAICompatProvider::handleResponse(QNetworkReply *reply, QString &accumul
                 QJsonObject delta = choice["delta"].toObject();
                 if (delta.contains("content")) {
                     QString completion = delta["content"].toString();
-
-                    accumulatedResponse += completion;
+                    if (!completion.isEmpty()) {
+                        tempResponse += completion;
+                    }
                 }
-                if (choice["finish_reason"].toString() == "stop") {
+                QString finishReason = choice["finish_reason"].toString();
+                if (!finishReason.isNull() && finishReason == "stop") {
                     isComplete = true;
-                    break;
                 }
             }
         }
+
+        if (responseObj.contains("usage")) {
+            QJsonObject usage = responseObj["usage"].toObject();
+            LOG_MESSAGE(QString("Token usage - Prompt: %1, Completion: %2, Total: %3")
+                            .arg(usage["prompt_tokens"].toInt())
+                            .arg(usage["completion_tokens"].toInt())
+                            .arg(usage["total_tokens"].toInt()));
+        }
     }
+
+    if (!tempResponse.isEmpty()) {
+        accumulatedResponse = tempResponse;
+    }
+
     return isComplete;
 }
 
-QList<QString> OpenAICompatProvider::getInstalledModels(const Utils::Environment &env)
+QList<QString> OpenAICompatProvider::getInstalledModels(const QString &url)
 {
     return QStringList();
 }

providers/OpenAICompatProvider.hpp

@@ -19,22 +19,23 @@
 
 #pragma once
 
-#include "LLMProvider.hpp"
+#include "llmcore/Provider.hpp"
 
 namespace QodeAssist::Providers {
 
-class OpenAICompatProvider : public LLMProvider
+class OpenAICompatProvider : public LLMCore::Provider
 {
 public:
     OpenAICompatProvider();
 
     QString name() const override;
     QString url() const override;
-    int defaultPort() const override;
     QString completionEndpoint() const override;
-    void prepareRequest(QJsonObject &request) override;
+    QString chatEndpoint() const override;
+    bool supportsModelListing() const override;
+    void prepareRequest(QJsonObject &request, LLMCore::RequestType type) override;
     bool handleResponse(QNetworkReply *reply, QString &accumulatedResponse) override;
-    QList<QString> getInstalledModels(const Utils::Environment &env) override;
+    QList<QString> getInstalledModels(const QString &url) override;
 };
 
 } // namespace QodeAssist::Providers

providers/Providers.hpp

@@ -0,0 +1,37 @@
+/* 
+ * 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 "llmcore/ProvidersManager.hpp"
+#include "providers/LMStudioProvider.hpp"
+#include "providers/OllamaProvider.hpp"
+#include "providers/OpenAICompatProvider.hpp"
+
+namespace QodeAssist::Providers {
+
+inline void registerProviders()
+{
+    auto &providerManager = LLMCore::ProvidersManager::instance();
+    providerManager.registerProvider<OllamaProvider>();
+    providerManager.registerProvider<LMStudioProvider>();
+    providerManager.registerProvider<OpenAICompatProvider>();
+}
+
+} // namespace QodeAssist::Providers

qodeassist.cpp

@@ -26,8 +26,9 @@
 #include <coreplugin/coreconstants.h>
 #include <coreplugin/icontext.h>
 #include <coreplugin/icore.h>
+#include <coreplugin/messagemanager.h>
+#include <coreplugin/modemanager.h>
 #include <coreplugin/statusbarmanager.h>
-
 #include <extensionsystem/iplugin.h>
 #include <languageclient/languageclientmanager.h>
 
@@ -38,15 +39,13 @@
 #include <texteditor/texteditor.h>
 #include <utils/icon.h>
 
-#include "LLMProvidersManager.hpp"
-#include "PromptTemplateManager.hpp"
+#include "ConfigurationManager.hpp"
 #include "QodeAssistClient.hpp"
-#include "providers/LMStudioProvider.hpp"
-#include "providers/OllamaProvider.hpp"
-#include "providers/OpenAICompatProvider.h"
-#include "templates/CodeLLamaTemplate.hpp"
-#include "templates/CodeQwenChat.hpp"
-#include "templates/StarCoder2Template.hpp"
+#include "chat/ChatOutputPane.h"
+#include "chat/NavigationPanel.hpp"
+
+#include "providers/Providers.hpp"
+#include "templates/Templates.hpp"
 
 using namespace Utils;
 using namespace Core;
@@ -66,20 +65,15 @@ public:
 
     ~QodeAssistPlugin() final
     {
-
+        delete m_qodeAssistClient;
+        delete m_chatOutputPane;
+        delete m_navigationPanel;
     }
 
     void initialize() final
     {
-        auto &providerManager = LLMProvidersManager::instance();
-        providerManager.registerProvider<Providers::OllamaProvider>();
-        providerManager.registerProvider<Providers::LMStudioProvider>();
-        providerManager.registerProvider<Providers::OpenAICompatProvider>();
-
-        auto &templateManager = PromptTemplateManager::instance();
-        templateManager.registerTemplate<Templates::CodeLLamaTemplate>();
-        templateManager.registerTemplate<Templates::StarCoder2Template>();
-        templateManager.registerTemplate<Templates::CodeQwenChatTemplate>();
+        Providers::registerProviders();
+        Templates::registerTemplates();
 
         Utils::Icon QCODEASSIST_ICON(
             {{":/resources/images/qoderassist-icon.png", Utils::Theme::IconsBaseColor}});
@@ -104,6 +98,11 @@ public:
         auto toggleButton = new QToolButton;
         toggleButton->setDefaultAction(requestAction.contextAction());
         StatusBarManager::addStatusBarWidget(toggleButton, StatusBarManager::RightCorner);
+
+        m_chatOutputPane = new Chat::ChatOutputPane(this);
+        m_navigationPanel = new Chat::NavigationPanel();
+
+        ConfigurationManager::instance().init();
     }
 
     void extensionsInitialized() final
@@ -137,6 +136,8 @@ public:
 
 private:
     QPointer<QodeAssistClient> m_qodeAssistClient;
+    QPointer<Chat::ChatOutputPane> m_chatOutputPane;
+    QPointer<Chat::NavigationPanel> m_navigationPanel;
 };
 
 } // namespace QodeAssist::Internal

rawPromptExamples/OllamaStarCoder2FIM.json

@@ -0,0 +1,19 @@
+{
+  "prompt": "{{QODE_INSTRUCTIONS}}<fim_prefix>{{QODE_PREFIX}}<fim_suffix>{{QODE_SUFFIX}}<fim_middle>",
+  "options": {
+    "temperature": 0.7,
+    "top_p": 0.95,
+    "top_k": 40,
+    "num_predict": 175,
+    "stop": [
+      "<|endoftext|>",
+      "<file_sep>",
+      "<fim_prefix>",
+      "<fim_suffix>",
+      "<fim_middle>"
+    ],
+    "frequency_penalty": 0,
+    "presence_penalty": 0
+  },
+  "stream": true
+}

rawPromptExamples/OpenAICodeqwenChat.json

@@ -0,0 +1,16 @@
+{
+  "max_tokens": 150,
+  "messages": [
+    {
+      "content": "{{QODE_INSTRUCTIONS}}\n### Instruction:{{QODE_PREFIX}}{{QODE_SUFFIX}} ### Response:\n",
+      "role": "user"
+    }
+  ],
+  "stop": [
+    "### Instruction:",
+    "### Response:",
+    "\n\n### "
+  ],
+  "stream": true,
+  "temperature": 0.2
+}

settings/Assisttr.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

settings/ButtonAspect.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 <QPushButton>
+#include <utils/aspects.h>
+#include <utils/layoutbuilder.h>
+
+class ButtonAspect : public Utils::BaseAspect
+{
+    Q_OBJECT
+
+public:
+    ButtonAspect(Utils::AspectContainer *container = nullptr)
+        : Utils::BaseAspect(container)
+    {}
+
+    void addToLayoutImpl(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();
+};

settings/CMakeLists.txt

@@ -0,0 +1,21 @@
+add_library(QodeAssistSettings STATIC
+    GeneralSettings.hpp GeneralSettings.cpp
+    CustomPromptSettings.hpp CustomPromptSettings.cpp
+    SettingsUtils.hpp
+    SettingsConstants.hpp
+    ButtonAspect.hpp
+    SettingsTr.hpp
+    CodeCompletionSettings.hpp CodeCompletionSettings.cpp
+    ChatAssistantSettings.hpp ChatAssistantSettings.cpp
+    SettingsDialog.hpp SettingsDialog.cpp
+)
+
+target_link_libraries(QodeAssistSettings
+    PUBLIC
+    Qt::Core
+    Qt::Network
+    QtCreator::Core
+    QtCreator::Utils
+    QodeAssistLogger
+)
+target_include_directories(QodeAssistSettings PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

settings/ChatAssistantSettings.cpp

@@ -0,0 +1,236 @@
+/* 
+ * 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 "ChatAssistantSettings.hpp"
+
+#include <QMessageBox>
+#include <coreplugin/dialogs/ioptionspage.h>
+#include <coreplugin/icore.h>
+#include <utils/layoutbuilder.h>
+
+#include "SettingsConstants.hpp"
+#include "SettingsTr.hpp"
+#include "SettingsUtils.hpp"
+
+namespace QodeAssist::Settings {
+
+ChatAssistantSettings &chatAssistantSettings()
+{
+    static ChatAssistantSettings settings;
+    return settings;
+}
+
+ChatAssistantSettings::ChatAssistantSettings()
+{
+    setAutoApply(false);
+
+    setDisplayName(Tr::tr("Chat Assistant"));
+
+    // Chat Settings
+    chatTokensThreshold.setSettingsKey(Constants::CA_TOKENS_THRESHOLD);
+    chatTokensThreshold.setLabelText(Tr::tr("Chat History Token Limit:"));
+    chatTokensThreshold.setToolTip(Tr::tr("Maximum number of tokens in chat history. When "
+                                          "exceeded, oldest messages will be removed."));
+    chatTokensThreshold.setRange(1000, 16000);
+    chatTokensThreshold.setDefaultValue(8000);
+
+    sharingCurrentFile.setSettingsKey(Constants::CA_SHARING_CURRENT_FILE);
+    sharingCurrentFile.setLabelText(Tr::tr("Share Current File With Assistant by Default"));
+    sharingCurrentFile.setDefaultValue(true);
+
+    // General Parameters Settings
+    temperature.setSettingsKey(Constants::CA_TEMPERATURE);
+    temperature.setLabelText(Tr::tr("Temperature:"));
+    temperature.setDefaultValue(0.5);
+    temperature.setRange(0.0, 2.0);
+    temperature.setSingleStep(0.1);
+
+    maxTokens.setSettingsKey(Constants::CA_MAX_TOKENS);
+    maxTokens.setLabelText(Tr::tr("Max Tokens:"));
+    maxTokens.setRange(-1, 10000);
+    maxTokens.setDefaultValue(2000);
+
+    // Advanced Parameters
+    useTopP.setSettingsKey(Constants::CA_USE_TOP_P);
+    useTopP.setDefaultValue(false);
+    useTopP.setLabelText(Tr::tr("Top P:"));
+
+    topP.setSettingsKey(Constants::CA_TOP_P);
+    topP.setDefaultValue(0.9);
+    topP.setRange(0.0, 1.0);
+    topP.setSingleStep(0.1);
+
+    useTopK.setSettingsKey(Constants::CA_USE_TOP_K);
+    useTopK.setDefaultValue(false);
+    useTopK.setLabelText(Tr::tr("Top K:"));
+
+    topK.setSettingsKey(Constants::CA_TOP_K);
+    topK.setDefaultValue(50);
+    topK.setRange(1, 1000);
+
+    usePresencePenalty.setSettingsKey(Constants::CA_USE_PRESENCE_PENALTY);
+    usePresencePenalty.setDefaultValue(false);
+    usePresencePenalty.setLabelText(Tr::tr("Presence Penalty:"));
+
+    presencePenalty.setSettingsKey(Constants::CA_PRESENCE_PENALTY);
+    presencePenalty.setDefaultValue(0.0);
+    presencePenalty.setRange(-2.0, 2.0);
+    presencePenalty.setSingleStep(0.1);
+
+    useFrequencyPenalty.setSettingsKey(Constants::CA_USE_FREQUENCY_PENALTY);
+    useFrequencyPenalty.setDefaultValue(false);
+    useFrequencyPenalty.setLabelText(Tr::tr("Frequency Penalty:"));
+
+    frequencyPenalty.setSettingsKey(Constants::CA_FREQUENCY_PENALTY);
+    frequencyPenalty.setDefaultValue(0.0);
+    frequencyPenalty.setRange(-2.0, 2.0);
+    frequencyPenalty.setSingleStep(0.1);
+
+    // Context Settings
+    useSystemPrompt.setSettingsKey(Constants::CA_USE_SYSTEM_PROMPT);
+    useSystemPrompt.setDefaultValue(true);
+    useSystemPrompt.setLabelText(Tr::tr("Use System Prompt"));
+
+    systemPrompt.setSettingsKey(Constants::CA_SYSTEM_PROMPT);
+    systemPrompt.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+    systemPrompt.setDefaultValue(
+        "You are an advanced AI assistant specializing in C++, Qt, and QML development. Your role "
+        "is to provide helpful, accurate, and detailed responses to questions about coding, "
+        "debugging, "
+        "and best practices in these technologies.");
+
+    // Ollama Settings
+    ollamaLivetime.setSettingsKey(Constants::CA_OLLAMA_LIVETIME);
+    ollamaLivetime.setToolTip(
+        Tr::tr("Time to suspend Ollama after completion request (in minutes), "
+               "Only Ollama,  -1 to disable"));
+    ollamaLivetime.setLabelText("Livetime:");
+    ollamaLivetime.setDefaultValue("5m");
+    ollamaLivetime.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    contextWindow.setSettingsKey(Constants::CA_OLLAMA_CONTEXT_WINDOW);
+    contextWindow.setLabelText(Tr::tr("Context Window:"));
+    contextWindow.setRange(-1, 10000);
+    contextWindow.setDefaultValue(2048);
+
+    // API Configuration Settings
+    apiKey.setSettingsKey(Constants::CA_API_KEY);
+    apiKey.setLabelText(Tr::tr("API Key:"));
+    apiKey.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+    apiKey.setPlaceHolderText(Tr::tr("Enter your API key here"));
+
+    resetToDefaults.m_buttonText = TrConstants::RESET_TO_DEFAULTS;
+
+    readSettings();
+
+    setupConnections();
+
+    setLayouter([this]() {
+        using namespace Layouting;
+
+        auto genGrid = Grid{};
+        genGrid.addRow({Row{temperature}});
+        genGrid.addRow({Row{maxTokens}});
+
+        auto advancedGrid = Grid{};
+        advancedGrid.addRow({useTopP, topP});
+        advancedGrid.addRow({useTopK, topK});
+        advancedGrid.addRow({usePresencePenalty, presencePenalty});
+        advancedGrid.addRow({useFrequencyPenalty, frequencyPenalty});
+
+        auto ollamaGrid = Grid{};
+        ollamaGrid.addRow({ollamaLivetime});
+        ollamaGrid.addRow({contextWindow});
+
+        return Column{Row{Stretch{1}, resetToDefaults},
+                      Space{8},
+                      Group{title(Tr::tr("Chat Settings")),
+                            Column{Row{chatTokensThreshold, Stretch{1}}, sharingCurrentFile}},
+                      Space{8},
+                      Group{
+                          title(Tr::tr("General Parameters")),
+                          Row{genGrid, Stretch{1}},
+                      },
+                      Space{8},
+                      Group{title(Tr::tr("Advanced Parameters")),
+                            Column{Row{advancedGrid, Stretch{1}}}},
+                      Space{8},
+                      Group{title(Tr::tr("Context Settings")),
+                            Column{
+                                Row{useSystemPrompt, Stretch{1}},
+                                systemPrompt,
+                            }},
+                      Group{title(Tr::tr("Ollama Settings")), Column{Row{ollamaGrid, Stretch{1}}}},
+                      Space{8},
+                      Group{title(Tr::tr("API Configuration")), Column{apiKey}},
+                      Stretch{1}};
+    });
+}
+
+void ChatAssistantSettings::setupConnections()
+{
+    connect(&resetToDefaults,
+            &ButtonAspect::clicked,
+            this,
+            &ChatAssistantSettings::resetSettingsToDefaults);
+}
+
+void ChatAssistantSettings::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(chatTokensThreshold);
+        resetAspect(temperature);
+        resetAspect(maxTokens);
+        resetAspect(useTopP);
+        resetAspect(topP);
+        resetAspect(useTopK);
+        resetAspect(topK);
+        resetAspect(usePresencePenalty);
+        resetAspect(presencePenalty);
+        resetAspect(useFrequencyPenalty);
+        resetAspect(frequencyPenalty);
+        resetAspect(useSystemPrompt);
+        resetAspect(systemPrompt);
+        resetAspect(ollamaLivetime);
+        resetAspect(contextWindow);
+    }
+}
+
+class ChatAssistantSettingsPage : public Core::IOptionsPage
+{
+public:
+    ChatAssistantSettingsPage()
+    {
+        setId(Constants::QODE_ASSIST_CHAT_ASSISTANT_SETTINGS_PAGE_ID);
+        setDisplayName(Tr::tr("Chat Assistant"));
+        setCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_CATEGORY);
+        setSettingsProvider([] { return &chatAssistantSettings(); });
+    }
+};
+
+const ChatAssistantSettingsPage chatAssistantSettingsPage;
+
+} // namespace QodeAssist::Settings

settings/ChatAssistantSettings.hpp

@@ -0,0 +1,74 @@
+/* 
+ * 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 <utils/aspects.h>
+
+#include "ButtonAspect.hpp"
+
+namespace QodeAssist::Settings {
+
+class ChatAssistantSettings : public Utils::AspectContainer
+{
+public:
+    ChatAssistantSettings();
+
+    ButtonAspect resetToDefaults{this};
+
+    // Chat settings
+    Utils::IntegerAspect chatTokensThreshold{this};
+    Utils::BoolAspect sharingCurrentFile{this};
+
+    // General Parameters Settings
+    Utils::DoubleAspect temperature{this};
+    Utils::IntegerAspect maxTokens{this};
+
+    // Advanced Parameters
+    Utils::BoolAspect useTopP{this};
+    Utils::DoubleAspect topP{this};
+
+    Utils::BoolAspect useTopK{this};
+    Utils::IntegerAspect topK{this};
+
+    Utils::BoolAspect usePresencePenalty{this};
+    Utils::DoubleAspect presencePenalty{this};
+
+    Utils::BoolAspect useFrequencyPenalty{this};
+    Utils::DoubleAspect frequencyPenalty{this};
+
+    // Context Settings
+    Utils::BoolAspect useSystemPrompt{this};
+    Utils::StringAspect systemPrompt{this};
+
+    // Ollama Settings
+    Utils::StringAspect ollamaLivetime{this};
+    Utils::IntegerAspect contextWindow{this};
+
+    // API Configuration Settings
+    Utils::StringAspect apiKey{this};
+
+private:
+    void setupConnections();
+    void resetSettingsToDefaults();
+};
+
+ChatAssistantSettings &chatAssistantSettings();
+
+} // namespace QodeAssist::Settings

settings/CodeCompletionSettings.cpp

@@ -0,0 +1,316 @@
+/* 
+ * 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 "CodeCompletionSettings.hpp"
+
+#include <QMessageBox>
+#include <coreplugin/dialogs/ioptionspage.h>
+#include <coreplugin/icore.h>
+#include <utils/layoutbuilder.h>
+
+#include "SettingsConstants.hpp"
+#include "SettingsTr.hpp"
+#include "SettingsUtils.hpp"
+
+namespace QodeAssist::Settings {
+
+CodeCompletionSettings &codeCompletionSettings()
+{
+    static CodeCompletionSettings settings;
+    return settings;
+}
+
+CodeCompletionSettings::CodeCompletionSettings()
+{
+    setAutoApply(false);
+
+    setDisplayName(Tr::tr("Code Completion"));
+
+    // Auto Completion Settings
+    autoCompletion.setSettingsKey(Constants::CC_AUTO_COMPLETION);
+    autoCompletion.setLabelText(Tr::tr("Enable Auto Complete"));
+    autoCompletion.setDefaultValue(true);
+
+    multiLineCompletion.setSettingsKey(Constants::CC_MULTILINE_COMPLETION);
+    multiLineCompletion.setDefaultValue(false);
+    multiLineCompletion.setLabelText(Tr::tr("Enable Multiline Completion(experimental)"));
+
+    startSuggestionTimer.setSettingsKey(Constants::СС_START_SUGGESTION_TIMER);
+    startSuggestionTimer.setLabelText(Tr::tr("with delay(ms)"));
+    startSuggestionTimer.setRange(10, 10000);
+    startSuggestionTimer.setDefaultValue(500);
+
+    autoCompletionCharThreshold.setSettingsKey(Constants::СС_AUTO_COMPLETION_CHAR_THRESHOLD);
+    autoCompletionCharThreshold.setLabelText(Tr::tr("AI suggestion triggers after typing"));
+    autoCompletionCharThreshold.setToolTip(
+        Tr::tr("The number of characters that need to be typed within the typing interval "
+               "before an AI suggestion request is sent."));
+    autoCompletionCharThreshold.setRange(0, 10);
+    autoCompletionCharThreshold.setDefaultValue(0);
+
+    autoCompletionTypingInterval.setSettingsKey(Constants::СС_AUTO_COMPLETION_TYPING_INTERVAL);
+    autoCompletionTypingInterval.setLabelText(Tr::tr("character(s) within(ms)"));
+    autoCompletionTypingInterval.setToolTip(
+        Tr::tr("The time window (in milliseconds) during which the character threshold "
+               "must be met to trigger an AI suggestion request."));
+    autoCompletionTypingInterval.setRange(500, 5000);
+    autoCompletionTypingInterval.setDefaultValue(2000);
+
+    // General Parameters Settings
+    temperature.setSettingsKey(Constants::CC_TEMPERATURE);
+    temperature.setLabelText(Tr::tr("Temperature:"));
+    temperature.setDefaultValue(0.2);
+    temperature.setRange(0.0, 2.0);
+    temperature.setSingleStep(0.1);
+
+    maxTokens.setSettingsKey(Constants::CC_MAX_TOKENS);
+    maxTokens.setLabelText(Tr::tr("Max Tokens:"));
+    maxTokens.setRange(-1, 10000);
+    maxTokens.setDefaultValue(50);
+
+    // Advanced Parameters
+    useTopP.setSettingsKey(Constants::CC_USE_TOP_P);
+    useTopP.setDefaultValue(false);
+    useTopP.setLabelText(Tr::tr("Top P:"));
+
+    topP.setSettingsKey(Constants::CC_TOP_P);
+    topP.setDefaultValue(0.9);
+    topP.setRange(0.0, 1.0);
+    topP.setSingleStep(0.1);
+
+    useTopK.setSettingsKey(Constants::CC_USE_TOP_K);
+    useTopK.setDefaultValue(false);
+    useTopK.setLabelText(Tr::tr("Top K:"));
+
+    topK.setSettingsKey(Constants::CC_TOP_K);
+    topK.setDefaultValue(50);
+    topK.setRange(1, 1000);
+
+    usePresencePenalty.setSettingsKey(Constants::CC_USE_PRESENCE_PENALTY);
+    usePresencePenalty.setDefaultValue(false);
+    usePresencePenalty.setLabelText(Tr::tr("Presence Penalty:"));
+
+    presencePenalty.setSettingsKey(Constants::CC_PRESENCE_PENALTY);
+    presencePenalty.setDefaultValue(0.0);
+    presencePenalty.setRange(-2.0, 2.0);
+    presencePenalty.setSingleStep(0.1);
+
+    useFrequencyPenalty.setSettingsKey(Constants::CC_USE_FREQUENCY_PENALTY);
+    useFrequencyPenalty.setDefaultValue(false);
+    useFrequencyPenalty.setLabelText(Tr::tr("Frequency Penalty:"));
+
+    frequencyPenalty.setSettingsKey(Constants::CC_FREQUENCY_PENALTY);
+    frequencyPenalty.setDefaultValue(0.0);
+    frequencyPenalty.setRange(-2.0, 2.0);
+    frequencyPenalty.setSingleStep(0.1);
+
+    // Context Settings
+    readFullFile.setSettingsKey(Constants::CC_READ_FULL_FILE);
+    readFullFile.setLabelText(Tr::tr("Read Full File"));
+    readFullFile.setDefaultValue(false);
+
+    readFileParts.setLabelText(Tr::tr("Read Strings Before Cursor:"));
+    readFileParts.setDefaultValue(true);
+
+    readStringsBeforeCursor.setSettingsKey(Constants::CC_READ_STRINGS_BEFORE_CURSOR);
+    readStringsBeforeCursor.setRange(0, 10000);
+    readStringsBeforeCursor.setDefaultValue(50);
+
+    readStringsAfterCursor.setSettingsKey(Constants::CC_READ_STRINGS_AFTER_CURSOR);
+    readStringsAfterCursor.setLabelText(Tr::tr("Read Strings After Cursor:"));
+    readStringsAfterCursor.setRange(0, 10000);
+    readStringsAfterCursor.setDefaultValue(30);
+
+    useSystemPrompt.setSettingsKey(Constants::CC_USE_SYSTEM_PROMPT);
+    useSystemPrompt.setDefaultValue(true);
+    useSystemPrompt.setLabelText(Tr::tr("Use System Prompt"));
+
+    systemPrompt.setSettingsKey(Constants::CC_SYSTEM_PROMPT);
+    systemPrompt.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+    systemPrompt.setDefaultValue("You are an expert C++, Qt, and QML code completion AI. ANSWER "
+                                 "should be SHORT and in CODE");
+
+    useFilePathInContext.setSettingsKey(Constants::CC_USE_FILE_PATH_IN_CONTEXT);
+    useFilePathInContext.setDefaultValue(true);
+    useFilePathInContext.setLabelText(Tr::tr("Use File Path in Context"));
+
+    useProjectChangesCache.setSettingsKey(Constants::CC_USE_PROJECT_CHANGES_CACHE);
+    useProjectChangesCache.setDefaultValue(true);
+    useProjectChangesCache.setLabelText(Tr::tr("Max Changes Cache Size:"));
+
+    maxChangesCacheSize.setSettingsKey(Constants::CC_MAX_CHANGES_CACHE_SIZE);
+    maxChangesCacheSize.setRange(2, 1000);
+    maxChangesCacheSize.setDefaultValue(10);
+
+    // Ollama Settings
+    ollamaLivetime.setSettingsKey(Constants::CC_OLLAMA_LIVETIME);
+    ollamaLivetime.setToolTip(
+        Tr::tr("Time to suspend Ollama after completion request (in minutes), "
+               "Only Ollama,  -1 to disable"));
+    ollamaLivetime.setLabelText("Livetime:");
+    ollamaLivetime.setDefaultValue("5m");
+    ollamaLivetime.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+
+    contextWindow.setSettingsKey(Constants::CC_OLLAMA_CONTEXT_WINDOW);
+    contextWindow.setLabelText(Tr::tr("Context Window:"));
+    contextWindow.setRange(-1, 10000);
+    contextWindow.setDefaultValue(2048);
+
+    // API Configuration Settings
+    apiKey.setSettingsKey(Constants::CC_API_KEY);
+    apiKey.setLabelText(Tr::tr("API Key:"));
+    apiKey.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+    apiKey.setPlaceHolderText(Tr::tr("Enter your API key here"));
+
+    resetToDefaults.m_buttonText = Tr::tr("Reset Page to Defaults");
+
+    readSettings();
+
+    readFileParts.setValue(!readFullFile.value());
+
+    setupConnections();
+
+    setLayouter([this]() {
+        using namespace Layouting;
+
+        auto genGrid = Grid{};
+        genGrid.addRow({Row{temperature}});
+        genGrid.addRow({Row{maxTokens}});
+
+        auto advancedGrid = Grid{};
+        advancedGrid.addRow({useTopP, topP});
+        advancedGrid.addRow({useTopK, topK});
+        advancedGrid.addRow({usePresencePenalty, presencePenalty});
+        advancedGrid.addRow({useFrequencyPenalty, frequencyPenalty});
+
+        auto ollamaGrid = Grid{};
+        ollamaGrid.addRow({ollamaLivetime});
+        ollamaGrid.addRow({contextWindow});
+
+        auto contextGrid = Grid{};
+        contextGrid.addRow({Row{readFullFile}});
+        contextGrid.addRow({Row{readFileParts, readStringsBeforeCursor, readStringsAfterCursor}});
+
+        auto contextItem = Column{Row{contextGrid, Stretch{1}},
+                                  Row{useSystemPrompt, Stretch{1}},
+                                  systemPrompt,
+                                  Row{useFilePathInContext, Stretch{1}},
+                                  Row{useProjectChangesCache, maxChangesCacheSize, Stretch{1}}};
+
+        return Column{Row{Stretch{1}, resetToDefaults},
+                      Space{8},
+                      Group{title(Tr::tr("Auto Completion Settings")),
+                            Column{autoCompletion,
+                                   Space{8},
+                                   multiLineCompletion,
+                                   Row{autoCompletionCharThreshold,
+                                       autoCompletionTypingInterval,
+                                       startSuggestionTimer,
+                                       Stretch{1}}}},
+                      Space{8},
+                      Group{title(Tr::tr("General Parameters")),
+                            Column{
+                                Row{genGrid, Stretch{1}},
+                            }},
+                      Space{8},
+                      Group{title(Tr::tr("Advanced Parameters")),
+                            Column{Row{advancedGrid, Stretch{1}}}},
+                      Space{8},
+                      Group{title(Tr::tr("Context Settings")), contextItem},
+                      Space{8},
+                      Group{title(Tr::tr("Ollama Settings")), Column{Row{ollamaGrid, Stretch{1}}}},
+                      Space{8},
+                      Group{title(Tr::tr("API Configuration")), Column{apiKey}},
+                      Stretch{1}};
+    });
+}
+
+void CodeCompletionSettings::setupConnections()
+{
+    connect(&resetToDefaults,
+            &ButtonAspect::clicked,
+            this,
+            &CodeCompletionSettings::resetSettingsToDefaults);
+
+    connect(&readFullFile, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
+        if (readFullFile.volatileValue()) {
+            readFileParts.setValue(false);
+            writeSettings();
+        }
+    });
+
+    connect(&readFileParts, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
+        if (readFileParts.volatileValue()) {
+            readFullFile.setValue(false);
+            writeSettings();
+        }
+    });
+}
+
+void CodeCompletionSettings::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(autoCompletion);
+        resetAspect(multiLineCompletion);
+        resetAspect(temperature);
+        resetAspect(maxTokens);
+        resetAspect(useTopP);
+        resetAspect(topP);
+        resetAspect(useTopK);
+        resetAspect(topK);
+        resetAspect(usePresencePenalty);
+        resetAspect(presencePenalty);
+        resetAspect(useFrequencyPenalty);
+        resetAspect(frequencyPenalty);
+        resetAspect(readFullFile);
+        resetAspect(readFileParts);
+        resetAspect(readStringsBeforeCursor);
+        resetAspect(readStringsAfterCursor);
+        resetAspect(useSystemPrompt);
+        resetAspect(systemPrompt);
+        resetAspect(useFilePathInContext);
+        resetAspect(useProjectChangesCache);
+        resetAspect(maxChangesCacheSize);
+        resetAspect(ollamaLivetime);
+        resetAspect(contextWindow);
+    }
+}
+
+class CodeCompletionSettingsPage : public Core::IOptionsPage
+{
+public:
+    CodeCompletionSettingsPage()
+    {
+        setId(Constants::QODE_ASSIST_CODE_COMPLETION_SETTINGS_PAGE_ID);
+        setDisplayName(Tr::tr("Code Completion"));
+        setCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_CATEGORY);
+        setSettingsProvider([] { return &codeCompletionSettings(); });
+    }
+};
+
+const CodeCompletionSettingsPage codeCompletionSettingsPage;
+
+} // namespace QodeAssist::Settings

settings/CodeCompletionSettings.hpp

@@ -19,64 +19,32 @@
 
 #pragma once
 
-#include <QPushButton>
 #include <utils/aspects.h>
-#include <utils/layoutbuilder.h>
 
-namespace QodeAssist {
+#include "ButtonAspect.hpp"
 
-template<typename AspectType>
-void resetAspect(AspectType &aspect)
-{
-    aspect.setValue(aspect.defaultValue());
-}
+namespace QodeAssist::Settings {
 
-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
+class CodeCompletionSettings : public Utils::AspectContainer
 {
 public:
-    QodeAssistSettings();
+    CodeCompletionSettings();
 
-    Utils::BoolAspect enableQodeAssist{this};
-    Utils::BoolAspect enableAutoComplete{this};
-    Utils::BoolAspect enableLogging{this};
+    ButtonAspect resetToDefaults{this};
 
-    Utils::SelectionAspect llmProviders{this};
-    Utils::StringAspect url{this};
-    Utils::IntegerAspect port{this};
-    Utils::StringAspect endPoint{this};
+    // Auto Completion Settings
+    Utils::BoolAspect autoCompletion{this};
+    Utils::BoolAspect multiLineCompletion{this};
 
-    Utils::StringAspect modelName{this};
-    ButtonAspect selectModels{this};
+    Utils::IntegerAspect startSuggestionTimer{this};
+    Utils::IntegerAspect autoCompletionCharThreshold{this};
+    Utils::IntegerAspect autoCompletionTypingInterval{this};
 
-    Utils::SelectionAspect fimPrompts{this};
+    // General Parameters Settings
     Utils::DoubleAspect temperature{this};
     Utils::IntegerAspect maxTokens{this};
 
-    Utils::BoolAspect readFullFile{this};
-    Utils::IntegerAspect readStringsBeforeCursor{this};
-    Utils::IntegerAspect readStringsAfterCursor{this};
-
+    // Advanced Parameters
     Utils::BoolAspect useTopP{this};
     Utils::DoubleAspect topP{this};
 
@@ -89,28 +57,29 @@ public:
     Utils::BoolAspect useFrequencyPenalty{this};
     Utils::DoubleAspect frequencyPenalty{this};
 
-    Utils::StringListAspect providerPaths{this};
-
-    Utils::IntegerAspect startSuggestionTimer{this};
-    Utils::IntegerAspect maxFileThreshold{this};
+    // Context Settings
+    Utils::BoolAspect readFullFile{this};
+    Utils::BoolAspect readFileParts{this};
+    Utils::IntegerAspect readStringsBeforeCursor{this};
+    Utils::IntegerAspect readStringsAfterCursor{this};
+    Utils::BoolAspect useSystemPrompt{this};
+    Utils::StringAspect systemPrompt{this};
+    Utils::BoolAspect useFilePathInContext{this};
+    Utils::BoolAspect useProjectChangesCache{this};
+    Utils::IntegerAspect maxChangesCacheSize{this};
 
+    // Ollama Settings
     Utils::StringAspect ollamaLivetime{this};
-    Utils::StringAspect specificInstractions{this};
-    Utils::BoolAspect multiLineCompletion{this};
+    Utils::IntegerAspect contextWindow{this};
 
+    // API Configuration Settings
     Utils::StringAspect apiKey{this};
 
-    ButtonAspect resetToDefaults{this};
-
 private:
     void setupConnections();
-    void updateProviderSettings();
-    QStringList getInstalledModels();
-    void showModelSelectionDialog();
-    Utils::Environment getEnvironmentWithProviderPaths() const;
     void resetSettingsToDefaults();
 };
 
-QodeAssistSettings &settings();
+CodeCompletionSettings &codeCompletionSettings();
 
-} // namespace QodeAssist
+} // namespace QodeAssist::Settings

settings/CustomPromptSettings.cpp

@@ -0,0 +1,201 @@
+/* 
+ * 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 "CustomPromptSettings.hpp"
+
+#include <QFileDialog>
+#include <QJsonParseError>
+#include <QMessageBox>
+#include <coreplugin/dialogs/ioptionspage.h>
+#include <coreplugin/icore.h>
+#include <utils/layoutbuilder.h>
+
+#include "SettingsConstants.hpp"
+#include "SettingsTr.hpp"
+#include "SettingsUtils.hpp"
+
+namespace QodeAssist::Settings {
+
+CustomPromptSettings &customPromptSettings()
+{
+    static CustomPromptSettings settings;
+    return settings;
+}
+
+CustomPromptSettings::CustomPromptSettings()
+{
+    setAutoApply(false);
+
+    setDisplayName(Tr::tr("Custom Prompt"));
+
+    customJsonLabel.setLabelText("Custom JSON Template:");
+    customJsonLabel.setDisplayStyle(Utils::StringAspect::LabelDisplay);
+
+    customJsonLegend.setLabelText(Tr::tr(R"(Prompt components:
+- model is set on General Page
+- {{QODE_INSTRUCTIONS}}: Placeholder for specific instructions or context.
+- {{QODE_PREFIX}}: Will be replaced with the actual code before the cursor.
+- {{QODE_SUFFIX}}: Will be replaced with the actual code after the cursor.
+)"));
+
+    customJsonTemplate.setSettingsKey(Constants::CUSTOM_JSON_TEMPLATE);
+    customJsonTemplate.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+
+    customJsonTemplate.setDefaultValue(R"({
+  "prompt": "{{QODE_INSTRUCTIONS}}<fim_prefix>{{QODE_PREFIX}}<fim_suffix>{{QODE_SUFFIX}}<fim_middle>",
+  "options": {
+    "temperature": 0.7,
+    "top_p": 0.95,
+    "top_k": 40,
+    "num_predict": 100,
+    "stop": [
+      "<|endoftext|>",
+      "<file_sep>",
+      "<fim_prefix>",
+      "<fim_suffix>",
+      "<fim_middle>"
+    ],
+    "frequency_penalty": 0,
+    "presence_penalty": 0
+  },
+  "stream": true
+})");
+    saveCustomTemplateButton.m_buttonText = (Tr::tr("Save Custom Template to JSON"));
+    loadCustomTemplateButton.m_buttonText = (Tr::tr("Load Custom Template from JSON"));
+    resetToDefaults.m_buttonText = Tr::tr("Reset Page to Defaults");
+
+    readSettings();
+
+    setupConnection();
+
+    setLayouter([this]() {
+        using namespace Layouting;
+        return Column{Group{title(Tr::tr("Custom prompt for FIM model")),
+                            Column{Row{customJsonLabel, Stretch{1}, resetToDefaults},
+                                   Row{customJsonTemplate,
+                                       Column{saveCustomTemplateButton,
+                                              loadCustomTemplateButton,
+                                              customJsonLegend,
+                                              Stretch{1}}}}}};
+    });
+}
+
+void CustomPromptSettings::setupConnection()
+{
+    connect(&resetToDefaults,
+            &ButtonAspect::clicked,
+            this,
+            &CustomPromptSettings::resetSettingsToDefaults);
+    connect(&saveCustomTemplateButton,
+            &ButtonAspect::clicked,
+            this,
+            &CustomPromptSettings::saveCustomTemplate);
+    connect(&loadCustomTemplateButton,
+            &ButtonAspect::clicked,
+            this,
+            &CustomPromptSettings::loadCustomTemplate);
+}
+
+void CustomPromptSettings::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(customJsonTemplate);
+    }
+}
+
+void CustomPromptSettings::saveCustomTemplate()
+{
+    QString fileName = QFileDialog::getSaveFileName(nullptr,
+                                                    Tr::tr("Save JSON Template"),
+                                                    QString(),
+                                                    Tr::tr("JSON Files (*.json)"));
+    if (fileName.isEmpty())
+        return;
+
+    QFile file(fileName);
+    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        QTextStream out(&file);
+        out << customJsonTemplate.value();
+        file.close();
+        QMessageBox::information(nullptr,
+                                 Tr::tr("Save Successful"),
+                                 Tr::tr("JSON template has been saved successfully."));
+    } else {
+        QMessageBox::critical(nullptr,
+                              Tr::tr("Save Failed"),
+                              Tr::tr("Failed to save JSON template."));
+    }
+}
+
+void CustomPromptSettings::loadCustomTemplate()
+{
+    QString fileName = QFileDialog::getOpenFileName(nullptr,
+                                                    Tr::tr("Load JSON Template"),
+                                                    QString(),
+                                                    Tr::tr("JSON Files (*.json)"));
+    if (fileName.isEmpty())
+        return;
+
+    QFile file(fileName);
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream in(&file);
+        QString jsonContent = in.readAll();
+        file.close();
+
+        QJsonParseError parseError;
+        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonContent.toUtf8(), &parseError);
+        if (parseError.error == QJsonParseError::NoError) {
+            customJsonTemplate.setVolatileValue(jsonContent);
+            QMessageBox::information(nullptr,
+                                     Tr::tr("Load Successful"),
+                                     Tr::tr("JSON template has been loaded successfully."));
+        } else {
+            QMessageBox::critical(nullptr,
+                                  Tr::tr("Invalid JSON"),
+                                  Tr::tr("The selected file contains invalid JSON."));
+        }
+    } else {
+        QMessageBox::critical(nullptr,
+                              Tr::tr("Load Failed"),
+                              Tr::tr("Failed to load JSON template."));
+    }
+}
+
+class CustomPromptSettingsPage : public Core::IOptionsPage
+{
+public:
+    CustomPromptSettingsPage()
+    {
+        setId(Constants::QODE_ASSIST_CUSTOM_PROMPT_SETTINGS_PAGE_ID);
+        setDisplayName(Tr::tr("Custom Prompt"));
+        setCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_CATEGORY);
+        setSettingsProvider([] { return &customPromptSettings(); });
+    }
+};
+
+const CustomPromptSettingsPage customPromptSettingsPage;
+
+} // namespace QodeAssist::Settings

settings/CustomPromptSettings.hpp

@@ -0,0 +1,49 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <utils/aspects.h>
+
+#include "ButtonAspect.hpp"
+
+namespace QodeAssist::Settings {
+
+class CustomPromptSettings : public Utils::AspectContainer
+{
+public:
+    CustomPromptSettings();
+
+    Utils::StringAspect customJsonLabel{this};
+    Utils::StringAspect customJsonTemplate{this};
+    Utils::StringAspect customJsonLegend{this};
+    ButtonAspect saveCustomTemplateButton{this};
+    ButtonAspect loadCustomTemplateButton{this};
+    ButtonAspect resetToDefaults{this};
+
+private:
+    void setupConnection();
+    void resetSettingsToDefaults();
+    void saveCustomTemplate();
+    void loadCustomTemplate();
+};
+
+CustomPromptSettings &customPromptSettings();
+
+} // namespace QodeAssist::Settings

settings/GeneralSettings.cpp

@@ -0,0 +1,341 @@
+/* 
+ * 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 "GeneralSettings.hpp"
+
+#include <coreplugin/dialogs/ioptionspage.h>
+#include <coreplugin/icore.h>
+#include <utils/layoutbuilder.h>
+#include <utils/utilsicons.h>
+#include <QInputDialog>
+#include <QMessageBox>
+#include <QTimer>
+#include <QtWidgets/qboxlayout.h>
+#include <QtWidgets/qcompleter.h>
+#include <QtWidgets/qgroupbox.h>
+#include <QtWidgets/qradiobutton.h>
+#include <QtWidgets/qstackedwidget.h>
+
+#include "Logger.hpp"
+#include "SettingsConstants.hpp"
+#include "SettingsDialog.hpp"
+#include "SettingsTr.hpp"
+#include "SettingsUtils.hpp"
+
+namespace QodeAssist::Settings {
+
+GeneralSettings &generalSettings()
+{
+    static GeneralSettings settings;
+    return settings;
+}
+
+GeneralSettings::GeneralSettings()
+{
+    setAutoApply(false);
+
+    setDisplayName(TrConstants::GENERAL);
+
+    enableQodeAssist.setSettingsKey(Constants::ENABLE_QODE_ASSIST);
+    enableQodeAssist.setLabelText(TrConstants::ENABLE_QODE_ASSIST);
+    enableQodeAssist.setDefaultValue(true);
+
+    enableLogging.setSettingsKey(Constants::ENABLE_LOGGING);
+    enableLogging.setLabelText(TrConstants::ENABLE_LOG);
+    enableLogging.setDefaultValue(false);
+
+    resetToDefaults.m_buttonText = TrConstants::RESET_TO_DEFAULTS;
+
+    initStringAspect(ccProvider, Constants::CC_PROVIDER, TrConstants::PROVIDER, "Ollama");
+    ccProvider.setReadOnly(true);
+    ccSelectProvider.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(ccModel, Constants::CC_MODEL, TrConstants::MODEL, "qwen2.5-coder:7b");
+    ccModel.setHistoryCompleter(Constants::CC_MODEL_HISTORY);
+    ccSelectModel.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(ccTemplate, Constants::CC_TEMPLATE, TrConstants::TEMPLATE, "Ollama Auto FIM");
+    ccTemplate.setReadOnly(true);
+    ccSelectTemplate.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(ccUrl, Constants::CC_URL, TrConstants::URL, "http://localhost:11434");
+    ccUrl.setHistoryCompleter(Constants::CC_URL_HISTORY);
+    ccSetUrl.m_buttonText = TrConstants::SELECT;
+
+    ccStatus.setDisplayStyle(Utils::StringAspect::LabelDisplay);
+    ccStatus.setLabelText(TrConstants::STATUS);
+    ccStatus.setDefaultValue("");
+    ccTest.m_buttonText = TrConstants::TEST;
+
+    initStringAspect(caProvider, Constants::CA_PROVIDER, TrConstants::PROVIDER, "Ollama");
+    caProvider.setReadOnly(true);
+    caSelectProvider.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(caModel, Constants::CA_MODEL, TrConstants::MODEL, "qwen2.5-coder:7b");
+    caModel.setHistoryCompleter(Constants::CA_MODEL_HISTORY);
+    caSelectModel.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(caTemplate, Constants::CA_TEMPLATE, TrConstants::TEMPLATE, "Ollama Auto Chat");
+    caTemplate.setReadOnly(true);
+
+    caSelectTemplate.m_buttonText = TrConstants::SELECT;
+
+    initStringAspect(caUrl, Constants::CA_URL, TrConstants::URL, "http://localhost:11434");
+    caUrl.setHistoryCompleter(Constants::CA_URL_HISTORY);
+    caSetUrl.m_buttonText = TrConstants::SELECT;
+
+    caStatus.setDisplayStyle(Utils::StringAspect::LabelDisplay);
+    caStatus.setLabelText(TrConstants::STATUS);
+    caStatus.setDefaultValue("");
+    caTest.m_buttonText = TrConstants::TEST;
+
+    readSettings();
+
+    Logger::instance().setLoggingEnabled(enableLogging());
+
+    setupConnections();
+
+    setLayouter([this]() {
+        using namespace Layouting;
+
+        auto ccGrid = Grid{};
+        ccGrid.addRow({ccProvider, ccSelectProvider});
+        ccGrid.addRow({ccUrl, ccSetUrl});
+        ccGrid.addRow({ccModel, ccSelectModel});
+        ccGrid.addRow({ccTemplate, ccSelectTemplate});
+        ccGrid.addRow({ccStatus, ccTest});
+
+        auto caGrid = Grid{};
+        caGrid.addRow({caProvider, caSelectProvider});
+        caGrid.addRow({caUrl, caSetUrl});
+        caGrid.addRow({caModel, caSelectModel});
+        caGrid.addRow({caTemplate, caSelectTemplate});
+        caGrid.addRow({caStatus, caTest});
+
+        auto ccGroup = Group{title(TrConstants::CODE_COMPLETION), ccGrid};
+        auto caGroup = Group{title(TrConstants::CHAT_ASSISTANT), caGrid};
+
+        auto rootLayout = Column{Row{enableQodeAssist, Stretch{1}, resetToDefaults},
+                                 Row{enableLogging, Stretch{1}},
+                                 Space{8},
+                                 ccGroup,
+                                 Space{8},
+                                 caGroup,
+                                 Stretch{1}};
+
+        return rootLayout;
+    });
+}
+
+void GeneralSettings::showSelectionDialog(const QStringList &data,
+                                          Utils::StringAspect &aspect,
+                                          const QString &title,
+                                          const QString &text)
+{
+    if (data.isEmpty())
+        return;
+
+    bool ok;
+    QInputDialog dialog(Core::ICore::dialogParent());
+    dialog.setWindowTitle(title);
+    dialog.setLabelText(text);
+    dialog.setComboBoxItems(data);
+    dialog.setComboBoxEditable(false);
+    dialog.setFixedSize(400, 150);
+
+    if (dialog.exec() == QDialog::Accepted) {
+        QString result = dialog.textValue();
+        if (!result.isEmpty()) {
+            aspect.setValue(result);
+            writeSettings();
+        }
+    }
+}
+
+void GeneralSettings::showModelsNotFoundDialog(Utils::StringAspect &aspect)
+{
+    SettingsDialog dialog(TrConstants::CONNECTION_ERROR);
+    dialog.addLabel(TrConstants::NO_MODELS_FOUND);
+    dialog.addLabel(TrConstants::CHECK_CONNECTION);
+    dialog.addSpacing();
+
+    ButtonAspect *providerButton = nullptr;
+    ButtonAspect *urlButton = nullptr;
+
+    if (&aspect == &ccModel) {
+        providerButton = &ccSelectProvider;
+        urlButton = &ccSetUrl;
+    } else if (&aspect == &caModel) {
+        providerButton = &caSelectProvider;
+        urlButton = &caSetUrl;
+    }
+
+    if (providerButton && urlButton) {
+        auto selectProviderBtn = new QPushButton(TrConstants::SELECT_PROVIDER);
+        auto selectUrlBtn = new QPushButton(TrConstants::SELECT_URL);
+        auto enterManuallyBtn = new QPushButton(TrConstants::ENTER_MODEL_MANUALLY);
+
+        connect(selectProviderBtn, &QPushButton::clicked, &dialog, [this, providerButton, &dialog]() {
+            dialog.close();
+            emit providerButton->clicked();
+        });
+
+        connect(selectUrlBtn, &QPushButton::clicked, &dialog, [this, urlButton, &dialog]() {
+            dialog.close();
+            emit urlButton->clicked();
+        });
+
+        connect(enterManuallyBtn, &QPushButton::clicked, &dialog, [this, &aspect, &dialog]() {
+            dialog.close();
+            showModelsNotSupportedDialog(aspect);
+        });
+
+        dialog.buttonLayout()->addWidget(selectProviderBtn);
+        dialog.buttonLayout()->addWidget(selectUrlBtn);
+        dialog.buttonLayout()->addWidget(enterManuallyBtn);
+    }
+
+    auto closeBtn = new QPushButton(TrConstants::CLOSE);
+    connect(closeBtn, &QPushButton::clicked, &dialog, &QDialog::close);
+    dialog.buttonLayout()->addWidget(closeBtn);
+
+    dialog.exec();
+}
+
+void GeneralSettings::showModelsNotSupportedDialog(Utils::StringAspect &aspect)
+{
+    SettingsDialog dialog(TrConstants::MODEL_SELECTION);
+    dialog.addLabel(TrConstants::MODEL_LISTING_NOT_SUPPORTED_INFO);
+    dialog.addSpacing();
+
+    QString key = QString("CompleterHistory/")
+                      .append(
+                          (&aspect == &ccModel) ? Constants::CC_MODEL_HISTORY
+                                                : Constants::CA_MODEL_HISTORY);
+    QStringList historyList = qtcSettings()->value(Utils::Key(key.toLocal8Bit())).toStringList();
+
+    auto modelList = dialog.addComboBox(historyList, aspect.value());
+    dialog.addSpacing();
+
+    auto okButton = new QPushButton(TrConstants::OK);
+    connect(okButton, &QPushButton::clicked, &dialog, [this, &aspect, modelList, &dialog]() {
+        QString value = modelList->currentText().trimmed();
+        if (!value.isEmpty()) {
+            aspect.setValue(value);
+            writeSettings();
+            dialog.accept();
+        }
+    });
+
+    auto cancelButton = new QPushButton(TrConstants::CANCEL);
+    connect(cancelButton, &QPushButton::clicked, &dialog, &QDialog::reject);
+
+    dialog.buttonLayout()->addWidget(cancelButton);
+    dialog.buttonLayout()->addWidget(okButton);
+
+    modelList->setFocus();
+    dialog.exec();
+}
+
+void GeneralSettings::showUrlSelectionDialog(
+    Utils::StringAspect &aspect, const QStringList &predefinedUrls)
+{
+    SettingsDialog dialog(TrConstants::URL_SELECTION);
+    dialog.addLabel(TrConstants::URL_SELECTION_INFO);
+    dialog.addSpacing();
+
+    QStringList allUrls = predefinedUrls;
+    QString key
+        = QString("CompleterHistory/")
+              .append((&aspect == &ccUrl) ? Constants::CC_URL_HISTORY : Constants::CA_URL_HISTORY);
+    QStringList historyList = qtcSettings()->value(Utils::Key(key.toLocal8Bit())).toStringList();
+    allUrls.append(historyList);
+    allUrls.removeDuplicates();
+
+    auto urlList = dialog.addComboBox(allUrls, aspect.value());
+    dialog.addSpacing();
+
+    auto okButton = new QPushButton(TrConstants::OK);
+    connect(okButton, &QPushButton::clicked, &dialog, [this, &aspect, urlList, &dialog]() {
+        QString value = urlList->currentText().trimmed();
+        if (!value.isEmpty()) {
+            aspect.setValue(value);
+            writeSettings();
+            dialog.accept();
+        }
+    });
+
+    auto cancelButton = new QPushButton(TrConstants::CANCEL);
+    connect(cancelButton, &QPushButton::clicked, &dialog, &QDialog::reject);
+
+    dialog.buttonLayout()->addWidget(cancelButton);
+    dialog.buttonLayout()->addWidget(okButton);
+
+    urlList->setFocus();
+    dialog.exec();
+}
+
+void GeneralSettings::setupConnections()
+{
+    connect(&enableLogging, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
+        Logger::instance().setLoggingEnabled(enableLogging.volatileValue());
+    });
+    connect(&resetToDefaults, &ButtonAspect::clicked, this, &GeneralSettings::resetPageToDefaults);
+}
+
+void GeneralSettings::resetPageToDefaults()
+{
+    QMessageBox::StandardButton reply;
+    reply = QMessageBox::question(Core::ICore::dialogParent(),
+                                  TrConstants::RESET_SETTINGS,
+                                  TrConstants::CONFIRMATION,
+                                  QMessageBox::Yes | QMessageBox::No);
+
+    if (reply == QMessageBox::Yes) {
+        resetAspect(enableQodeAssist);
+        resetAspect(enableLogging);
+        resetAspect(ccProvider);
+        resetAspect(ccModel);
+        resetAspect(ccTemplate);
+        resetAspect(ccUrl);
+        resetAspect(caProvider);
+        resetAspect(caModel);
+        resetAspect(caTemplate);
+        resetAspect(caUrl);
+        writeSettings();
+    }
+}
+
+class GeneralSettingsPage : public Core::IOptionsPage
+{
+public:
+    GeneralSettingsPage()
+    {
+        setId(Constants::QODE_ASSIST_GENERAL_SETTINGS_PAGE_ID);
+        setDisplayName(TrConstants::GENERAL);
+        setCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_CATEGORY);
+        setDisplayCategory(Constants::QODE_ASSIST_GENERAL_OPTIONS_DISPLAY_CATEGORY);
+        setCategoryIconPath(":/resources/images/qoderassist-icon.png");
+        setSettingsProvider([] { return &generalSettings(); });
+    }
+};
+
+const GeneralSettingsPage generalSettingsPage;
+
+} // namespace QodeAssist::Settings

settings/GeneralSettings.hpp

@@ -0,0 +1,90 @@
+/* 
+ * 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 <utils/aspects.h>
+
+#include "ButtonAspect.hpp"
+
+namespace QodeAssist::LLMCore {
+class Provider;
+}
+namespace QodeAssist::Settings {
+
+class GeneralSettings : public Utils::AspectContainer
+{
+public:
+    GeneralSettings();
+
+    Utils::BoolAspect enableQodeAssist{this};
+    Utils::BoolAspect enableLogging{this};
+    ButtonAspect resetToDefaults{this};
+
+    // code completion setttings
+    Utils::StringAspect ccProvider{this};
+    ButtonAspect ccSelectProvider{this};
+
+    Utils::StringAspect ccModel{this};
+    ButtonAspect ccSelectModel{this};
+
+    Utils::StringAspect ccTemplate{this};
+    ButtonAspect ccSelectTemplate{this};
+
+    Utils::StringAspect ccUrl{this};
+    ButtonAspect ccSetUrl{this};
+
+    Utils::StringAspect ccStatus{this};
+    ButtonAspect ccTest{this};
+
+    // chat assistant settings
+    Utils::StringAspect caProvider{this};
+    ButtonAspect caSelectProvider{this};
+
+    Utils::StringAspect caModel{this};
+    ButtonAspect caSelectModel{this};
+
+    Utils::StringAspect caTemplate{this};
+    ButtonAspect caSelectTemplate{this};
+
+    Utils::StringAspect caUrl{this};
+    ButtonAspect caSetUrl{this};
+
+    Utils::StringAspect caStatus{this};
+    ButtonAspect caTest{this};
+
+    void showSelectionDialog(const QStringList &data,
+                             Utils::StringAspect &aspect,
+                             const QString &title = {},
+                             const QString &text = {});
+
+    void showModelsNotFoundDialog(Utils::StringAspect &aspect);
+
+    void showModelsNotSupportedDialog(Utils::StringAspect &aspect);
+
+    void showUrlSelectionDialog(Utils::StringAspect &aspect, const QStringList &predefinedUrls);
+
+private:
+    void setupConnections();
+    void resetPageToDefaults();
+};
+
+GeneralSettings &generalSettings();
+
+} // namespace QodeAssist::Settings

settings/SettingsConstants.hpp

@@ -0,0 +1,109 @@
+/* 
+ * 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";
+
+// new settings
+const char CC_PROVIDER[] = "QodeAssist.ccProvider";
+const char CC_MODEL[] = "QodeAssist.ccModel";
+const char CC_MODEL_HISTORY[] = "QodeAssist.ccModelHistory";
+const char CC_TEMPLATE[] = "QodeAssist.ccTemplate";
+const char CC_URL[] = "QodeAssist.ccUrl";
+const char CC_URL_HISTORY[] = "QodeAssist.ccUrlHistory";
+
+const char CA_PROVIDER[] = "QodeAssist.caProvider";
+const char CA_MODEL[] = "QodeAssist.caModel";
+const char CA_MODEL_HISTORY[] = "QodeAssist.caModelHistory";
+const char CA_TEMPLATE[] = "QodeAssist.caTemplate";
+const char CA_URL[] = "QodeAssist.caUrl";
+const char CA_URL_HISTORY[] = "QodeAssist.caUrlHistory";
+
+// settings
+const char ENABLE_QODE_ASSIST[] = "QodeAssist.enableQodeAssist";
+const char CC_AUTO_COMPLETION[] = "QodeAssist.ccAutoCompletion";
+const char ENABLE_LOGGING[] = "QodeAssist.enableLogging";
+const char PROVIDER_PATHS[] = "QodeAssist.providerPaths";
+const char СС_START_SUGGESTION_TIMER[] = "QodeAssist.startSuggestionTimer";
+const char СС_AUTO_COMPLETION_CHAR_THRESHOLD[] = "QodeAssist.autoCompletionCharThreshold";
+const char СС_AUTO_COMPLETION_TYPING_INTERVAL[] = "QodeAssist.autoCompletionTypingInterval";
+const char MAX_FILE_THRESHOLD[] = "QodeAssist.maxFileThreshold";
+const char CC_MULTILINE_COMPLETION[] = "QodeAssist.ccMultilineCompletion";
+const char CUSTOM_JSON_TEMPLATE[] = "QodeAssist.customJsonTemplate";
+const char CA_TOKENS_THRESHOLD[] = "QodeAssist.caTokensThreshold";
+const char CA_SHARING_CURRENT_FILE[] = "QodeAssist.caSharingCurrentFile";
+
+const char QODE_ASSIST_GENERAL_OPTIONS_ID[] = "QodeAssist.GeneralOptions";
+const char QODE_ASSIST_GENERAL_SETTINGS_PAGE_ID[] = "QodeAssist.1GeneralSettingsPageId";
+const char QODE_ASSIST_CODE_COMPLETION_SETTINGS_PAGE_ID[]
+    = "QodeAssist.2CodeCompletionSettingsPageId";
+const char QODE_ASSIST_CHAT_ASSISTANT_SETTINGS_PAGE_ID[]
+    = "QodeAssist.3ChatAssistantSettingsPageId";
+const char QODE_ASSIST_CUSTOM_PROMPT_SETTINGS_PAGE_ID[] = "QodeAssist.4CustomPromptSettingsPageId";
+
+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";
+
+// context settings
+const char CC_READ_FULL_FILE[] = "QodeAssist.ccReadFullFile";
+const char CC_READ_STRINGS_BEFORE_CURSOR[] = "QodeAssist.ccReadStringsBeforeCursor";
+const char CC_READ_STRINGS_AFTER_CURSOR[] = "QodeAssist.ccReadStringsAfterCursor";
+const char CC_USE_SYSTEM_PROMPT[] = "QodeAssist.ccUseSystemPrompt";
+const char CC_USE_FILE_PATH_IN_CONTEXT[] = "QodeAssist.ccUseFilePathInContext";
+const char CC_SYSTEM_PROMPT[] = "QodeAssist.ccSystemPrompt";
+const char CC_USE_PROJECT_CHANGES_CACHE[] = "QodeAssist.ccUseProjectChangesCache";
+const char CC_MAX_CHANGES_CACHE_SIZE[] = "QodeAssist.ccMaxChangesCacheSize";
+const char CA_USE_SYSTEM_PROMPT[] = "QodeAssist.useChatSystemPrompt";
+const char CA_SYSTEM_PROMPT[] = "QodeAssist.chatSystemPrompt";
+
+// preset prompt settings
+const char CC_TEMPERATURE[] = "QodeAssist.ccTemperature";
+const char CC_MAX_TOKENS[] = "QodeAssist.ccMaxTokens";
+const char CC_USE_TOP_P[] = "QodeAssist.ccUseTopP";
+const char CC_TOP_P[] = "QodeAssist.ccTopP";
+const char CC_USE_TOP_K[] = "QodeAssist.ccUseTopK";
+const char CC_TOP_K[] = "QodeAssist.ccTopK";
+const char CC_USE_PRESENCE_PENALTY[] = "QodeAssist.ccUsePresencePenalty";
+const char CC_PRESENCE_PENALTY[] = "QodeAssist.ccPresencePenalty";
+const char CC_USE_FREQUENCY_PENALTY[] = "QodeAssist.fimUseFrequencyPenalty";
+const char CC_FREQUENCY_PENALTY[] = "QodeAssist.fimFrequencyPenalty";
+const char CC_OLLAMA_LIVETIME[] = "QodeAssist.fimOllamaLivetime";
+const char CC_OLLAMA_CONTEXT_WINDOW[] = "QodeAssist.ccOllamaContextWindow";
+const char CC_API_KEY[] = "QodeAssist.apiKey";
+const char CA_TEMPERATURE[] = "QodeAssist.chatTemperature";
+const char CA_MAX_TOKENS[] = "QodeAssist.chatMaxTokens";
+const char CA_USE_TOP_P[] = "QodeAssist.chatUseTopP";
+const char CA_TOP_P[] = "QodeAssist.chatTopP";
+const char CA_USE_TOP_K[] = "QodeAssist.chatUseTopK";
+const char CA_TOP_K[] = "QodeAssist.chatTopK";
+const char CA_USE_PRESENCE_PENALTY[] = "QodeAssist.chatUsePresencePenalty";
+const char CA_PRESENCE_PENALTY[] = "QodeAssist.chatPresencePenalty";
+const char CA_USE_FREQUENCY_PENALTY[] = "QodeAssist.chatUseFrequencyPenalty";
+const char CA_FREQUENCY_PENALTY[] = "QodeAssist.chatFrequencyPenalty";
+const char CA_OLLAMA_LIVETIME[] = "QodeAssist.chatOllamaLivetime";
+const char CA_OLLAMA_CONTEXT_WINDOW[] = "QodeAssist.caOllamaContextWindow";
+const char CA_API_KEY[] = "QodeAssist.chatApiKey";
+
+} // namespace QodeAssist::Constants

settings/SettingsDialog.cpp

@@ -0,0 +1,89 @@
+/* 
+ * 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 "SettingsDialog.hpp"
+
+namespace QodeAssist::Settings {
+
+SettingsDialog::SettingsDialog(const QString &title, QWidget *parent)
+    : QDialog(parent)
+    , m_mainLayout(new QVBoxLayout(this))
+    , m_buttonLayout(nullptr)
+{
+    setWindowTitle(title);
+    m_mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
+}
+
+QLabel *SettingsDialog::addLabel(const QString &text)
+{
+    auto label = new QLabel(text, this);
+    label->setWordWrap(true);
+    label->setMinimumWidth(300);
+    m_mainLayout->addWidget(label);
+    return label;
+}
+
+QLineEdit *SettingsDialog::addInputField(const QString &labelText, const QString &value)
+{
+    auto inputLayout = new QGridLayout;
+    auto inputLabel = new QLabel(labelText, this);
+    auto inputField = new QLineEdit(value, this);
+    inputField->setMinimumWidth(200);
+
+    inputLayout->addWidget(inputLabel, 0, 0);
+    inputLayout->addWidget(inputField, 0, 1);
+    inputLayout->setColumnStretch(1, 1);
+    m_mainLayout->addLayout(inputLayout);
+
+    return inputField;
+}
+
+void SettingsDialog::addSpacing(int space)
+{
+    m_mainLayout->addSpacing(space);
+}
+
+QHBoxLayout *SettingsDialog::buttonLayout()
+{
+    if (!m_buttonLayout) {
+        m_buttonLayout = new QHBoxLayout;
+        m_buttonLayout->addStretch();
+        m_mainLayout->addLayout(m_buttonLayout);
+    }
+    return m_buttonLayout;
+}
+
+QComboBox *SettingsDialog::addComboBox(
+    const QStringList &items, const QString &currentText, bool editable)
+{
+    auto comboBox = new QComboBox(this);
+    comboBox->addItems(items);
+    comboBox->setCurrentText(currentText);
+    comboBox->setMinimumWidth(300);
+    comboBox->setEditable(editable);
+    m_mainLayout->addWidget(comboBox);
+    return comboBox;
+}
+
+QVBoxLayout *SettingsDialog::mainLayout() const
+{
+    return m_mainLayout;
+}
+
+} // namespace QodeAssist::Settings

settings/SettingsDialog.hpp

@@ -0,0 +1,50 @@
+/* 
+ * 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 <QComboBox>
+#include <QDialog>
+#include <QLabel>
+#include <QLayout>
+#include <QLineEdit>
+#include <QWidget>
+
+#include <coreplugin/icore.h>
+
+namespace QodeAssist::Settings {
+
+class SettingsDialog : public QDialog
+{
+public:
+    explicit SettingsDialog(const QString &title, QWidget *parent = Core::ICore::dialogParent());
+
+    QLabel *addLabel(const QString &text);
+    QLineEdit *addInputField(const QString &labelText, const QString &value);
+    void addSpacing(int space = 12);
+    QHBoxLayout *buttonLayout();
+    QVBoxLayout *mainLayout() const;
+
+    QComboBox *addComboBox(
+        const QStringList &items, const QString &currentText = QString(), bool editable = true);
+
+private:
+    QVBoxLayout *m_mainLayout;
+    QHBoxLayout *m_buttonLayout;
+};
+
+} // namespace QodeAssist::Settings

settings/SettingsTr.hpp

@@ -0,0 +1,90 @@
+/* 
+ * 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::Settings {
+
+namespace TrConstants {
+inline const char *ENABLE_QODE_ASSIST = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Enable Qode Assist");
+inline const char *GENERAL = QT_TRANSLATE_NOOP("QtC::QodeAssist", "General");
+inline const char *RESET_TO_DEFAULTS = QT_TRANSLATE_NOOP("QtC::QodeAssist",
+                                                         "Reset Page to Defaults");
+inline const char *SELECT = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Select...");
+inline const char *PROVIDER = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Provider:");
+inline const char *MODEL = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Model:");
+inline const char *TEMPLATE = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Template:");
+inline const char *URL = QT_TRANSLATE_NOOP("QtC::QodeAssist", "URL:");
+inline const char *STATUS = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Status:");
+inline const char *TEST = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Test");
+inline const char *ENABLE_LOG = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Enable Logging");
+inline const char *CODE_COMPLETION = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Code Completion");
+inline const char *CHAT_ASSISTANT = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Chat Assistant");
+inline const char *RESET_SETTINGS = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Reset Settings");
+inline const char *CONFIRMATION
+    = QT_TRANSLATE_NOOP("QtC::QodeAssist",
+                        "Are you sure you want to reset all settings to default values?");
+
+inline const char CONNECTION_ERROR[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Connection Error");
+inline const char NO_MODELS_FOUND[]
+    = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Unable to retrieve the list of models from the server.");
+inline const char CHECK_CONNECTION[] = QT_TRANSLATE_NOOP(
+    "QtC::QodeAssist",
+    "Please verify the following:\n"
+    "- Server is running and accessible\n"
+    "- URL is correct\n"
+    "- Provider is properly configured\n\n"
+    "You can try selecting a different provider or changing the URL:");
+inline const char SELECT_PROVIDER[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Select Provider");
+inline const char SELECT_URL[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Select URL");
+inline const char CLOSE[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Close");
+inline const char MODEL_SELECTION[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Model Selection");
+inline const char MODEL_LISTING_NOT_SUPPORTED_INFO[] = QT_TRANSLATE_NOOP(
+    "QtC::QodeAssist",
+    "Select from previously used models or enter a new model name.\n\n"
+    "If entering a new model name:\n"
+    "• For providers with automatic listing - ensure the model is installed\n"
+    "• For providers without listing support - check provider's documentation\n"
+    "• Make sure the model name matches exactly");
+inline const char MODEL_NAME[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Model name:");
+inline const char OK[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "OK");
+inline const char CANCEL[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Cancel");
+inline const char ENTER_MODEL_MANUALLY[]
+    = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Enter Model Manually");
+inline const char URL_SELECTION[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "URL Selection");
+inline const char URL_SELECTION_INFO[] = QT_TRANSLATE_NOOP(
+    "QtC::QodeAssist",
+    "Select from the list of default and previously used URLs, or enter a custom one.\n"
+    "Please ensure the selected URL is accessible and the service is running.");
+inline const char PREDEFINED_URL[]
+    = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Use default provider URL or from history");
+inline const char CUSTOM_URL[] = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Enter custom URL");
+inline const char ENTER_MODEL_MANUALLY_BUTTON[]
+    = QT_TRANSLATE_NOOP("QtC::QodeAssist", "Enter Model Name Manually");
+
+} // namespace TrConstants
+
+struct Tr
+{
+    Q_DECLARE_TR_FUNCTIONS(QtC::QodeAssist)
+};
+
+} // namespace QodeAssist::Settings

settings/SettingsUtils.hpp

@@ -0,0 +1,81 @@
+/* 
+ * 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>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QPushButton>
+#include <QtCore/qtimer.h>
+#include <utils/aspects.h>
+#include <utils/layoutbuilder.h>
+
+namespace QodeAssist::Settings {
+
+inline bool pingUrl(const QUrl &url, int timeout = 5000)
+{
+    if (!url.isValid()) {
+        return false;
+    }
+
+    QNetworkAccessManager manager;
+    QNetworkRequest request(url);
+    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, true);
+
+    QScopedPointer<QNetworkReply> reply(manager.get(request));
+
+    QTimer timer;
+    timer.setSingleShot(true);
+
+    QEventLoop loop;
+    QObject::connect(reply.data(), &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
+
+    timer.start(timeout);
+    loop.exec();
+
+    if (timer.isActive()) {
+        timer.stop();
+        return (reply->error() == QNetworkReply::NoError);
+    } else {
+        QObject::disconnect(reply.data(), &QNetworkReply::finished, &loop, &QEventLoop::quit);
+        reply->abort();
+        return false;
+    }
+}
+
+template<typename AspectType>
+void resetAspect(AspectType &aspect)
+{
+    aspect.setVolatileValue(aspect.defaultValue());
+}
+
+inline void initStringAspect(Utils::StringAspect &aspect,
+                             const Utils::Key &settingsKey,
+                             const QString &labelText,
+                             const QString &defaultValue)
+{
+    aspect.setSettingsKey(settingsKey);
+    aspect.setLabelText(labelText);
+    aspect.setDisplayStyle(Utils::StringAspect::LineEditDisplay);
+    aspect.setDefaultValue(defaultValue);
+}
+
+} // namespace QodeAssist::Settings

templates/Alpaca.hpp

@@ -0,0 +1,67 @@
+/* 
+ * 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 "llmcore/PromptTemplate.hpp"
+#include <QJsonArray>
+
+namespace QodeAssist::Templates {
+
+class Alpaca : public LLMCore::PromptTemplate
+{
+public:
+    QString name() const override { return "Alpaca"; }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
+    QString promptTemplate() const override { return {}; }
+    QStringList stopWords() const override
+    {
+        return QStringList() << "### Instruction:" << "### Response:";
+    }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QJsonArray messages = request["messages"].toArray();
+
+        for (int i = 0; i < messages.size(); ++i) {
+            QJsonObject message = messages[i].toObject();
+            QString role = message["role"].toString();
+            QString content = message["content"].toString();
+
+            QString formattedContent;
+            if (role == "system") {
+                formattedContent = content + "\n\n";
+            } else if (role == "user") {
+                formattedContent = "### Instruction:\n" + content + "\n\n";
+            } else if (role == "assistant") {
+                formattedContent = "### Response:\n" + content + "\n\n";
+            }
+
+            message["content"] = formattedContent;
+            messages[i] = message;
+        }
+
+        request["messages"] = messages;
+    }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: ### Instruction:\n### Response:\n";
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/BasicChat.hpp

@@ -19,26 +19,22 @@
 
 #pragma once
 
-#include "PromptTemplate.hpp"
+#include <QJsonArray>
+
+#include "llmcore/PromptTemplate.hpp"
 
 namespace QodeAssist::Templates {
 
-class CodeQwenChatTemplate : public PromptTemplate
+class BasicChat : public LLMCore::PromptTemplate
 {
 public:
-    QString name() const override { return "CodeQwenChat (experimental)"; }
-    QString promptTemplate() const override { return "\n### Instruction:%1%2 ### Response:\n"; }
-    QStringList stopWords() const override
-    {
-        return QStringList() << "### Instruction:" << "### Response:" << "\n\n### ";
-    }
-    void prepareRequest(QJsonObject &request,
-                        const QString &prefix,
-                        const QString &suffix) const override
-    {
-        QString formattedPrompt = promptTemplate().arg(prefix, suffix);
-        request["prompt"] = formattedPrompt;
-    }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
+    QString name() const override { return "Basic Chat"; }
+    QString promptTemplate() const override { return {}; }
+    QStringList stopWords() const override { return QStringList(); }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {}
+    QString description() const override { return "chat without tokens"; }
 };
 
 } // namespace QodeAssist::Templates

templates/ChatML.hpp

@@ -0,0 +1,60 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QJsonArray>
+
+#include "llmcore/PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class ChatML : public LLMCore::PromptTemplate
+{
+public:
+    QString name() const override { return "ChatML"; }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
+    QString promptTemplate() const override { return {}; }
+    QStringList stopWords() const override
+    {
+        return QStringList() << "<|im_start|>" << "<|im_end|>";
+    }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QJsonArray messages = request["messages"].toArray();
+
+        for (int i = 0; i < messages.size(); ++i) {
+            QJsonObject message = messages[i].toObject();
+            QString role = message["role"].toString();
+            QString content = message["content"].toString();
+
+            message["content"] = QString("<|im_start|>%1\n%2\n<|im_end|>").arg(role, content);
+
+            messages[i] = message;
+        }
+
+        request["messages"] = messages;
+    }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: <|im_start|>%1\n%2\n<|im_end|>";
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/CodeLlamaFim.hpp

@@ -19,27 +19,29 @@
 
 #pragma once
 
-#include "PromptTemplate.hpp"
+#include "llmcore/PromptTemplate.hpp"
 
 namespace QodeAssist::Templates {
 
-class CodeLLamaTemplate : public PromptTemplate
+class CodeLlamaFim : public LLMCore::PromptTemplate
 {
 public:
-    QString name() const override { return "CodeLlama"; }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Fim; }
+    QString name() const override { return "CodeLlama FIM"; }
     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
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
     {
-        QString formattedPrompt = promptTemplate().arg(prefix, suffix);
+        QString formattedPrompt = promptTemplate().arg(context.prefix, context.suffix);
         request["prompt"] = formattedPrompt;
     }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: <PRE> %1 <SUF>%2 <MID>";
+    }
 };
 
 } // namespace QodeAssist::Templates

templates/CustomFimTemplate.hpp

@@ -0,0 +1,90 @@
+/* 
+ * 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 "llmcore/PromptTemplate.hpp"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+
+#include "logger/Logger.hpp"
+#include "settings/CustomPromptSettings.hpp"
+
+namespace QodeAssist::Templates {
+
+class CustomTemplate : public LLMCore::PromptTemplate
+{
+public:
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Fim; }
+    QString name() const override { return "Custom FIM Template"; }
+    QString promptTemplate() const override
+    {
+        return Settings::customPromptSettings().customJsonTemplate();
+    }
+    QStringList stopWords() const override { return QStringList(); }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QJsonDocument doc = QJsonDocument::fromJson(promptTemplate().toUtf8());
+        if (doc.isNull() || !doc.isObject()) {
+            LOG_MESSAGE(QString("Invalid JSON template in settings"));
+
+            return;
+        }
+
+        QJsonObject templateObj = doc.object();
+        QJsonObject processedObj = processJsonTemplate(templateObj, context);
+
+        for (auto it = processedObj.begin(); it != processedObj.end(); ++it) {
+            request[it.key()] = it.value();
+        }
+    }
+    QString description() const override { return promptTemplate(); }
+
+private:
+    QJsonValue processJsonValue(const QJsonValue &value, const LLMCore::ContextData &context) const
+    {
+        if (value.isString()) {
+            QString str = value.toString();
+            str.replace("{{QODE_PREFIX}}", context.prefix);
+            str.replace("{{QODE_SUFFIX}}", context.suffix);
+            return str;
+        } else if (value.isObject()) {
+            return processJsonTemplate(value.toObject(), context);
+        } else if (value.isArray()) {
+            QJsonArray newArray;
+            for (const QJsonValue &arrayValue : value.toArray()) {
+                newArray.append(processJsonValue(arrayValue, context));
+            }
+            return newArray;
+        }
+        return value;
+    }
+
+    QJsonObject processJsonTemplate(const QJsonObject &templateObj,
+                                    const LLMCore::ContextData &context) const
+    {
+        QJsonObject result;
+        for (auto it = templateObj.begin(); it != templateObj.end(); ++it) {
+            result[it.key()] = processJsonValue(it.value(), context);
+        }
+        return result;
+    }
+};
+} // namespace QodeAssist::Templates

templates/DeepSeekCoderFim.hpp

@@ -0,0 +1,48 @@
+/* 
+ * 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 "llmcore/PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class DeepSeekCoderFim : public LLMCore::PromptTemplate
+{
+public:
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Fim; }
+    QString name() const override { return "DeepSeekCoder FIM"; }
+    QString promptTemplate() const override
+    {
+        return "<｜fim▁begin｜>%1<｜fim▁hole｜>%2<｜fim▁end｜>";
+    }
+    QStringList stopWords() const override { return QStringList(); }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QString formattedPrompt = promptTemplate().arg(context.prefix, context.suffix);
+        request["prompt"] = formattedPrompt;
+    }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: "
+               "<｜fim▁begin｜>%1<｜fim▁hole｜>%2<｜fim▁end｜>";
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/Llama2.hpp

@@ -0,0 +1,64 @@
+/* 
+ * Copyright (C) 2024 Petr Mironychev
+ *
+ * This file is part of QodeAssist.
+ *
+ * QodeAssist is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QodeAssist is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "llmcore/PromptTemplate.hpp"
+#include <QJsonArray>
+
+namespace QodeAssist::Templates {
+
+class Llama2 : public LLMCore::PromptTemplate
+{
+public:
+    QString name() const override { return "Llama 2"; }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
+    QString promptTemplate() const override { return {}; }
+    QStringList stopWords() const override { return QStringList() << "[INST]"; }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QJsonArray messages = request["messages"].toArray();
+
+        for (int i = 0; i < messages.size(); ++i) {
+            QJsonObject message = messages[i].toObject();
+            QString role = message["role"].toString();
+            QString content = message["content"].toString();
+
+            QString formattedContent;
+            if (role == "system") {
+                formattedContent = QString("[INST]<<SYS>>\n%1\n<</SYS>>[/INST]\n").arg(content);
+            } else if (role == "user") {
+                formattedContent = QString("[INST]%1[/INST]\n").arg(content);
+            } else if (role == "assistant") {
+                formattedContent = content + "\n";
+            }
+
+            message["content"] = formattedContent;
+            messages[i] = message;
+        }
+
+        request["messages"] = messages;
+    }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: [INST]%1[/INST]\n";
+    }
+};
+
+} // namespace QodeAssist::Templates

templates/Llama3.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
+
+#include <QJsonArray>
+
+#include "llmcore/PromptTemplate.hpp"
+
+namespace QodeAssist::Templates {
+
+class Llama3 : public LLMCore::PromptTemplate
+{
+public:
+    QString name() const override { return "Llama 3"; }
+    LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
+    QString promptTemplate() const override { return ""; }
+    QStringList stopWords() const override
+    {
+        return QStringList() << "<|start_header_id|>" << "<|end_header_id|>" << "<|eot_id|>";
+    }
+    void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
+    {
+        QJsonArray messages = request["messages"].toArray();
+
+        for (int i = 0; i < messages.size(); ++i) {
+            QJsonObject message = messages[i].toObject();
+            QString role = message["role"].toString();
+            QString content = message["content"].toString();
+
+            message["content"]
+                = QString("<|start_header_id|>%1<|end_header_id|>%2<|eot_id|>").arg(role, content);
+
+            messages[i] = message;
+        }
+
+        request["messages"] = messages;
+    }
+    QString description() const override
+    {
+        return "The message will contain the following tokens: "
+               "<|start_header_id|>%1<|end_header_id|>%2<|eot_id|>";
+    }
+};
+
+} // namespace QodeAssist::Templates