chore: Upgrade plugin to 0.7.1

feat: Add support QtC 17.0.2

.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: ['https://www.paypal.com/paypalme/palm1r', 'https://github.com/Palm1r/QodeAssist#support-the-development-of-qodeassist']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+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.
+
+**Log**
+**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,109 @@
+{
+    "name": "QodeAssist",
+    "vendor": "Petr Mironychev",
+    "tags": [
+        "code assistant",
+        "llm",
+        "ai"
+    ],
+    "compatibility": "Qt 6.8.3",
+    "platforms": [
+        "Windows",
+        "macOS",
+        "Linux"
+    ],
+    "license": "GPLv3",
+    "version": "0.5.11",
+    "status": "draft",
+    "is_pack": false,
+    "released_at": null,
+    "version_history": [
+        {
+            "version": "0.4.0",
+            "is_latest": false,
+            "released_at": "2024-01-24T15:00:00Z"
+        },
+        {
+            "version": "0.5.2",
+            "is_latest": false,
+            "released_at": "2025-03-13T17:00:00Z"
+        },
+        {
+            "version": "0.5.3",
+            "is_latest": false,
+            "released_at": "2025-03-14T11:00:00Z"
+        },
+        {
+            "version": "0.5.4",
+            "is_latest": false,
+            "released_at": "2025-03-17T03:00:00Z"
+        },
+        {
+            "version": "0.5.5",
+            "is_latest": false,
+            "released_at": "2025-03-20T19:00:00Z"
+        },
+        {
+            "version": "0.5.6",
+            "is_latest": false,
+            "released_at": "2025-04-04T19:00:00Z"
+        },
+        {
+            "version": "0.5.7",
+            "is_latest": false,
+            "released_at": "2025-04-14T01:00:00Z"
+        },
+        {
+            "version": "0.5.8",
+            "is_latest": false,
+            "released_at": "2025-04-17T10:00:00Z"
+        },
+        {
+            "version": "0.5.9",
+            "is_latest": false,
+            "released_at": "2025-04-21T10:00:00Z"
+        },
+        {
+            "version": "0.5.10",
+            "is_latest": false,
+            "released_at": "2025-04-24T10:00:00Z"
+        },
+        {
+            "version": "0.5.11",
+            "is_latest": false,
+            "released_at": "2025-04-24T21:00:00Z"
+        },
+        {
+            "version": "0.5.12",
+            "is_latest": true,
+            "released_at": "2025-05-01T17: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,19 +1,24 @@
 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
   MACOS_DEPLOYMENT_TARGET: "11.0"
   CMAKE_VERSION: "3.29.6"
   NINJA_VERSION: "1.12.1"
 
 jobs:
   build:
-    name: ${{ matrix.config.name }}
+    name: ${{ matrix.config.name }} (Qt ${{ matrix.qt_config.qt_version }}, QtC ${{ matrix.qt_config.qt_creator_version }})
     runs-on: ${{ matrix.config.os }}
     outputs:
         tag: ${{ steps.git.outputs.tag }}
@@ -23,76 +28,57 @@ 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,
+            name: "Ubuntu 22.04 GCC", artifact: "Linux-x64",
+            os: ubuntu-22.04,
+            platform: linux_x64,
             cc: "gcc", cxx: "g++"
           }
         - {
             name: "macOS Latest Clang", artifact: "macOS-universal",
             os: macos-latest,
+            platform: mac_x64,
             cc: "clang", cxx: "clang++"
           }
+        qt_config:
+        - {
+            qt_version: "6.9.2",
+            qt_creator_version: "17.0.2"
+          }
+        - {
+            qt_version: "6.8.3",
+            qt_creator_version: "16.0.2"
+          }
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955
+
     - 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")
+            execute_process(
+                COMMAND git rev-parse --short HEAD
+                OUTPUT_VARIABLE short_sha
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+            )
+            file(APPEND "$ENV{GITHUB_OUTPUT}" "tag=${short_sha}")
         endif()
 
     - name: Download Ninja and CMake
-      shell: cmake -P {0}
-      run: |
-        set(cmake_version "$ENV{CMAKE_VERSION}")
-        set(ninja_version "$ENV{NINJA_VERSION}")
+      uses: lukka/get-cmake@2ecc21724e5215b0e567bc399a2602d2ecb48541
+      with:
+        cmakeVersion: ${{ env.CMAKE_VERSION }}
+        ninjaVersion: ${{ env.NINJA_VERSION }}
 
-        if ("${{ runner.os }}" STREQUAL "Windows")
-          set(ninja_suffix "win.zip")
-          set(cmake_suffix "windows-x86_64.zip")
-          set(cmake_dir "cmake-${cmake_version}-windows-x86_64/bin")
-        elseif ("${{ runner.os }}" STREQUAL "Linux")
-          set(ninja_suffix "linux.zip")
-          set(cmake_suffix "linux-x86_64.tar.gz")
-          set(cmake_dir "cmake-${cmake_version}-linux-x86_64/bin")
-        elseif ("${{ runner.os }}" STREQUAL "macOS")
-          set(ninja_suffix "mac.zip")
-          set(cmake_suffix "macos-universal.tar.gz")
-          set(cmake_dir "cmake-${cmake_version}-macos-universal/CMake.app/Contents/bin")
-        endif()
-
-        set(ninja_url "https://github.com/ninja-build/ninja/releases/download/v${ninja_version}/ninja-${ninja_suffix}")
-        file(DOWNLOAD "${ninja_url}" ./ninja.zip SHOW_PROGRESS)
-        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ninja.zip)
-
-        set(cmake_url "https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-${cmake_suffix}")
-        file(DOWNLOAD "${cmake_url}" ./cmake.zip SHOW_PROGRESS)
-        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./cmake.zip)
-
-        # Add to PATH environment variable
-        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/${cmake_dir}" cmake_dir)
-        set(path_separator ":")
-        if ("${{ runner.os }}" STREQUAL "Windows")
-          set(path_separator ";")
-        endif()
-        file(APPEND "$ENV{GITHUB_PATH}" "$ENV{GITHUB_WORKSPACE}${path_separator}${cmake_dir}")
-
-        if (NOT "${{ runner.os }}" STREQUAL "Windows")
-          execute_process(
-            COMMAND chmod +x ninja
-            COMMAND chmod +x ${cmake_dir}/cmake
-          )
-        endif()
-
-    - name: Install system libs
+    - name: Install dependencies
       shell: cmake -P {0}
       run: |
         if ("${{ runner.os }}" STREQUAL "Linux")
@@ -100,7 +86,13 @@ jobs:
             COMMAND sudo apt update
           )
           execute_process(
-            COMMAND sudo apt install libgl1-mesa-dev
+            COMMAND sudo apt install
+              # build dependencies
+              libgl1-mesa-dev libgtest-dev libgmock-dev
+              # runtime dependencies for tests (Qt is downloaded outside package manager,
+              # thus minimal dependencies must be installed explicitly)
+              libsecret-1-0 libxcb-cursor0 libxcb-icccm4 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-render0
+              libxcb-shape0 libxcb-shm0 libxcb-sync1 libxcb-xfixes0 libxcb-xkb1 libxkbcommon-x11-0 xvfb
             RESULT_VARIABLE result
           )
           if (NOT result EQUAL 0)
@@ -112,14 +104,14 @@ jobs:
       id: qt
       shell: cmake -P {0}
       run: |
-        set(qt_version "$ENV{QT_VERSION}")
+        set(qt_version "${{ matrix.qt_config.qt_version }}")
 
         string(REPLACE "." "" qt_version_dotless "${qt_version}")
         if ("${{ runner.os }}" STREQUAL "Windows")
           set(url_os "windows_x86")
-          set(qt_package_arch_suffix "win64_msvc2019_64")
-          set(qt_dir_prefix "${qt_version}/msvc2019_64")
-          set(qt_package_suffix "-Windows-Windows_10_22H2-MSVC2019-Windows-Windows_10_22H2-X86_64")
+          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 +120,19 @@ 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")
+          if (qt_version VERSION_LESS "6.9.1")
+            set(qt_package_suffix "-MacOS-MacOS_14-Clang-MacOS-MacOS_14-X86_64-ARM64")
+          else()
+            set(qt_package_suffix "-MacOS-MacOS_15-Clang-MacOS-MacOS_15-X86_64-ARM64")
+          endif()
         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 +142,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}")
@@ -156,7 +152,7 @@ jobs:
           execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ../${archive} WORKING_DIRECTORY qt6)
         endfunction()
 
-        foreach(package qtbase qtdeclarative)
+        foreach(package qtbase qtdeclarative qttools)
           downloadAndExtract(
             "${qt_base_url}/qt.qt6.${qt_version_dotless}.${qt_package_arch_suffix}/${qt_package_version}${package}${qt_package_suffix}.7z"
             ${package}.7z
@@ -165,11 +161,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 +179,26 @@ 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@4046eda2efa77c0fe61d4cde7e622c050a4d65af
+      with:
+        version: ${{ matrix.qt_config.qt_creator_version }}
+        unzip-to: 'qtcreator'
+        platform: ${{ matrix.config.platform }}
+
+    - 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: |
@@ -255,7 +236,7 @@ jobs:
           COMMAND python
             -u
             "${{ steps.qt_creator.outputs.qtc_dir }}/${build_plugin_py}"
-            --name "$ENV{PLUGIN_NAME}-$ENV{QT_CREATOR_VERSION}-${{ matrix.config.artifact }}"
+            --name "$ENV{PLUGIN_NAME}-v${{ steps.git.outputs.tag }}-QtC${{ matrix.qt_config.qt_creator_version }}-${{ matrix.config.artifact }}"
             --src .
             --build build
             --qt-path "${{ steps.qt.outputs.qt_dir }}"
@@ -271,19 +252,24 @@ jobs:
         endif()
 
     - name: Upload
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
       with:
-        path: ./${{ env.PLUGIN_NAME }}-${{ env.QT_CREATOR_VERSION }}-${{ matrix.config.artifact }}.7z
-        name: ${{ env.PLUGIN_NAME}}-${{ env.QT_CREATOR_VERSION }}-${{ matrix.config.artifact }}.7z
+        path: ./${{ env.PLUGIN_NAME }}-v${{ steps.git.outputs.tag }}-QtC${{ matrix.qt_config.qt_creator_version }}-${{ matrix.config.artifact }}.7z
+        name: ${{ env.PLUGIN_NAME}}-v${{ steps.git.outputs.tag }}-QtC${{ matrix.qt_config.qt_creator_version }}-${{ matrix.config.artifact }}.7z
+
+    - name: Run unit tests
+      if: startsWith(matrix.config.os, 'ubuntu')
+      run: |
+        xvfb-run ./build/build/test/QodeAssistTest
 
   release:
     if: contains(github.ref, 'tags/v')
-    runs-on: ubuntu-latest
-    needs: build
+    runs-on: ubuntu-22.04
+    needs: [build]
 
     steps:
     - name: Download artifacts
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
       with:
         path: release-with-dirs
 
@@ -294,7 +280,7 @@ jobs:
 
     - name: Create Release
       id: create_release
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@6cbd405e2c4e67a21c47fa9e383d020e4e28b836
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:

.gitignore

@@ -34,6 +34,7 @@ Thumbs.db
 *.rc
 /.qmake.cache
 /.qmake.stash
+.qmlls.ini
 
 # qtcreator generated files
 *.pro.user*
@@ -72,4 +73,5 @@ CMakeLists.txt.user*
 *.dll
 *.exe
 
-/build
+/build
+/.qodeassist

.qmlformat.ini

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

CMakeLists.txt

@@ -8,20 +8,57 @@ set(CMAKE_AUTOUIC ON)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 find_package(QtCreator REQUIRED COMPONENTS Core)
-find_package(Qt6 COMPONENTS Widgets REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Quick Widgets Network Test LinguistTools REQUIRED)
+find_package(GTest)
+
+qt_standard_project_setup(I18N_TRANSLATED_LANGUAGES en)
+
+# IDE_VERSION is defined by QtCreator package
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" version_match ${IDE_VERSION})
+set(QODEASSIST_QT_CREATOR_VERSION_MAJOR ${CMAKE_MATCH_1})
+set(QODEASSIST_QT_CREATOR_VERSION_MINOR ${CMAKE_MATCH_2})
+set(QODEASSIST_QT_CREATOR_VERSION_PATCH ${CMAKE_MATCH_3})
+
+if(NOT version_match)
+    message(FATAL_ERROR "Failed to parse Qt Creator version string: ${IDE_VERSION}")
+endif()
+
+message(STATUS "Qt Creator Version: ${QODEASSIST_QT_CREATOR_VERSION_MAJOR}.${QODEASSIST_QT_CREATOR_VERSION_MINOR}.${QODEASSIST_QT_CREATOR_VERSION_PATCH}")
+
+add_definitions(
+  -DQODEASSIST_QT_CREATOR_VERSION_MAJOR=${QODEASSIST_QT_CREATOR_VERSION_MAJOR}
+  -DQODEASSIST_QT_CREATOR_VERSION_MINOR=${QODEASSIST_QT_CREATOR_VERSION_MINOR}
+  -DQODEASSIST_QT_CREATOR_VERSION_PATCH=${QODEASSIST_QT_CREATOR_VERSION_PATCH}
+)
+
+add_subdirectory(llmcore)
+add_subdirectory(settings)
+add_subdirectory(logger)
+add_subdirectory(UIControls)
+add_subdirectory(ChatView)
+add_subdirectory(context)
+if(GTest_FOUND)
+  add_subdirectory(test)
+endif()
 
 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,20 +67,85 @@ 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
-    providers/LLMProvider.hpp
+    templates/Templates.hpp
+    templates/CodeLlamaFim.hpp
+    templates/Ollama.hpp
+    templates/Claude.hpp
+    templates/OpenAI.hpp
+    templates/MistralAI.hpp
+    templates/StarCoder2Fim.hpp
+    # templates/DeepSeekCoderFim.hpp
+    # templates/CustomFimTemplate.hpp
+    templates/Qwen25CoderFIM.hpp
+    templates/OpenAICompatible.hpp
+    templates/Llama3.hpp
+    templates/ChatML.hpp
+    templates/Alpaca.hpp
+    templates/Llama2.hpp
+    templates/CodeLlamaQMLFim.hpp
+    templates/GoogleAI.hpp
+    templates/LlamaCppFim.hpp
+    templates/Qwen3CoderFIM.hpp
+    providers/Providers.hpp
     providers/OllamaProvider.hpp providers/OllamaProvider.cpp
+    providers/ClaudeProvider.hpp providers/ClaudeProvider.cpp
+    providers/OpenAIProvider.hpp providers/OpenAIProvider.cpp
+    providers/MistralAIProvider.hpp providers/MistralAIProvider.cpp
     providers/LMStudioProvider.hpp providers/LMStudioProvider.cpp
-    LLMProvidersManager.hpp LLMProvidersManager.cpp
-    QodeAssistSettings.hpp QodeAssistSettings.cpp
+    providers/OpenAICompatProvider.hpp providers/OpenAICompatProvider.cpp
+    providers/OpenRouterAIProvider.hpp providers/OpenRouterAIProvider.cpp
+    providers/GoogleAIProvider.hpp providers/GoogleAIProvider.cpp
+    providers/LlamaCppProvider.hpp providers/LlamaCppProvider.cpp
+    providers/CodestralProvider.hpp providers/CodestralProvider.cpp
     QodeAssist.qrc
     LSPCompletion.hpp
     LLMSuggestion.hpp LLMSuggestion.cpp
-    QodeAssistHoverHandler.hpp QodeAssistHoverHandler.cpp
     QodeAssistClient.hpp QodeAssistClient.cpp
-    QodeAssistUtils.hpp
-    DocumentContextReader.hpp DocumentContextReader.cpp
+    chat/ChatOutputPane.h chat/ChatOutputPane.cpp
+    chat/NavigationPanel.hpp chat/NavigationPanel.cpp
+    ConfigurationManager.hpp ConfigurationManager.cpp
+    CodeHandler.hpp CodeHandler.cpp
+    UpdateStatusWidget.hpp UpdateStatusWidget.cpp
+    widgets/CompletionProgressHandler.hpp widgets/CompletionProgressHandler.cpp
+    widgets/ProgressWidget.hpp widgets/ProgressWidget.cpp
+    widgets/EditorChatButton.hpp widgets/EditorChatButton.cpp
+    widgets/EditorChatButtonHandler.hpp widgets/EditorChatButtonHandler.cpp
+    widgets/QuickRefactorDialog.hpp widgets/QuickRefactorDialog.cpp
+    QuickRefactorHandler.hpp QuickRefactorHandler.cpp
+    tools/ToolsFactory.hpp tools/ToolsFactory.cpp
+    tools/ReadProjectFileByNameTool.hpp tools/ReadProjectFileByNameTool.cpp
+    tools/ReadVisibleFilesTool.hpp tools/ReadVisibleFilesTool.cpp
+    tools/ToolHandler.hpp tools/ToolHandler.cpp
+    tools/ListProjectFilesTool.hpp tools/ListProjectFilesTool.cpp
+    tools/ToolsManager.hpp tools/ToolsManager.cpp
+    tools/SearchInProjectTool.hpp tools/SearchInProjectTool.cpp
+    tools/GetIssuesListTool.hpp tools/GetIssuesListTool.cpp
+    providers/ClaudeMessage.hpp providers/ClaudeMessage.cpp
+    providers/OpenAIMessage.hpp providers/OpenAIMessage.cpp
+    providers/OllamaMessage.hpp providers/OllamaMessage.cpp
+    providers/GoogleMessage.hpp providers/GoogleMessage.cpp
+)
+
+get_target_property(QtCreatorCorePath QtCreator::Core LOCATION)
+find_program(QtCreatorExecutable
+  NAMES
+    qtcreator "Qt Creator"
+  PATHS
+    "${QtCreatorCorePath}/../../../bin"
+    "${QtCreatorCorePath}/../../../MacOS"
+  NO_DEFAULT_PATH
+)
+if (QtCreatorExecutable)
+  add_custom_target(RunQtCreator
+    COMMAND ${QtCreatorExecutable} -pluginpath $<TARGET_FILE_DIR:QodeAssist>
+    DEPENDS QodeAssist
+  )
+  set_target_properties(RunQtCreator PROPERTIES FOLDER "qtc_runnable")
+endif()
+
+#TODO change to TS_OUTPUT_DIRECTORY after removing Qt6.8
+qt_add_translations(TARGETS QodeAssist
+          TS_FILE_DIR ${CMAKE_CURRENT_LIST_DIR}/resources/translations
+          RESOURCE_PREFIX "/translations"
+          LUPDATE_OPTIONS -no-obsolete
 )

ChatView/CMakeLists.txt

@@ -0,0 +1,65 @@
+qt_add_library(QodeAssistChatView STATIC)
+
+qt_policy(SET QTP0001 NEW)
+qt_policy(SET QTP0004 NEW)
+
+qt_add_qml_module(QodeAssistChatView
+    URI ChatView
+    VERSION 1.0
+    DEPENDENCIES
+    QtQuick
+    QML_FILES
+    qml/RootItem.qml
+    qml/ChatItem.qml
+    qml/dialog/CodeBlock.qml
+    qml/dialog/TextBlock.qml
+    qml/parts/TopBar.qml
+    qml/parts/BottomBar.qml
+    qml/parts/AttachedFilesPlace.qml
+    qml/parts/ErrorToast.qml
+    qml/ToolStatusItem.qml
+
+    RESOURCES
+    icons/attach-file-light.svg
+    icons/attach-file-dark.svg
+    icons/close-dark.svg
+    icons/close-light.svg
+    icons/link-file-light.svg
+    icons/link-file-dark.svg
+    icons/load-chat-dark.svg
+    icons/save-chat-dark.svg
+    icons/clean-icon-dark.svg
+    icons/file-in-system.svg
+    icons/window-lock.svg
+    icons/window-unlock.svg
+    icons/chat-icon.svg
+    icons/chat-pause-icon.svg
+    SOURCES
+    ChatWidget.hpp ChatWidget.cpp
+    ChatModel.hpp ChatModel.cpp
+    ChatRootView.hpp ChatRootView.cpp
+    ClientInterface.hpp ClientInterface.cpp
+    MessagePart.hpp
+    ChatUtils.h ChatUtils.cpp
+    ChatSerializer.hpp ChatSerializer.cpp
+    ChatView.hpp ChatView.cpp
+    ChatData.hpp
+)
+
+target_link_libraries(QodeAssistChatView
+    PUBLIC
+    Qt::Widgets
+    Qt::Quick
+    Qt::QuickWidgets
+    Qt::Network
+    QtCreator::Core
+    QtCreator::Utils
+    LLMCore
+    QodeAssistSettings
+    Context
+    QodeAssistUIControlsplugin
+)
+
+target_include_directories(QodeAssistChatView
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
+)

ChatView/ChatData.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2025 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 <QtQmlIntegration>
+
+namespace QodeAssist::Chat {
+Q_NAMESPACE
+QML_NAMED_ELEMENT(MessagePartType)
+
+enum class MessagePartType { Code, Text };
+Q_ENUM_NS(MessagePartType)
+
+} // namespace QodeAssist::Chat

ChatView/ChatModel.cpp

@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2024-2025 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 <utils/aspects.h>
+#include <QtCore/qjsonobject.h>
+#include <QtQml>
+
+#include "ChatAssistantSettings.hpp"
+#include "Logger.hpp"
+
+namespace QodeAssist::Chat {
+
+ChatModel::ChatModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    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;
+    }
+    case Roles::Attachments: {
+        QStringList filenames;
+        for (const auto &attachment : message.attachments) {
+            filenames << attachment.filename;
+        }
+        return filenames;
+    }
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> ChatModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[Roles::RoleType] = "roleType";
+    roles[Roles::Content] = "content";
+    roles[Roles::Attachments] = "attachments";
+    return roles;
+}
+
+void ChatModel::addMessage(
+    const QString &content,
+    ChatRole role,
+    const QString &id,
+    const QList<Context::ContentFile> &attachments)
+{
+    QString fullContent = content;
+    if (!attachments.isEmpty()) {
+        fullContent += "\n\nAttached files list:";
+        for (const auto &attachment : attachments) {
+            fullContent += QString("\nname: %1\nfile content:\n%2")
+                               .arg(attachment.filename, attachment.content);
+        }
+    }
+
+    if (!m_messages.isEmpty() && !id.isEmpty() && m_messages.last().id == id
+        && m_messages.last().role == role) {
+        Message &lastMessage = m_messages.last();
+        lastMessage.content = content;
+        lastMessage.attachments = attachments;
+        emit dataChanged(index(m_messages.size() - 1), index(m_messages.size() - 1));
+    } else {
+        beginInsertRows(QModelIndex(), m_messages.size(), m_messages.size());
+        Message newMessage{role, content, id};
+        newMessage.attachments = attachments;
+        m_messages.append(newMessage);
+        endInsertRows();
+    }
+}
+
+QVector<ChatModel::Message> ChatModel::getChatHistory() const
+{
+    return m_messages;
+}
+
+void ChatModel::clear()
+{
+    beginResetModel();
+    m_messages.clear();
+    endResetModel();
+    emit modelReseted();
+}
+
+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);
+    bool foundCodeBlock = blockMatches.hasNext();
+
+    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({MessagePartType::Text, textBetween, ""});
+            }
+        }
+        parts.append({MessagePartType::Code, match.captured(2).trimmed(), match.captured(1)});
+        lastIndex = match.capturedEnd();
+    }
+
+    if (lastIndex < content.length()) {
+        QString remainingText = content.mid(lastIndex).trimmed();
+
+        QRegularExpression unclosedBlockRegex("```(\\w*)\\n?([\\s\\S]*)$");
+        auto unclosedMatch = unclosedBlockRegex.match(remainingText);
+
+        if (unclosedMatch.hasMatch()) {
+            QString beforeCodeBlock = remainingText.left(unclosedMatch.capturedStart()).trimmed();
+            if (!beforeCodeBlock.isEmpty()) {
+                parts.append({MessagePartType::Text, beforeCodeBlock, ""});
+            }
+
+            parts.append(
+                {MessagePartType::Code,
+                 unclosedMatch.captured(2).trimmed(),
+                 unclosedMatch.captured(1)});
+        } else if (!remainingText.isEmpty()) {
+            parts.append({MessagePartType::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;
+        }
+
+        QString content
+            = message.attachments.isEmpty()
+                  ? message.content
+                  : message.content + "\n\nAttached files list:"
+                        + std::accumulate(
+                            message.attachments.begin(),
+                            message.attachments.end(),
+                            QString(),
+                            [](QString acc, const Context::ContentFile &attachment) {
+                                return acc
+                                       + QString("\nname: %1\nfile content:\n%2")
+                                             .arg(attachment.filename, attachment.content);
+                            });
+
+        messages.append(QJsonObject{{"role", role}, {"content", content}});
+    }
+
+    return messages;
+}
+
+int ChatModel::tokensThreshold() const
+{
+    auto &settings = Settings::chatAssistantSettings();
+    return settings.chatTokensThreshold();
+}
+
+QString ChatModel::lastMessageId() const
+{
+    return !m_messages.isEmpty() ? m_messages.last().id : "";
+}
+
+void ChatModel::resetModelTo(int index)
+{
+    if (index < 0 || index >= m_messages.size())
+        return;
+
+    if (index < m_messages.size()) {
+        beginRemoveRows(QModelIndex(), index, m_messages.size() - 1);
+        m_messages.remove(index, m_messages.size() - index);
+        endRemoveRows();
+    }
+}
+
+void ChatModel::addToolExecutionStatus(
+    const QString &requestId, const QString &toolId, const QString &toolName)
+{
+    QString content = toolName;
+
+    LOG_MESSAGE(QString("Adding tool execution status: requestId=%1, toolId=%2, toolName=%3")
+                    .arg(requestId, toolId, toolName));
+
+    if (!m_messages.isEmpty() && !toolId.isEmpty() && m_messages.last().id == toolId
+        && m_messages.last().role == ChatRole::Tool) {
+        Message &lastMessage = m_messages.last();
+        lastMessage.content = content;
+        LOG_MESSAGE(QString("Updated existing tool message at index %1").arg(m_messages.size() - 1));
+        emit dataChanged(index(m_messages.size() - 1), index(m_messages.size() - 1));
+    } else {
+        beginInsertRows(QModelIndex(), m_messages.size(), m_messages.size());
+        Message newMessage{ChatRole::Tool, content, toolId};
+        m_messages.append(newMessage);
+        endInsertRows();
+        LOG_MESSAGE(QString("Created new tool message at index %1 with toolId=%2")
+                        .arg(m_messages.size() - 1)
+                        .arg(toolId));
+    }
+}
+
+void ChatModel::updateToolResult(
+    const QString &requestId, const QString &toolId, const QString &toolName, const QString &result)
+{
+    if (m_messages.isEmpty() || toolId.isEmpty()) {
+        LOG_MESSAGE(QString("Cannot update tool result: messages empty=%1, toolId empty=%2")
+                        .arg(m_messages.isEmpty())
+                        .arg(toolId.isEmpty()));
+        return;
+    }
+
+    LOG_MESSAGE(
+        QString("Updating tool result: requestId=%1, toolId=%2, toolName=%3, result length=%4")
+            .arg(requestId, toolId, toolName)
+            .arg(result.length()));
+
+    for (int i = m_messages.size() - 1; i >= 0; --i) {
+        if (m_messages[i].id == toolId && m_messages[i].role == ChatRole::Tool) {
+            m_messages[i].content = toolName + "\n" + result;
+            emit dataChanged(index(i), index(i));
+            LOG_MESSAGE(QString("Updated tool result at index %1").arg(i));
+            return;
+        }
+    }
+
+    LOG_MESSAGE(QString("WARNING: Tool message with requestId=%1 toolId=%2 not found!")
+                    .arg(requestId, toolId));
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatModel.hpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2024-2025 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>
+
+#include "context/ContentFile.hpp"
+
+namespace QodeAssist::Chat {
+
+class ChatModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int tokensThreshold READ tokensThreshold NOTIFY tokensThresholdChanged FINAL)
+    QML_ELEMENT
+
+public:
+    enum ChatRole { System, User, Assistant, Tool };
+    Q_ENUM(ChatRole)
+
+    enum Roles { RoleType = Qt::UserRole, Content, Attachments };
+    Q_ENUM(Roles)
+
+    struct Message
+    {
+        ChatRole role;
+        QString content;
+        QString id;
+
+        QList<Context::ContentFile> attachments;
+    };
+
+    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,
+        const QList<Context::ContentFile> &attachments = {});
+    Q_INVOKABLE void clear();
+    Q_INVOKABLE QList<MessagePart> processMessageContent(const QString &content) const;
+
+    QVector<Message> getChatHistory() const;
+    QJsonArray prepareMessagesForRequest(const QString &systemPrompt) const;
+
+    int tokensThreshold() const;
+
+    QString currentModel() const;
+    QString lastMessageId() const;
+
+    Q_INVOKABLE void resetModelTo(int index);
+
+    void addToolExecutionStatus(
+        const QString &requestId, const QString &toolId, const QString &toolName);
+    void updateToolResult(
+        const QString &requestId,
+        const QString &toolId,
+        const QString &toolName,
+        const QString &result);
+signals:
+    void tokensThresholdChanged();
+    void modelReseted();
+
+private:
+    QVector<Message> m_messages;
+};
+
+} // namespace QodeAssist::Chat
+Q_DECLARE_METATYPE(QodeAssist::Chat::ChatModel::Message)
+Q_DECLARE_METATYPE(QodeAssist::Chat::MessagePart)

ChatView/ChatRootView.cpp

@@ -0,0 +1,635 @@
+/*
+ * Copyright (C) 2024-2025 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 <QClipboard>
+#include <QDesktopServices>
+#include <QFileDialog>
+#include <QMessageBox>
+
+#include <coreplugin/editormanager/editormanager.h>
+#include <coreplugin/icore.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/projectmanager.h>
+#include <utils/theme/theme.h>
+#include <utils/utilsicons.h>
+
+#include "ChatAssistantSettings.hpp"
+#include "ChatSerializer.hpp"
+#include "GeneralSettings.hpp"
+#include "Logger.hpp"
+#include "ProjectSettings.hpp"
+#include "context/ContextManager.hpp"
+#include "context/TokenUtils.hpp"
+
+namespace QodeAssist::Chat {
+
+ChatRootView::ChatRootView(QQuickItem *parent)
+    : QQuickItem(parent)
+    , m_chatModel(new ChatModel(this))
+    , m_promptProvider(LLMCore::PromptTemplateManager::instance())
+    , m_clientInterface(new ClientInterface(m_chatModel, &m_promptProvider, this))
+    , m_isRequestInProgress(false)
+{
+    m_isSyncOpenFiles = Settings::chatAssistantSettings().linkOpenFiles();
+    connect(
+        &Settings::chatAssistantSettings().linkOpenFiles,
+        &Utils::BaseAspect::changed,
+        this,
+        [this]() { setIsSyncOpenFiles(Settings::chatAssistantSettings().linkOpenFiles()); });
+
+    auto &settings = Settings::generalSettings();
+
+    connect(
+        &settings.caModel, &Utils::BaseAspect::changed, this, &ChatRootView::currentTemplateChanged);
+
+    connect(
+        m_clientInterface,
+        &ClientInterface::messageReceivedCompletely,
+        this,
+        &ChatRootView::autosave);
+
+    connect(m_clientInterface, &ClientInterface::messageReceivedCompletely, this, [this]() {
+        this->setRequestProgressStatus(false);
+    });
+
+    connect(
+        m_clientInterface,
+        &ClientInterface::messageReceivedCompletely,
+        this,
+        &ChatRootView::updateInputTokensCount);
+
+    connect(m_chatModel, &ChatModel::modelReseted, this, [this]() { setRecentFilePath(QString{}); });
+    connect(this, &ChatRootView::attachmentFilesChanged, &ChatRootView::updateInputTokensCount);
+    connect(this, &ChatRootView::linkedFilesChanged, &ChatRootView::updateInputTokensCount);
+    connect(
+        &Settings::chatAssistantSettings().useSystemPrompt,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::updateInputTokensCount);
+    connect(
+        &Settings::chatAssistantSettings().systemPrompt,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::updateInputTokensCount);
+
+    auto editors = Core::EditorManager::instance();
+
+    connect(editors, &Core::EditorManager::editorCreated, this, &ChatRootView::onEditorCreated);
+    connect(
+        editors,
+        &Core::EditorManager::editorAboutToClose,
+        this,
+        &ChatRootView::onEditorAboutToClose);
+
+    connect(editors, &Core::EditorManager::currentEditorAboutToChange, this, [this]() {
+        if (m_isSyncOpenFiles) {
+            for (auto editor : std::as_const(m_currentEditors)) {
+                onAppendLinkFileFromEditor(editor);
+            }
+        }
+    });
+    connect(
+        &Settings::chatAssistantSettings().textFontFamily,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::textFamilyChanged);
+    connect(
+        &Settings::chatAssistantSettings().codeFontFamily,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::codeFamilyChanged);
+    connect(
+        &Settings::chatAssistantSettings().textFontSize,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::textFontSizeChanged);
+    connect(
+        &Settings::chatAssistantSettings().codeFontSize,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::codeFontSizeChanged);
+    connect(
+        &Settings::chatAssistantSettings().textFormat,
+        &Utils::BaseAspect::changed,
+        this,
+        &ChatRootView::textFormatChanged);
+    connect(m_clientInterface, &ClientInterface::errorOccurred, this, [this](const QString &error) {
+        this->setRequestProgressStatus(false);
+        m_lastErrorMessage = error;
+        emit lastErrorMessageChanged();
+    });
+
+    updateInputTokensCount();
+}
+
+ChatModel *ChatRootView::chatModel() const
+{
+    return m_chatModel;
+}
+
+void ChatRootView::sendMessage(const QString &message)
+{
+    if (m_inputTokensCount > m_chatModel->tokensThreshold()) {
+        QMessageBox::StandardButton reply = QMessageBox::question(
+            Core::ICore::dialogParent(),
+            tr("Token Limit Exceeded"),
+            tr("The chat history has exceeded the token limit.\n"
+               "Would you like to create new chat?"),
+            QMessageBox::Yes | QMessageBox::No);
+
+        if (reply == QMessageBox::Yes) {
+            autosave();
+            m_chatModel->clear();
+            setRecentFilePath(QString{});
+            return;
+        }
+    }
+
+    m_clientInterface->sendMessage(message, m_attachmentFiles, m_linkedFiles);
+    clearAttachmentFiles();
+    setRequestProgressStatus(true);
+}
+
+void ChatRootView::copyToClipboard(const QString &text)
+{
+    QGuiApplication::clipboard()->setText(text);
+}
+
+void ChatRootView::cancelRequest()
+{
+    m_clientInterface->cancelRequest();
+    setRequestProgressStatus(false);
+}
+
+void ChatRootView::clearAttachmentFiles()
+{
+    if (!m_attachmentFiles.isEmpty()) {
+        m_attachmentFiles.clear();
+        emit attachmentFilesChanged();
+    }
+}
+
+void ChatRootView::clearLinkedFiles()
+{
+    if (!m_linkedFiles.isEmpty()) {
+        m_linkedFiles.clear();
+        emit linkedFilesChanged();
+    }
+}
+
+QString ChatRootView::getChatsHistoryDir() const
+{
+    QString path;
+
+    if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
+        Settings::ProjectSettings projectSettings(project);
+        path = projectSettings.chatHistoryPath().toFSPathString();
+    } else {
+        path = QString("%1/qodeassist/chat_history")
+                   .arg(Core::ICore::userResourcePath().toFSPathString());
+    }
+
+    QDir dir(path);
+    if (!dir.exists() && !dir.mkpath(".")) {
+        LOG_MESSAGE(QString("Failed to create directory: %1").arg(path));
+        return QString();
+    }
+
+    return path;
+}
+
+QString ChatRootView::currentTemplate() const
+{
+    auto &settings = Settings::generalSettings();
+    return settings.caModel();
+}
+
+void ChatRootView::saveHistory(const QString &filePath)
+{
+    auto result = ChatSerializer::saveToFile(m_chatModel, filePath);
+    if (!result.success) {
+        LOG_MESSAGE(QString("Failed to save chat history: %1").arg(result.errorMessage));
+    } else {
+        setRecentFilePath(filePath);
+    }
+}
+
+void ChatRootView::loadHistory(const QString &filePath)
+{
+    auto result = ChatSerializer::loadFromFile(m_chatModel, filePath);
+    if (!result.success) {
+        LOG_MESSAGE(QString("Failed to load chat history: %1").arg(result.errorMessage));
+    } else {
+        setRecentFilePath(filePath);
+    }
+    updateInputTokensCount();
+}
+
+void ChatRootView::showSaveDialog()
+{
+    QString initialDir = getChatsHistoryDir();
+
+    QFileDialog *dialog = new QFileDialog(nullptr, tr("Save Chat History"));
+    dialog->setAcceptMode(QFileDialog::AcceptSave);
+    dialog->setFileMode(QFileDialog::AnyFile);
+    dialog->setNameFilter(tr("JSON files (*.json)"));
+    dialog->setDefaultSuffix("json");
+    if (!initialDir.isEmpty()) {
+        dialog->setDirectory(initialDir);
+        dialog->selectFile(getSuggestedFileName() + ".json");
+    }
+
+    connect(dialog, &QFileDialog::finished, this, [this, dialog](int result) {
+        if (result == QFileDialog::Accepted) {
+            QStringList files = dialog->selectedFiles();
+            if (!files.isEmpty()) {
+                saveHistory(files.first());
+            }
+        }
+        dialog->deleteLater();
+    });
+
+    dialog->open();
+}
+
+void ChatRootView::showLoadDialog()
+{
+    QString initialDir = getChatsHistoryDir();
+
+    QFileDialog *dialog = new QFileDialog(nullptr, tr("Load Chat History"));
+    dialog->setAcceptMode(QFileDialog::AcceptOpen);
+    dialog->setFileMode(QFileDialog::ExistingFile);
+    dialog->setNameFilter(tr("JSON files (*.json)"));
+    if (!initialDir.isEmpty()) {
+        dialog->setDirectory(initialDir);
+    }
+
+    connect(dialog, &QFileDialog::finished, this, [this, dialog](int result) {
+        if (result == QFileDialog::Accepted) {
+            QStringList files = dialog->selectedFiles();
+            if (!files.isEmpty()) {
+                loadHistory(files.first());
+            }
+        }
+        dialog->deleteLater();
+    });
+
+    dialog->open();
+}
+
+QString ChatRootView::getSuggestedFileName() const
+{
+    QStringList parts;
+
+    static const QRegularExpression saitizeSymbols = QRegularExpression("[\\/:*?\"<>|\\s]");
+    static const QRegularExpression underSymbols = QRegularExpression("_+");
+
+    if (m_chatModel->rowCount() > 0) {
+        QString firstMessage
+            = m_chatModel->data(m_chatModel->index(0), ChatModel::Content).toString();
+        QString shortMessage = firstMessage.split('\n').first().simplified().left(30);
+
+        QString sanitizedMessage = shortMessage;
+        sanitizedMessage.replace(saitizeSymbols, "_");
+        sanitizedMessage.replace(underSymbols, "_");
+        sanitizedMessage = sanitizedMessage.trimmed();
+
+        if (!sanitizedMessage.isEmpty()) {
+            if (sanitizedMessage.startsWith('_')) {
+                sanitizedMessage.remove(0, 1);
+            }
+            if (sanitizedMessage.endsWith('_')) {
+                sanitizedMessage.chop(1);
+            }
+
+            QString targetDir = getChatsHistoryDir();
+            QString fullPath = QDir(targetDir).filePath(sanitizedMessage);
+
+            QFileInfo fileInfo(fullPath);
+            if (!fileInfo.exists() && QFileInfo(fileInfo.path()).isWritable()) {
+                parts << sanitizedMessage;
+            }
+        }
+    }
+
+    parts << QDateTime::currentDateTime().toString("yyyy-MM-dd_HH-mm");
+
+    QString fileName = parts.join("_");
+
+    QString fullPath = QDir(getChatsHistoryDir()).filePath(fileName);
+    QFileInfo finalCheck(fullPath);
+
+    if (fileName.isEmpty() || finalCheck.exists() || !QFileInfo(finalCheck.path()).isWritable()) {
+        fileName = QString("chat_%1").arg(
+            QDateTime::currentDateTime().toString("yyyy-MM-dd_HH-mm"));
+    }
+
+    return fileName;
+}
+
+void ChatRootView::autosave()
+{
+    if (m_chatModel->rowCount() == 0 || !Settings::chatAssistantSettings().autosave()) {
+        return;
+    }
+
+    QString filePath = getAutosaveFilePath();
+    if (!filePath.isEmpty()) {
+        ChatSerializer::saveToFile(m_chatModel, filePath);
+        setRecentFilePath(filePath);
+    }
+}
+
+QString ChatRootView::getAutosaveFilePath() const
+{
+    if (!m_recentFilePath.isEmpty()) {
+        return m_recentFilePath;
+    }
+
+    QString dir = getChatsHistoryDir();
+    if (dir.isEmpty()) {
+        return QString();
+    }
+
+    return QDir(dir).filePath(getSuggestedFileName() + ".json");
+}
+
+QStringList ChatRootView::attachmentFiles() const
+{
+    return m_attachmentFiles;
+}
+
+QStringList ChatRootView::linkedFiles() const
+{
+    return m_linkedFiles;
+}
+
+void ChatRootView::showAttachFilesDialog()
+{
+    QFileDialog dialog(nullptr, tr("Select Files to Attach"));
+    dialog.setFileMode(QFileDialog::ExistingFiles);
+
+    if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
+        dialog.setDirectory(project->projectDirectory().toFSPathString());
+    }
+
+    if (dialog.exec() == QDialog::Accepted) {
+        QStringList newFilePaths = dialog.selectedFiles();
+        if (!newFilePaths.isEmpty()) {
+            bool filesAdded = false;
+            for (const QString &filePath : std::as_const(newFilePaths)) {
+                if (!m_attachmentFiles.contains(filePath)) {
+                    m_attachmentFiles.append(filePath);
+                    filesAdded = true;
+                }
+            }
+            if (filesAdded) {
+                emit attachmentFilesChanged();
+            }
+        }
+    }
+}
+
+void ChatRootView::removeFileFromAttachList(int index)
+{
+    if (index >= 0 && index < m_attachmentFiles.size()) {
+        m_attachmentFiles.removeAt(index);
+        emit attachmentFilesChanged();
+    }
+}
+
+void ChatRootView::showLinkFilesDialog()
+{
+    QFileDialog dialog(nullptr, tr("Select Files to Attach"));
+    dialog.setFileMode(QFileDialog::ExistingFiles);
+
+    if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
+        dialog.setDirectory(project->projectDirectory().toFSPathString());
+    }
+
+    if (dialog.exec() == QDialog::Accepted) {
+        QStringList newFilePaths = dialog.selectedFiles();
+        if (!newFilePaths.isEmpty()) {
+            bool filesAdded = false;
+            for (const QString &filePath : std::as_const(newFilePaths)) {
+                if (!m_linkedFiles.contains(filePath)) {
+                    m_linkedFiles.append(filePath);
+                    filesAdded = true;
+                }
+            }
+            if (filesAdded) {
+                emit linkedFilesChanged();
+            }
+        }
+    }
+}
+
+void ChatRootView::removeFileFromLinkList(int index)
+{
+    if (index >= 0 && index < m_linkedFiles.size()) {
+        m_linkedFiles.removeAt(index);
+        emit linkedFilesChanged();
+    }
+}
+
+void ChatRootView::calculateMessageTokensCount(const QString &message)
+{
+    m_messageTokensCount = Context::TokenUtils::estimateTokens(message);
+    updateInputTokensCount();
+}
+
+void ChatRootView::setIsSyncOpenFiles(bool state)
+{
+    if (m_isSyncOpenFiles != state) {
+        m_isSyncOpenFiles = state;
+        emit isSyncOpenFilesChanged();
+    }
+
+    if (m_isSyncOpenFiles) {
+        for (auto editor : std::as_const(m_currentEditors)) {
+            onAppendLinkFileFromEditor(editor);
+        }
+    }
+}
+
+void ChatRootView::openChatHistoryFolder()
+{
+    QString path;
+    if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
+        Settings::ProjectSettings projectSettings(project);
+        path = projectSettings.chatHistoryPath().toFSPathString();
+    } else {
+        path = QString("%1/qodeassist/chat_history")
+                   .arg(Core::ICore::userResourcePath().toFSPathString());
+    }
+
+    QDir dir(path);
+    if (!dir.exists()) {
+        dir.mkpath(".");
+    }
+
+    QUrl url = QUrl::fromLocalFile(dir.absolutePath());
+    QDesktopServices::openUrl(url);
+}
+
+void ChatRootView::updateInputTokensCount()
+{
+    int inputTokens = m_messageTokensCount;
+    auto &settings = Settings::chatAssistantSettings();
+
+    if (settings.useSystemPrompt()) {
+        inputTokens += Context::TokenUtils::estimateTokens(settings.systemPrompt());
+    }
+
+    if (!m_attachmentFiles.isEmpty()) {
+        auto attachFiles = m_clientInterface->contextManager()->getContentFiles(m_attachmentFiles);
+        inputTokens += Context::TokenUtils::estimateFilesTokens(attachFiles);
+    }
+
+    if (!m_linkedFiles.isEmpty()) {
+        auto linkFiles = m_clientInterface->contextManager()->getContentFiles(m_linkedFiles);
+        inputTokens += Context::TokenUtils::estimateFilesTokens(linkFiles);
+    }
+
+    const auto &history = m_chatModel->getChatHistory();
+    for (const auto &message : history) {
+        inputTokens += Context::TokenUtils::estimateTokens(message.content);
+        inputTokens += 4; // + role
+    }
+
+    m_inputTokensCount = inputTokens;
+    emit inputTokensCountChanged();
+}
+
+int ChatRootView::inputTokensCount() const
+{
+    return m_inputTokensCount;
+}
+
+bool ChatRootView::isSyncOpenFiles() const
+{
+    return m_isSyncOpenFiles;
+}
+
+void ChatRootView::onEditorAboutToClose(Core::IEditor *editor)
+{
+    if (auto document = editor->document(); document && isSyncOpenFiles()) {
+        QString filePath = document->filePath().toFSPathString();
+        m_linkedFiles.removeOne(filePath);
+        emit linkedFilesChanged();
+    }
+
+    if (editor) {
+        m_currentEditors.removeOne(editor);
+    }
+}
+
+void ChatRootView::onAppendLinkFileFromEditor(Core::IEditor *editor)
+{
+    if (auto document = editor->document(); document && isSyncOpenFiles()) {
+        QString filePath = document->filePath().toFSPathString();
+        if (!m_linkedFiles.contains(filePath) && !shouldIgnoreFileForAttach(document->filePath())) {
+            m_linkedFiles.append(filePath);
+            emit linkedFilesChanged();
+        }
+    }
+}
+
+void ChatRootView::onEditorCreated(Core::IEditor *editor, const Utils::FilePath &filePath)
+{
+    if (editor && editor->document()) {
+        m_currentEditors.append(editor);
+    }
+}
+
+QString ChatRootView::chatFileName() const
+{
+    return QFileInfo(m_recentFilePath).baseName();
+}
+
+void ChatRootView::setRecentFilePath(const QString &filePath)
+{
+    if (m_recentFilePath != filePath) {
+        m_recentFilePath = filePath;
+        emit chatFileNameChanged();
+    }
+}
+
+bool ChatRootView::shouldIgnoreFileForAttach(const Utils::FilePath &filePath)
+{
+    auto project = ProjectExplorer::ProjectManager::projectForFile(filePath);
+    if (project
+        && m_clientInterface->contextManager()
+               ->ignoreManager()
+               ->shouldIgnore(filePath.toFSPathString(), project)) {
+        LOG_MESSAGE(QString("Ignoring file for attachment due to .qodeassistignore: %1")
+                        .arg(filePath.toFSPathString()));
+        return true;
+    }
+
+    return false;
+}
+
+QString ChatRootView::textFontFamily() const
+{
+    return Settings::chatAssistantSettings().textFontFamily.stringValue();
+}
+
+QString ChatRootView::codeFontFamily() const
+{
+    return Settings::chatAssistantSettings().codeFontFamily.stringValue();
+}
+
+int ChatRootView::codeFontSize() const
+{
+    return Settings::chatAssistantSettings().codeFontSize();
+}
+
+int ChatRootView::textFontSize() const
+{
+    return Settings::chatAssistantSettings().textFontSize();
+}
+
+int ChatRootView::textFormat() const
+{
+    return Settings::chatAssistantSettings().textFormat();
+}
+
+bool ChatRootView::isRequestInProgress() const
+{
+    return m_isRequestInProgress;
+}
+
+void ChatRootView::setRequestProgressStatus(bool state)
+{
+    if (m_isRequestInProgress == state)
+        return;
+    m_isRequestInProgress = state;
+    emit isRequestInProgressChanged();
+}
+
+QString ChatRootView::lastErrorMessage() const
+{
+    return m_lastErrorMessage;
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatRootView.hpp

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2024-2025 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"
+#include "llmcore/PromptProviderChat.hpp"
+#include <coreplugin/editormanager/editormanager.h>
+
+namespace QodeAssist::Chat {
+
+class ChatRootView : public QQuickItem
+{
+    Q_OBJECT
+    Q_PROPERTY(QodeAssist::Chat::ChatModel *chatModel READ chatModel NOTIFY chatModelChanged FINAL)
+    Q_PROPERTY(QString currentTemplate READ currentTemplate NOTIFY currentTemplateChanged FINAL)
+    Q_PROPERTY(bool isSyncOpenFiles READ isSyncOpenFiles NOTIFY isSyncOpenFilesChanged FINAL)
+    Q_PROPERTY(QStringList attachmentFiles READ attachmentFiles NOTIFY attachmentFilesChanged FINAL)
+    Q_PROPERTY(QStringList linkedFiles READ linkedFiles NOTIFY linkedFilesChanged FINAL)
+    Q_PROPERTY(int inputTokensCount READ inputTokensCount NOTIFY inputTokensCountChanged FINAL)
+    Q_PROPERTY(QString chatFileName READ chatFileName NOTIFY chatFileNameChanged FINAL)
+    Q_PROPERTY(QString textFontFamily READ textFontFamily NOTIFY textFamilyChanged FINAL)
+    Q_PROPERTY(QString codeFontFamily READ codeFontFamily NOTIFY codeFamilyChanged FINAL)
+    Q_PROPERTY(int codeFontSize READ codeFontSize NOTIFY codeFontSizeChanged FINAL)
+    Q_PROPERTY(int textFontSize READ textFontSize NOTIFY textFontSizeChanged FINAL)
+    Q_PROPERTY(int textFormat READ textFormat NOTIFY textFormatChanged FINAL)
+    Q_PROPERTY(
+        bool isRequestInProgress READ isRequestInProgress NOTIFY isRequestInProgressChanged FINAL)
+    Q_PROPERTY(QString lastErrorMessage READ lastErrorMessage NOTIFY lastErrorMessageChanged FINAL)
+
+    QML_ELEMENT
+
+public:
+    ChatRootView(QQuickItem *parent = nullptr);
+
+    ChatModel *chatModel() const;
+    QString currentTemplate() const;
+
+    void saveHistory(const QString &filePath);
+    void loadHistory(const QString &filePath);
+
+    Q_INVOKABLE void showSaveDialog();
+    Q_INVOKABLE void showLoadDialog();
+
+    void autosave();
+    QString getAutosaveFilePath() const;
+
+    QStringList attachmentFiles() const;
+    QStringList linkedFiles() const;
+
+    Q_INVOKABLE void showAttachFilesDialog();
+    Q_INVOKABLE void removeFileFromAttachList(int index);
+    Q_INVOKABLE void showLinkFilesDialog();
+    Q_INVOKABLE void removeFileFromLinkList(int index);
+    Q_INVOKABLE void calculateMessageTokensCount(const QString &message);
+    Q_INVOKABLE void setIsSyncOpenFiles(bool state);
+    Q_INVOKABLE void openChatHistoryFolder();
+
+    Q_INVOKABLE void updateInputTokensCount();
+    int inputTokensCount() const;
+
+    bool isSyncOpenFiles() const;
+
+    void onEditorAboutToClose(Core::IEditor *editor);
+    void onAppendLinkFileFromEditor(Core::IEditor *editor);
+    void onEditorCreated(Core::IEditor *editor, const Utils::FilePath &filePath);
+
+    QString chatFileName() const;
+    void setRecentFilePath(const QString &filePath);
+    bool shouldIgnoreFileForAttach(const Utils::FilePath &filePath);
+
+    QString textFontFamily() const;
+    QString codeFontFamily() const;
+
+    int codeFontSize() const;
+    int textFontSize() const;
+    int textFormat() const;
+
+    bool isRequestInProgress() const;
+    void setRequestProgressStatus(bool state);
+
+    QString lastErrorMessage() const;
+
+public slots:
+    void sendMessage(const QString &message);
+    void copyToClipboard(const QString &text);
+    void cancelRequest();
+    void clearAttachmentFiles();
+    void clearLinkedFiles();
+
+signals:
+    void chatModelChanged();
+    void currentTemplateChanged();
+    void attachmentFilesChanged();
+    void linkedFilesChanged();
+    void inputTokensCountChanged();
+    void isSyncOpenFilesChanged();
+    void chatFileNameChanged();
+    void textFamilyChanged();
+    void codeFamilyChanged();
+    void codeFontSizeChanged();
+    void textFontSizeChanged();
+    void textFormatChanged();
+    void chatRequestStarted();
+    void isRequestInProgressChanged();
+
+    void lastErrorMessageChanged();
+
+private:
+    QString getChatsHistoryDir() const;
+    QString getSuggestedFileName() const;
+
+    ChatModel *m_chatModel;
+    LLMCore::PromptProviderChat m_promptProvider;
+    ClientInterface *m_clientInterface;
+    QString m_currentTemplate;
+    QString m_recentFilePath;
+    QStringList m_attachmentFiles;
+    QStringList m_linkedFiles;
+    int m_messageTokensCount{0};
+    int m_inputTokensCount{0};
+    bool m_isSyncOpenFiles;
+    QList<Core::IEditor *> m_currentEditors;
+    bool m_isRequestInProgress;
+    QString m_lastErrorMessage;
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatSerializer.cpp

@@ -0,0 +1,142 @@
+/* 
+ * Copyright (C) 2024-2025 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 "ChatSerializer.hpp"
+#include "Logger.hpp"
+
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QJsonDocument>
+
+namespace QodeAssist::Chat {
+
+const QString ChatSerializer::VERSION = "0.1";
+
+SerializationResult ChatSerializer::saveToFile(const ChatModel *model, const QString &filePath)
+{
+    if (!ensureDirectoryExists(filePath)) {
+        return {false, "Failed to create directory structure"};
+    }
+
+    QFile file(filePath);
+    if (!file.open(QIODevice::WriteOnly)) {
+        return {false, QString("Failed to open file for writing: %1").arg(filePath)};
+    }
+
+    QJsonObject root = serializeChat(model);
+    QJsonDocument doc(root);
+
+    if (file.write(doc.toJson(QJsonDocument::Indented)) == -1) {
+        return {false, QString("Failed to write to file: %1").arg(file.errorString())};
+    }
+
+    return {true, QString()};
+}
+
+SerializationResult ChatSerializer::loadFromFile(ChatModel *model, const QString &filePath)
+{
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly)) {
+        return {false, QString("Failed to open file for reading: %1").arg(filePath)};
+    }
+
+    QJsonParseError error;
+    QJsonDocument doc = QJsonDocument::fromJson(file.readAll(), &error);
+    if (error.error != QJsonParseError::NoError) {
+        return {false, QString("JSON parse error: %1").arg(error.errorString())};
+    }
+
+    QJsonObject root = doc.object();
+    QString version = root["version"].toString();
+
+    if (!validateVersion(version)) {
+        return {false, QString("Unsupported version: %1").arg(version)};
+    }
+
+    if (!deserializeChat(model, root)) {
+        return {false, "Failed to deserialize chat data"};
+    }
+
+    return {true, QString()};
+}
+
+QJsonObject ChatSerializer::serializeMessage(const ChatModel::Message &message)
+{
+    QJsonObject messageObj;
+    messageObj["role"] = static_cast<int>(message.role);
+    messageObj["content"] = message.content;
+    messageObj["id"] = message.id;
+    return messageObj;
+}
+
+ChatModel::Message ChatSerializer::deserializeMessage(const QJsonObject &json)
+{
+    ChatModel::Message message;
+    message.role = static_cast<ChatModel::ChatRole>(json["role"].toInt());
+    message.content = json["content"].toString();
+    message.id = json["id"].toString();
+    return message;
+}
+
+QJsonObject ChatSerializer::serializeChat(const ChatModel *model)
+{
+    QJsonArray messagesArray;
+    for (const auto &message : model->getChatHistory()) {
+        messagesArray.append(serializeMessage(message));
+    }
+
+    QJsonObject root;
+    root["version"] = VERSION;
+    root["messages"] = messagesArray;
+
+    return root;
+}
+
+bool ChatSerializer::deserializeChat(ChatModel *model, const QJsonObject &json)
+{
+    QJsonArray messagesArray = json["messages"].toArray();
+    QVector<ChatModel::Message> messages;
+    messages.reserve(messagesArray.size());
+
+    for (const auto &messageValue : messagesArray) {
+        messages.append(deserializeMessage(messageValue.toObject()));
+    }
+
+    model->clear();
+    for (const auto &message : messages) {
+        model->addMessage(message.content, message.role, message.id);
+    }
+
+    return true;
+}
+
+bool ChatSerializer::ensureDirectoryExists(const QString &filePath)
+{
+    QFileInfo fileInfo(filePath);
+    QDir dir = fileInfo.dir();
+    return dir.exists() || dir.mkpath(".");
+}
+
+bool ChatSerializer::validateVersion(const QString &version)
+{
+    return version == VERSION;
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatSerializer.hpp

@@ -0,0 +1,56 @@
+/* 
+ * Copyright (C) 2024-2025 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 <QJsonObject>
+#include <QString>
+
+#include "ChatModel.hpp"
+
+namespace QodeAssist::Chat {
+
+struct SerializationResult
+{
+    bool success{false};
+    QString errorMessage;
+};
+
+class ChatSerializer
+{
+public:
+    static SerializationResult saveToFile(const ChatModel *model, const QString &filePath);
+    static SerializationResult loadFromFile(ChatModel *model, const QString &filePath);
+
+    // Public for testing purposes
+    static QJsonObject serializeMessage(const ChatModel::Message &message);
+    static ChatModel::Message deserializeMessage(const QJsonObject &json);
+    static QJsonObject serializeChat(const ChatModel *model);
+    static bool deserializeChat(ChatModel *model, const QJsonObject &json);
+
+private:
+    static const QString VERSION;
+    static constexpr int CURRENT_VERSION = 1;
+
+    static bool ensureDirectoryExists(const QString &filePath);
+    static bool validateVersion(const QString &version);
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatUtils.cpp

@@ -0,0 +1,68 @@
+/* 
+ * Copyright (C) 2024-2025 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);
+}
+
+QString ChatUtils::getSafeMarkdownText(const QString &text) const
+{
+    if (text.isEmpty()) {
+        return text;
+    }
+
+    bool needsSanitization = false;
+    for (const QChar &ch : text) {
+        if (ch.isNull() || (!ch.isPrint() && ch != '\n' && ch != '\t' && ch != '\r' && ch != ' ')) {
+            needsSanitization = true;
+            break;
+        }
+    }
+
+    if (!needsSanitization) {
+        return text;
+    }
+
+    QString safeText;
+    safeText.reserve(text.size());
+
+    for (QChar ch : text) {
+        if (ch.isNull()) {
+            safeText.append(' ');
+        } else if (ch == '\n' || ch == '\t' || ch == '\r' || ch == ' ') {
+            safeText.append(ch);
+        } else if (ch.isPrint()) {
+            safeText.append(ch);
+        } else {
+            safeText.append(QChar(0xFFFD));
+        }
+    }
+
+    return safeText;
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatUtils.h

@@ -0,0 +1,40 @@
+/* 
+ * Copyright (C) 2024-2025 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 {
+
+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);
+    Q_INVOKABLE QString getSafeMarkdownText(const QString &text) const;
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatView.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2024-2025 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 "ChatView.hpp"
+
+#include <QQmlContext>
+#include <QQmlEngine>
+#include <QSettings>
+#include <QVariantMap>
+
+#include <coreplugin/actionmanager/actionmanager.h>
+#include <logger/Logger.hpp>
+
+namespace {
+constexpr Qt::WindowFlags baseFlags = Qt::Window | Qt::WindowTitleHint | Qt::WindowSystemMenuHint
+                                      | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint
+                                      | Qt::WindowCloseButtonHint;
+}
+
+namespace QodeAssist::Chat {
+
+ChatView::ChatView()
+    : m_isPin(false)
+{
+    setTitle("QodeAssist Chat");
+    engine()->rootContext()->setContextProperty("_chatview", this);
+    setSource(QUrl("qrc:/qt/qml/ChatView/qml/RootItem.qml"));
+    setResizeMode(QQuickView::SizeRootObjectToView);
+    setMinimumSize({400, 300});
+    setFlags(baseFlags);
+
+    if (auto action = Core::ActionManager::command("QodeAssist.CloseChatView")) {
+        m_closeShortcut = new QShortcut(action->keySequence(), this);
+        connect(m_closeShortcut, &QShortcut::activated, this, &QQuickView::close);
+
+        connect(action, &Core::Command::keySequenceChanged, this, [action, this]() {
+            if (m_closeShortcut) {
+                m_closeShortcut->setKey(action->keySequence());
+            }
+        });
+    }
+
+    restoreSettings();
+}
+
+void ChatView::closeEvent(QCloseEvent *event)
+{
+    saveSettings();
+    event->accept();
+}
+
+void ChatView::saveSettings()
+{
+    QSettings settings;
+    settings.setValue("QodeAssist/ChatView/geometry", geometry());
+    settings.setValue("QodeAssist/ChatView/pinned", m_isPin);
+}
+
+void ChatView::restoreSettings()
+{
+    QSettings settings;
+    const QRect savedGeometry
+        = settings.value("QodeAssist/ChatView/geometry", QRect(100, 100, 800, 600)).toRect();
+    setGeometry(savedGeometry);
+
+    const bool pinned = settings.value("QodeAssist/ChatView/pinned", false).toBool();
+    setIsPin(pinned);
+}
+
+bool ChatView::isPin() const
+{
+    return m_isPin;
+}
+
+void ChatView::setIsPin(bool newIsPin)
+{
+    if (m_isPin == newIsPin)
+        return;
+    m_isPin = newIsPin;
+
+    if (m_isPin) {
+        setFlags(baseFlags | Qt::WindowStaysOnTopHint);
+    } else {
+        setFlags(baseFlags);
+    }
+
+    emit isPinChanged();
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatView.hpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2024-2025 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 <QQuickView>
+#include <QShortcut>
+
+namespace QodeAssist::Chat {
+
+class ChatView : public QQuickView
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isPin READ isPin WRITE setIsPin NOTIFY isPinChanged FINAL)
+public:
+    ChatView();
+
+    bool isPin() const;
+    void setIsPin(bool newIsPin);
+
+signals:
+    void isPinChanged();
+
+protected:
+    void closeEvent(QCloseEvent *event) override;
+
+private:
+    void saveSettings();
+    void restoreSettings();
+
+    bool m_isPin;
+    QShortcut *m_closeShortcut;
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatWidget.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024-2025 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");
+}
+} // namespace QodeAssist::Chat

ChatView/ChatWidget.hpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024-2025 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();
+};
+
+} // namespace QodeAssist::Chat

ChatView/ClientInterface.cpp

@@ -0,0 +1,309 @@
+/* 
+ * Copyright (C) 2024-2025 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 <texteditor/textdocument.h>
+#include <QFileInfo>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QUuid>
+
+#include <coreplugin/editormanager/editormanager.h>
+#include <coreplugin/editormanager/ieditor.h>
+#include <coreplugin/idocument.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/projectmanager.h>
+
+#include <texteditor/textdocument.h>
+#include <texteditor/texteditor.h>
+
+#include "ChatAssistantSettings.hpp"
+#include "GeneralSettings.hpp"
+#include "Logger.hpp"
+#include "ProvidersManager.hpp"
+#include "RequestConfig.hpp"
+#include <RulesLoader.hpp>
+
+namespace QodeAssist::Chat {
+
+ClientInterface::ClientInterface(
+    ChatModel *chatModel, LLMCore::IPromptProvider *promptProvider, QObject *parent)
+    : QObject(parent)
+    , m_chatModel(chatModel)
+    , m_promptProvider(promptProvider)
+    , m_contextManager(new Context::ContextManager(this))
+{}
+
+ClientInterface::~ClientInterface() = default;
+
+void ClientInterface::sendMessage(
+    const QString &message, const QList<QString> &attachments, const QList<QString> &linkedFiles)
+{
+    cancelRequest();
+    m_accumulatedResponses.clear();
+
+    auto attachFiles = m_contextManager->getContentFiles(attachments);
+    m_chatModel->addMessage(message, ChatModel::ChatRole::User, "", attachFiles);
+
+    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 = m_promptProvider->getTemplateByName(templateName);
+
+    if (!promptTemplate) {
+        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+        return;
+    }
+
+    LLMCore::ContextData context;
+
+    if (chatAssistantSettings.useSystemPrompt()) {
+        QString systemPrompt = chatAssistantSettings.systemPrompt();
+
+        auto project = LLMCore::RulesLoader::getActiveProject();
+        if (project) {
+            QString projectRules
+                = LLMCore::RulesLoader::loadRulesForProject(project, LLMCore::RulesContext::Chat);
+
+            if (!projectRules.isEmpty()) {
+                systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
+            }
+        }
+
+        if (!linkedFiles.isEmpty()) {
+            systemPrompt = getSystemPromptWithLinkedFiles(systemPrompt, linkedFiles);
+        }
+        context.systemPrompt = systemPrompt;
+    }
+
+    QVector<LLMCore::Message> messages;
+    for (const auto &msg : m_chatModel->getChatHistory()) {
+        messages.append({msg.role == ChatModel::ChatRole::User ? "user" : "assistant", msg.content});
+    }
+    context.history = messages;
+
+    LLMCore::LLMConfig config;
+    config.requestType = LLMCore::RequestType::Chat;
+    config.provider = provider;
+    config.promptTemplate = promptTemplate;
+    if (provider->providerID() == LLMCore::ProviderID::GoogleAI) {
+        QString stream = QString{"streamGenerateContent?alt=sse"};
+        config.url = QUrl(QString("%1/models/%2:%3")
+                              .arg(
+                                  Settings::generalSettings().caUrl(),
+                                  Settings::generalSettings().caModel(),
+                                  stream));
+    } else {
+        config.url
+            = QString("%1%2").arg(Settings::generalSettings().caUrl(), provider->chatEndpoint());
+        config.providerRequest
+            = {{"model", Settings::generalSettings().caModel()}, {"stream", true}};
+    }
+
+    config.apiKey = provider->apiKey();
+
+    config.provider
+        ->prepareRequest(config.providerRequest, promptTemplate, context, LLMCore::RequestType::Chat);
+
+    QString requestId = QUuid::createUuid().toString();
+    QJsonObject request{{"id", requestId}};
+
+    m_activeRequests[requestId] = {request, provider};
+
+    connect(
+        provider,
+        &LLMCore::Provider::partialResponseReceived,
+        this,
+        &ClientInterface::handlePartialResponse,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::fullResponseReceived,
+        this,
+        &ClientInterface::handleFullResponse,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::requestFailed,
+        this,
+        &ClientInterface::handleRequestFailed,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::toolExecutionStarted,
+        m_chatModel,
+        &ChatModel::addToolExecutionStatus,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::toolExecutionCompleted,
+        m_chatModel,
+        &ChatModel::updateToolResult,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::continuationStarted,
+        this,
+        &ClientInterface::handleCleanAccumulatedData,
+        Qt::UniqueConnection);
+
+    provider->sendRequest(requestId, config.url, config.providerRequest);
+}
+
+void ClientInterface::clearMessages()
+{
+    m_chatModel->clear();
+    LOG_MESSAGE("Chat history cleared");
+}
+
+void ClientInterface::cancelRequest()
+{
+    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
+        const RequestContext &ctx = it.value();
+        if (ctx.provider) {
+            ctx.provider->cancelRequest(it.key());
+        }
+    }
+
+    m_activeRequests.clear();
+    m_accumulatedResponses.clear();
+
+    LOG_MESSAGE("All requests cancelled and state cleared");
+}
+
+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);
+            emit messageReceivedCompletely();
+        }
+    }
+}
+
+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().toFSPathString());
+
+    QString content = textDocument->document()->toPlainText();
+
+    LOG_MESSAGE(QString("Got context from file: %1").arg(textDocument->filePath().toFSPathString()));
+
+    return QString("Current file context:\n%1\nFile content:\n%2").arg(fileInfo, content);
+}
+
+QString ClientInterface::getSystemPromptWithLinkedFiles(
+    const QString &basePrompt, const QList<QString> &linkedFiles) const
+{
+    QString updatedPrompt = basePrompt;
+
+    if (!linkedFiles.isEmpty()) {
+        updatedPrompt += "\n\nLinked files for reference:\n";
+
+        auto contentFiles = m_contextManager->getContentFiles(linkedFiles);
+        for (const auto &file : contentFiles) {
+            updatedPrompt += QString("\nFile: %1\nContent:\n%2\n").arg(file.filename, file.content);
+        }
+    }
+
+    return updatedPrompt;
+}
+
+Context::ContextManager *ClientInterface::contextManager() const
+{
+    return m_contextManager;
+}
+
+void ClientInterface::handlePartialResponse(const QString &requestId, const QString &partialText)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    m_accumulatedResponses[requestId] += partialText;
+
+    const RequestContext &ctx = it.value();
+    handleLLMResponse(m_accumulatedResponses[requestId], ctx.originalRequest, false);
+}
+
+void ClientInterface::handleFullResponse(const QString &requestId, const QString &fullText)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    const RequestContext &ctx = it.value();
+
+    QString finalText = !fullText.isEmpty() ? fullText : m_accumulatedResponses[requestId];
+    handleLLMResponse(finalText, ctx.originalRequest, true);
+
+    m_activeRequests.erase(it);
+    m_accumulatedResponses.remove(requestId);
+}
+
+void ClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    LOG_MESSAGE(QString("Chat request %1 failed: %2").arg(requestId, error));
+    emit errorOccurred(error);
+
+    m_activeRequests.erase(it);
+    m_accumulatedResponses.remove(requestId);
+}
+
+void ClientInterface::handleCleanAccumulatedData(const QString &requestId)
+{
+    m_accumulatedResponses[requestId].clear();
+    LOG_MESSAGE(QString("Cleared accumulated responses for continuation request %1").arg(requestId));
+}
+
+} // namespace QodeAssist::Chat

ChatView/ClientInterface.hpp

@@ -0,0 +1,81 @@
+/* 
+ * Copyright (C) 2024-2025 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 "Provider.hpp"
+#include "llmcore/IPromptProvider.hpp"
+#include <context/ContextManager.hpp>
+
+namespace QodeAssist::Chat {
+
+class ClientInterface : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ClientInterface(
+        ChatModel *chatModel, LLMCore::IPromptProvider *promptProvider, QObject *parent = nullptr);
+    ~ClientInterface();
+
+    void sendMessage(
+        const QString &message,
+        const QList<QString> &attachments = {},
+        const QList<QString> &linkedFiles = {});
+    void clearMessages();
+    void cancelRequest();
+
+    Context::ContextManager *contextManager() const;
+
+signals:
+    void errorOccurred(const QString &error);
+    void messageReceivedCompletely();
+
+private slots:
+    void handlePartialResponse(const QString &requestId, const QString &partialText);
+    void handleFullResponse(const QString &requestId, const QString &fullText);
+    void handleRequestFailed(const QString &requestId, const QString &error);
+    void handleCleanAccumulatedData(const QString &requestId);
+
+private:
+    void handleLLMResponse(const QString &response, const QJsonObject &request, bool isComplete);
+    QString getCurrentFileContext() const;
+    QString getSystemPromptWithLinkedFiles(
+        const QString &basePrompt, const QList<QString> &linkedFiles) const;
+
+    struct RequestContext
+    {
+        QJsonObject originalRequest;
+        LLMCore::Provider *provider;
+    };
+
+    LLMCore::IPromptProvider *m_promptProvider = nullptr;
+    ChatModel *m_chatModel;
+    Context::ContextManager *m_contextManager;
+
+    QHash<QString, RequestContext> m_activeRequests;
+    QHash<QString, QString> m_accumulatedResponses;
+};
+
+} // namespace QodeAssist::Chat

ChatView/MessagePart.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024-2025 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 <QtQmlIntegration>
+
+#include "ChatData.hpp"
+
+namespace QodeAssist::Chat {
+
+class MessagePart
+{
+    Q_GADGET
+    Q_PROPERTY(MessagePartType 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:
+    MessagePartType type;
+    QString text;
+    QString language;
+};
+
+} // namespace QodeAssist::Chat

ChatView/icons/attach-file-dark.svg

@@ -0,0 +1,11 @@
+<svg width="24" height="48" viewBox="0 0 24 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_37_14)">
+<path d="M22 10.1053V36.7368C22 41.8547 17.525 46 12 46C6.475 46 2 41.8547 2 36.7368V7.78947C2 4.59368 4.8 2 8.25 2C11.7 2 15.75 4.59368 15.75 7.78947V35.5789C15.75 36.8526 13.375 39.0526 12 39.0526C10.625 39.0526 8.25 36.8526 8.25 35.5789V21.6842V8.94737" stroke="black" stroke-width="3" stroke-linecap="round"/>
+<path d="M22 10.1053V36.7368C22 41.8547 17.525 46 12 46C6.475 46 2 41.8547 2 36.7368V7.78947C2 4.59368 4.8 2 8.25 2C11.7 2 15.75 4.59368 15.75 7.78947V35.5789C15.75 36.8526 13.375 39.0526 12 39.0526C10.625 39.0526 8.25 36.8526 8.25 35.5789V21.6842V8.94737" stroke="black" stroke-width="3" stroke-linecap="round"/>
+</g>
+<defs>
+<clipPath id="clip0_37_14">
+<rect width="24" height="48" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/attach-file-light.svg

@@ -0,0 +1,11 @@
+<svg width="24" height="48" viewBox="0 0 24 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_51_20)">
+<path d="M22 10.1053V36.7368C22 41.8547 17.525 46 12 46C6.475 46 2 41.8547 2 36.7368V7.78947C2 4.59368 4.8 2 8.25 2C11.7 2 15.75 4.59368 15.75 7.78947V35.5789C15.75 36.8526 13.375 39.0526 12 39.0526C10.625 39.0526 8.25 36.8526 8.25 35.5789V21.6842V8.94737" stroke="white" stroke-width="3" stroke-linecap="round"/>
+<path d="M22 10.1053V36.7368C22 41.8547 17.525 46 12 46C6.475 46 2 41.8547 2 36.7368V7.78947C2 4.59368 4.8 2 8.25 2C11.7 2 15.75 4.59368 15.75 7.78947V35.5789C15.75 36.8526 13.375 39.0526 12 39.0526C10.625 39.0526 8.25 36.8526 8.25 35.5789V21.6842V8.94737" stroke="white" stroke-width="3" stroke-linecap="round"/>
+</g>
+<defs>
+<clipPath id="clip0_51_20">
+<rect width="24" height="48" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/chat-icon.svg

@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_5_6)">
+<path d="M21.6 0H2.4C1.08 0 0 1.08 0 2.4V16.8C0 18.12 1.08 19.2 2.4 19.2H7.2V22.8C7.2 23.46 7.74 24 8.4 24H9C9.3 24 9.6 23.88 9.84 23.652L14.28 19.2H21.6C22.92 19.2 24 18.12 24 16.8V2.4C24 1.08 22.92 0 21.6 0ZM21.6 16.8H13.44L8.76 21.48L8.4 21.6V16.8H2.4V2.4H21.6V16.8Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_5_6">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/chat-pause-icon.svg

@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_5_17)">
+<path d="M21.6 0H2.4C1.08 0 0 1.08 0 2.4V16.8C0 18.12 1.08 19.2 2.4 19.2H7.2V22.8C7.2 23.46 7.74 24 8.4 24H9C9.3 24 9.6 23.88 9.84 23.652L14.28 19.2H21.6C22.92 19.2 24 18.12 24 16.8V2.4C24 1.08 22.92 0 21.6 0ZM21.6 16.8H13.44L8.76 21.48L8.4 21.6V16.8H2.4V2.4H21.6V16.8ZM8.4 6H15.6V13.2H8.4V6Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_5_17">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/clean-icon-dark.svg

@@ -0,0 +1,8 @@
+<svg width="20" height="44" viewBox="0 0 20 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M16.75 15H3.25C2.00736 15 1 16.0074 1 17.25V39.75C1 40.9926 2.00736 42 3.25 42H16.75C17.9926 42 19 40.9926 19 39.75V17.25C19 16.0074 17.9926 15 16.75 15Z" stroke="black" stroke-width="2"/>
+<path d="M1.04316 11.015L18.9554 8.90787" stroke="black" stroke-width="2" stroke-linecap="round"/>
+<path d="M7.19462 10.363L7.02032 8.59516C6.92446 7.62284 8.18688 6.64116 9.8257 6.41365C11.4645 6.18615 12.8838 6.79555 12.9797 7.76787L13.154 9.53573" stroke="black" stroke-width="2"/>
+<path d="M6 24V34" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M10 24V34" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M14 24V34" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

ChatView/icons/close-dark.svg

@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_41_14)">
+<path d="M0 0L24 24M0 24L24 0" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_41_14">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/close-light.svg

@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_41_14)">
+<path d="M0 0L24 24M0 24L24 0" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</g>
+<defs>
+<clipPath id="clip0_41_14">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/file-in-system.svg

@@ -0,0 +1,12 @@
+<svg width="44" height="44" viewBox="0 0 44 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_59_114)">
+<path d="M2 8H12L16 4H40C42 4 44 6 44 8V36C44 38 42 40 40 40H6C4 40 2 38 2 36V8Z" fill="black" fill-opacity="0.1" stroke="black" stroke-width="3"/>
+<path d="M25 37C32.732 37 39 30.732 39 23C39 15.268 32.732 9 25 9C17.268 9 11 15.268 11 23C11 30.732 17.268 37 25 37Z" stroke="black" stroke-width="4"/>
+<path d="M33 35L42 44" stroke="black" stroke-width="4" stroke-linecap="round"/>
+</g>
+<defs>
+<clipPath id="clip0_59_114">
+<rect width="44" height="44" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/link-file-dark.svg

@@ -0,0 +1,12 @@
+<svg width="20" height="44" viewBox="0 0 20 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_49_24)">
+<path d="M10 12L10 32L10 12Z" fill="black"/>
+<path d="M10 12L10 32" stroke="black" stroke-width="3"/>
+<path d="M1.50001 12.484C1.50001 -1.99999 18.5 -1.99999 18.5 12.484M1.5 31.5334C1.50001 46 18.5 46 18.5 31.5334" stroke="black" stroke-width="3" stroke-linecap="round"/>
+</g>
+<defs>
+<clipPath id="clip0_49_24">
+<rect width="20" height="44" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/link-file-light.svg

@@ -0,0 +1,12 @@
+<svg width="20" height="44" viewBox="0 0 20 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_51_24)">
+<path d="M10 12L10 32Z" fill="white"/>
+<path d="M10 12L10 32" stroke="white" stroke-width="3"/>
+<path d="M1.50001 12.484C1.50001 -1.99999 18.5 -1.99999 18.5 12.484M1.5 31.5334C1.50001 46 18.5 46 18.5 31.5334" stroke="white" stroke-width="3" stroke-linecap="round"/>
+</g>
+<defs>
+<clipPath id="clip0_51_24">
+<rect width="20" height="44" fill="white"/>
+</clipPath>
+</defs>
+</svg>

ChatView/icons/load-chat-dark.svg

@@ -0,0 +1,5 @@
+<svg width="20" height="44" viewBox="0 0 20 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5 8H15" stroke="black" stroke-width="2.5" stroke-linecap="round"/>
+<path d="M10 16V36" stroke="black" stroke-width="2.5" stroke-linecap="round"/>
+<path d="M5 21L10 16L15 21" stroke="black" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

ChatView/icons/save-chat-dark.svg

@@ -0,0 +1,5 @@
+<svg width="20" height="44" viewBox="0 0 20 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10 8V28" stroke="black" stroke-width="2.5" stroke-linecap="round"/>
+<path d="M5 23L10 28L15 23" stroke="black" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M5 36H15" stroke="black" stroke-width="2.5" stroke-linecap="round"/>
+</svg>

ChatView/icons/window-lock.svg

@@ -0,0 +1,5 @@
+<svg width="44" height="44" viewBox="0 0 44 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M31 18H13C11.3431 18 10 19.3431 10 21V37C10 38.6569 11.3431 40 13 40H31C32.6569 40 34 38.6569 34 37V21C34 19.3431 32.6569 18 31 18Z" fill="black" fill-opacity="0.3" stroke="black" stroke-width="4"/>
+<path d="M14 18V10C14 5.6 17.6 2 22 2C26.4 2 30 5.6 30 10V18" stroke="black" stroke-width="4"/>
+<path d="M22 32C23.6569 32 25 30.6569 25 29C25 27.3431 23.6569 26 22 26C20.3431 26 19 27.3431 19 29C19 30.6569 20.3431 32 22 32Z" fill="black"/>
+</svg>

ChatView/icons/window-unlock.svg

@@ -0,0 +1,5 @@
+<svg width="44" height="44" viewBox="0 0 44 44" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M31 18H13C11.3431 18 10 19.3431 10 21V37C10 38.6569 11.3431 40 13 40H31C32.6569 40 34 38.6569 34 37V21C34 19.3431 32.6569 18 31 18Z" fill="black" fill-opacity="0.1" stroke="black" stroke-width="4"/>
+<path d="M14 17V9.5C14 5.375 17.15 2 21 2C24.85 2 27.5 2.875 27.5 7" stroke="black" stroke-width="4"/>
+<path d="M22 32C23.6569 32 25 30.6569 25 29C25 27.3431 23.6569 26 22 26C20.3431 26 19 27.3431 19 29C19 30.6569 20.3431 32 22 32Z" fill="black"/>
+</svg>

ChatView/qml/ChatItem.qml

@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2024-2025 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 ChatView
+import QtQuick.Layouts
+import UIControls
+
+import "./dialog"
+
+Rectangle {
+    id: root
+
+    property alias msgModel: msgCreator.model
+    property alias messageAttachments: attachmentsModel.model
+    property string textFontFamily: Qt.application.font.family
+    property string codeFontFamily: {
+        switch (Qt.platform.os) {
+        case "windows":
+            return "Consolas";
+        case "osx":
+            return "Menlo";
+        case "linux":
+            return "DejaVu Sans Mono";
+        default:
+            return "monospace";
+        }
+    }
+    property int textFontSize: Qt.application.font.pointSize
+    property int codeFontSize: Qt.application.font.pointSize
+    property int textFormat: 0
+
+    property bool isUserMessage: false
+    property int messageIndex: -1
+
+    signal resetChatToMessage(int index)
+
+    height: msgColumn.implicitHeight + 10
+    radius: 8
+    color: isUserMessage ? palette.alternateBase
+                         : palette.base
+
+    HoverHandler {
+        id: mouse
+    }
+
+    ColumnLayout {
+        id: msgColumn
+
+        x: 5
+        width: parent.width - x
+        anchors.verticalCenter: parent.verticalCenter
+        spacing: 5
+
+        Repeater {
+            id: msgCreator
+            delegate: Loader {
+                id: msgCreatorDelegate
+                // Fix me:
+                // why does `required property MessagePart modelData` not work?
+                required property var modelData
+
+                Layout.preferredWidth: root.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 MessagePartType.Text: return textComponent;
+                        case MessagePartType.Code: return codeBlockComponent;
+                        default: return textComponent;
+                    }
+                }
+
+                Component {
+                    id: textComponent
+                    TextComponent {
+                        itemData: msgCreatorDelegate.modelData
+                    }
+                }
+
+                Component {
+                    id: codeBlockComponent
+                    CodeBlockComponent {
+                        itemData: msgCreatorDelegate.modelData
+                    }
+                }
+            }
+        }
+
+        Flow {
+            id: attachmentsFlow
+
+            Layout.fillWidth: true
+            visible: attachmentsModel.model && attachmentsModel.model.length > 0
+            leftPadding: 10
+            rightPadding: 10
+            spacing: 5
+
+            Repeater {
+                id: attachmentsModel
+
+                delegate: Rectangle {
+                    required property int index
+                    required property var modelData
+
+                    height: attachText.implicitHeight + 8
+                    width: attachText.implicitWidth + 16
+                    radius: 4
+                    color: palette.button
+                    border.width: 1
+                    border.color: palette.mid
+
+                    Text {
+                        id: attachText
+
+                        anchors.centerIn: parent
+                        text: modelData
+                        color: palette.text
+                    }
+                }
+            }
+        }
+    }
+
+    Rectangle {
+        id: userMessageMarker
+
+        anchors.verticalCenter: parent.verticalCenter
+        width: 3
+        height: root.height - root.radius
+        color: "#92BD6C"
+        radius: root.radius
+        visible: root.isUserMessage
+    }
+
+    QoAButton {
+        id: stopButtonId
+
+        anchors {
+            right: parent.right
+            top: parent.top
+        }
+
+        text: qsTr("ResetTo")
+        visible: root.isUserMessage && mouse.hovered
+        onClicked: function() {
+            root.resetChatToMessage(root.messageIndex)
+        }
+    }
+
+    component TextComponent : TextBlock {
+        required property var itemData
+        height: implicitHeight + 10
+        verticalAlignment: Text.AlignVCenter
+        leftPadding: 10
+        text: textFormat == Text.MarkdownText ? utils.getSafeMarkdownText(itemData.text)
+                                              : itemData.text
+        font.family: root.textFontFamily
+        font.pointSize: root.textFontSize
+        textFormat: {
+            if (root.textFormat == 0) {
+                return Text.MarkdownText
+            } else if (root.textFormat == 1) {
+                return Text.RichText
+            } else {
+                return Text.PlainText
+            }
+        }
+
+        ChatUtils {
+            id: utils
+        }
+    }
+
+    component CodeBlockComponent : CodeBlock {
+        id: codeblock
+
+        required property var itemData
+        anchors {
+            left: parent.left
+            leftMargin: 10
+            right: parent.right
+            rightMargin: 10
+        }
+
+        code: itemData.text
+        language: itemData.language
+        codeFontFamily: root.codeFontFamily
+        codeFontSize: root.codeFontSize
+    }
+}

ChatView/qml/RootItem.qml

@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2024-2025 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 QtQuick.Controls.Basic as QQC
+import QtQuick.Layouts
+import ChatView
+import UIControls
+import Qt.labs.platform as Platform
+import "./parts"
+
+ChatRootView {
+    id: root
+
+    property SystemPalette sysPalette: SystemPalette {
+        colorGroup: SystemPalette.Active
+    }
+
+    palette {
+        window: sysPalette.window
+        windowText: sysPalette.windowText
+        base: sysPalette.base
+        alternateBase: sysPalette.alternateBase
+        text: sysPalette.text
+        button: sysPalette.button
+        buttonText: sysPalette.buttonText
+        highlight: sysPalette.highlight
+        highlightedText: sysPalette.highlightedText
+        light: sysPalette.light
+        mid: sysPalette.mid
+        dark: sysPalette.dark
+        shadow: sysPalette.shadow
+        brightText: sysPalette.brightText
+    }
+
+    Rectangle {
+        id: bg
+
+        anchors.fill: parent
+        color: palette.window
+    }
+
+    ColumnLayout {
+        anchors.fill: parent
+        spacing: 0
+
+        TopBar {
+            id: topBar
+
+            Layout.preferredWidth: parent.width
+            Layout.preferredHeight: 40
+
+            saveButton.onClicked: root.showSaveDialog()
+            loadButton.onClicked: root.showLoadDialog()
+            clearButton.onClicked: root.clearChat()
+            tokensBadge {
+                text: qsTr("%1/%2").arg(root.inputTokensCount).arg(root.chatModel.tokensThreshold)
+            }
+            recentPath {
+                text: qsTr("Latest chat file name: %1").arg(root.chatFileName.length > 0 ? root.chatFileName : "Unsaved")
+            }
+            openChatHistory.onClicked: root.openChatHistoryFolder()
+            pinButton {
+                visible: typeof _chatview !== 'undefined'
+                checked: typeof _chatview !== 'undefined' ? _chatview.isPin : false
+                onCheckedChanged: _chatview.isPin = topBar.pinButton.checked
+            }
+        }
+
+        ListView {
+            id: chatListView
+
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            leftMargin: 5
+            model: root.chatModel
+            clip: true
+            spacing: 10
+            boundsBehavior: Flickable.StopAtBounds
+            cacheBuffer: 2000
+
+            delegate: Loader {
+                required property var model
+                required property int index
+
+                width: ListView.view.width - scroll.width
+
+                sourceComponent: model.roleType === ChatModel.Tool ? toolMessageComponent : chatItemComponent
+            }
+
+            header: Item {
+                width: ListView.view.width - scroll.width
+                height: 30
+            }
+
+            ScrollBar.vertical: QQC.ScrollBar {
+                id: scroll
+            }
+
+            onCountChanged: {
+                root.scrollToBottom()
+            }
+
+            onContentHeightChanged: {
+                if (atYEnd) {
+                    root.scrollToBottom()
+                }
+            }
+
+            Component {
+                id: chatItemComponent
+
+                ChatItem {
+                    msgModel: root.chatModel.processMessageContent(model.content)
+                    messageAttachments: model.attachments
+                    isUserMessage: model.roleType === ChatModel.User
+                    messageIndex: index
+                    textFontFamily: root.textFontFamily
+                    codeFontFamily: root.codeFontFamily
+                    codeFontSize: root.codeFontSize
+                    textFontSize: root.textFontSize
+                    textFormat: root.textFormat
+
+                    onResetChatToMessage: function(idx) {
+                        messageInput.text = model.content
+                        messageInput.cursorPosition = model.content.length
+                        root.chatModel.resetModelTo(idx)
+                    }
+                }
+            }
+
+            Component {
+                id: toolMessageComponent
+
+                ToolStatusItem {
+                    toolContent: model.content
+                }
+            }
+        }
+
+        ScrollView {
+            id: view
+
+            Layout.fillWidth: true
+            Layout.minimumHeight: 30
+            Layout.maximumHeight: root.height / 2
+
+            QQC.TextArea {
+                id: messageInput
+
+                placeholderText: Qt.platform.os === "osx"
+                                 ? qsTr("Type your message here... (⌘+↩ to send)")
+                                 : qsTr("Type your message here... (Ctrl+Enter to send)")
+                placeholderTextColor: palette.mid
+                color: palette.text
+                background: Rectangle {
+                    radius: 2
+                    color: palette.base
+                    border.color:  messageInput.activeFocus ? palette.highlight : palette.button
+                    border.width: 1
+
+                    Behavior on border.color {
+                        ColorAnimation { duration: 150 }
+                    }
+
+                    Rectangle {
+                        anchors.fill: parent
+                        color: palette.highlight
+                        opacity: messageInput.hovered ? 0.1 : 0
+                        radius: parent.radius
+                    }
+                }
+
+                onTextChanged: root.calculateMessageTokensCount(messageInput.text)
+
+                MouseArea {
+                    anchors.fill: parent
+                    acceptedButtons: Qt.RightButton
+                    onClicked: messageContextMenu.open()
+                    propagateComposedEvents: true
+                }
+            }
+        }
+
+        Platform.Menu {
+            id: messageContextMenu
+
+            Platform.MenuItem {
+                text: qsTr("Cut")
+                enabled: messageInput.selectedText.length > 0
+                onTriggered: messageInput.cut()
+            }
+
+            Platform.MenuItem {
+                text: qsTr("Copy")
+                enabled: messageInput.selectedText.length > 0
+                onTriggered: messageInput.copy()
+            }
+
+            Platform.MenuItem {
+                text: qsTr("Paste")
+                enabled: messageInput.canPaste
+                onTriggered: messageInput.paste()
+            }
+
+            Platform.MenuSeparator {}
+
+            Platform.MenuItem {
+                text: qsTr("Select All")
+                enabled: messageInput.text.length > 0
+                onTriggered: messageInput.selectAll()
+            }
+
+            Platform.MenuSeparator {}
+
+            Platform.MenuItem {
+                text: qsTr("Clear")
+                enabled: messageInput.text.length > 0
+                onTriggered: messageInput.clear()
+            }
+        }
+
+        AttachedFilesPlace {
+            id: attachedFilesPlace
+
+            Layout.fillWidth: true
+            attachedFilesModel: root.attachmentFiles
+            iconPath: palette.window.hslLightness > 0.5 ? "qrc:/qt/qml/ChatView/icons/attach-file-dark.svg"
+                                                        : "qrc:/qt/qml/ChatView/icons/attach-file-light.svg"
+            accentColor: Qt.tint(palette.mid, Qt.rgba(0, 0.8, 0.3, 0.4))
+            onRemoveFileFromListByIndex: (index) => root.removeFileFromAttachList(index)
+        }
+
+        AttachedFilesPlace {
+            id: linkedFilesPlace
+
+            Layout.fillWidth: true
+            attachedFilesModel: root.linkedFiles
+            iconPath: palette.window.hslLightness > 0.5 ? "qrc:/qt/qml/ChatView/icons/link-file-dark.svg"
+                                                        : "qrc:/qt/qml/ChatView/icons/link-file-light.svg"
+            accentColor: Qt.tint(palette.mid, Qt.rgba(0, 0.3, 0.8, 0.4))
+            onRemoveFileFromListByIndex: (index) => root.removeFileFromLinkList(index)
+        }
+
+        BottomBar {
+            id: bottomBar
+
+            Layout.preferredWidth: parent.width
+            Layout.preferredHeight: 40
+
+            sendButton.onClicked: !root.isRequestInProgress ? root.sendChatMessage()
+                                                            : root.cancelRequest()
+            sendButton.icon.source: !root.isRequestInProgress ? "qrc:/qt/qml/ChatView/icons/chat-icon.svg"
+                                                              : "qrc:/qt/qml/ChatView/icons/chat-pause-icon.svg"
+            sendButton.ToolTip.text: !root.isRequestInProgress ? qsTr("Send message to LLM %1").arg(Qt.platform.os === "osx" ? "Cmd+Return" : "Ctrl+Return")
+                                                               : qsTr("Stop")
+            syncOpenFiles {
+                checked: root.isSyncOpenFiles
+                onCheckedChanged: root.setIsSyncOpenFiles(bottomBar.syncOpenFiles.checked)
+            }
+            attachFiles.onClicked: root.showAttachFilesDialog()
+            linkFiles.onClicked: root.showLinkFilesDialog()
+        }
+    }
+
+    Shortcut {
+        id: sendMessageShortcut
+
+        sequence: "Ctrl+Return"
+        context: Qt.WindowShortcut
+        onActivated: {
+            if (messageInput.activeFocus && !Qt.inputMethod.visible) {
+                root.sendChatMessage()
+            }
+        }
+    }
+
+    function clearChat() {
+        root.chatModel.clear()
+        root.clearAttachmentFiles()
+        root.updateInputTokensCount()
+    }
+
+    function scrollToBottom() {
+        Qt.callLater(chatListView.positionViewAtEnd)
+    }
+
+    function sendChatMessage() {
+        root.sendMessage(messageInput.text)
+        messageInput.text = ""
+        scrollToBottom()
+    }
+
+    ErrorToast {
+        id: errorToast
+        z: 1000
+    }
+
+    Connections {
+        target: root
+        function onLastErrorMessageChanged() {
+            if (root.lastErrorMessage.length > 0) {
+                errorToast.show(root.lastErrorMessage)
+            }
+        }
+    }
+
+    Component.onCompleted: {
+        messageInput.forceActiveFocus()
+    }
+}

ChatView/qml/ToolStatusItem.qml

@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2025 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 Qt.labs.platform as Platform
+
+Rectangle {
+    id: root
+
+    property string toolContent: ""
+    property bool expanded: false
+
+    readonly property int firstNewline: toolContent.indexOf('\n')
+    readonly property string toolName: firstNewline > 0 ? toolContent.substring(0, firstNewline) : toolContent
+    readonly property string toolResult: firstNewline > 0 ? toolContent.substring(firstNewline + 1) : ""
+
+    radius: 6
+    color: palette.base
+    clip: true
+
+    Behavior on implicitHeight {
+        NumberAnimation { duration: 200; easing.type: Easing.InOutQuad }
+    }
+
+    MouseArea {
+        id: header
+
+        width: parent.width
+        height: headerRow.height + 10
+        cursorShape: Qt.PointingHandCursor
+        onClicked: root.expanded = !root.expanded
+
+        Row {
+            id: headerRow
+
+            anchors {
+                verticalCenter: parent.verticalCenter
+                left: parent.left
+                leftMargin: 10
+            }
+            width: parent.width
+            spacing: 8
+
+            Text {
+                text: qsTr("Tool: %1").arg(root.toolName)
+                font.pixelSize: 13
+                font.bold: true
+                color: palette.text
+            }
+
+            Text {
+                anchors.verticalCenter: parent.verticalCenter
+                text: root.expanded ? "▼" : "▶"
+                font.pixelSize: 10
+                color: palette.mid
+            }
+        }
+    }
+
+    Column {
+        id: contentColumn
+
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: header.bottom
+            margins: 10
+        }
+        spacing: 8
+
+        TextEdit {
+            id: resultText
+
+            text: root.toolResult
+            readOnly: true
+            selectByMouse: true
+            color: palette.text
+            wrapMode: Text.WordWrap
+            font.family: "monospace"
+            font.pixelSize: 11
+            selectionColor: palette.highlight
+        }
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.RightButton
+        onClicked: contextMenu.open()
+        propagateComposedEvents: true
+    }
+
+    Platform.Menu {
+        id: contextMenu
+
+        Platform.MenuItem {
+            text: qsTr("Copy")
+            enabled: resultText.selectedText.length > 0
+            onTriggered: resultText.copy()
+        }
+
+        Platform.MenuItem {
+            text: qsTr("Select All")
+            enabled: resultText.text.length > 0
+            onTriggered: resultText.selectAll()
+        }
+
+        Platform.MenuSeparator {}
+
+        Platform.MenuItem {
+            text: root.expanded ? qsTr("Collapse") : qsTr("Expand")
+            onTriggered: root.expanded = !root.expanded
+        }
+    }
+
+    Rectangle {
+        id: messageMarker
+
+        anchors.verticalCenter: parent.verticalCenter
+        width: 3
+        height: root.height - root.radius
+        color: root.color.hslLightness > 0.5 ? Qt.darker(palette.alternateBase, 1.3)
+                                             : Qt.lighter(palette.alternateBase, 1.3)
+        radius: root.radius
+    }
+
+
+    states: [
+        State {
+            when: !root.expanded
+            PropertyChanges {
+                target: root
+                implicitHeight: header.height
+            }
+        },
+        State {
+            when: root.expanded
+            PropertyChanges {
+                target: root
+                implicitHeight: header.height + contentColumn.height + 20
+            }
+        }
+    ]
+}

ChatView/qml/dialog/CodeBlock.qml

@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2024-2025 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
+import UIControls
+import Qt.labs.platform as Platform
+
+Rectangle {
+    id: root
+
+    property string code: ""
+    property string language: ""
+    property bool expanded: false
+
+    property alias codeFontFamily: codeText.font.family
+    property alias codeFontSize: codeText.font.pointSize
+    readonly property real collapsedHeight: copyButton.height + 10
+
+    color: palette.alternateBase
+    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
+    clip: true
+
+    Behavior on implicitHeight {
+        NumberAnimation { duration: 200; easing.type: Easing.InOutQuad }
+    }
+
+    ChatUtils {
+        id: utils
+    }
+
+    HoverHandler {
+        id: hoverHandler
+        enabled: true
+    }
+
+    MouseArea {
+        id: header
+
+        width: parent.width
+        height: root.collapsedHeight
+        cursorShape: Qt.PointingHandCursor
+        onClicked: root.expanded = !root.expanded
+
+        Row {
+            id: headerRow
+
+            anchors {
+                verticalCenter: parent.verticalCenter
+                left: parent.left
+                leftMargin: 10
+            }
+            spacing: 6
+
+            Text {
+                text: root.language ? qsTr("Code (%1)").arg(root.language) :
+                                      qsTr("Code")
+                font.pixelSize: 12
+                font.bold: true
+                color: palette.text
+            }
+
+            Text {
+                anchors.verticalCenter: parent.verticalCenter
+                text: root.expanded ? "▼" : "▶"
+                font.pixelSize: 10
+                color: palette.mid
+            }
+        }
+    }
+
+    TextEdit {
+        id: codeText
+
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: header.bottom
+            margins: 10
+        }
+        text: root.code
+        readOnly: true
+        selectByMouse: true
+        color: parent.color.hslLightness > 0.5 ? "black" : "white"
+        wrapMode: Text.WordWrap
+        selectionColor: palette.highlight
+
+        MouseArea {
+            anchors.fill: parent
+            acceptedButtons: Qt.RightButton
+            onClicked: contextMenu.open()
+        }
+    }
+
+    Platform.Menu {
+        id: contextMenu
+
+        Platform.MenuItem {
+            text: qsTr("Copy")
+            onTriggered: {
+                const textToCopy = codeText.selectedText || root.code
+                utils.copyToClipboard(textToCopy)
+            }
+        }
+
+        Platform.MenuSeparator {}
+
+        Platform.MenuItem {
+            text: root.expanded ? qsTr("Collapse") : qsTr("Expand")
+            onTriggered: root.expanded = !root.expanded
+        }
+    }
+
+    QoAButton {
+        id: copyButton
+
+        anchors.right: parent.right
+        anchors.rightMargin: 5
+
+        y: 5
+        text: qsTr("Copy")
+
+        onClicked: {
+            utils.copyToClipboard(root.code)
+            text = qsTr("Copied")
+            copyTimer.start()
+        }
+
+        Timer {
+            id: copyTimer
+            interval: 2000
+            onTriggered: parent.text = qsTr("Copy")
+        }
+    }
+
+    states: [
+        State {
+            when: !root.expanded
+            PropertyChanges {
+                target: root
+                implicitHeight: root.collapsedHeight
+            }
+        },
+        State {
+            when: root.expanded
+            PropertyChanges {
+                target: root
+                implicitHeight: header.height + codeText.implicitHeight + 10
+            }
+        }
+    ]
+}

ChatView/qml/dialog/TextBlock.qml

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2024-2025 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 Qt.labs.platform as Platform
+
+TextEdit {
+    id: root
+
+    readOnly: true
+    selectByMouse: true
+    wrapMode: Text.WordWrap
+    selectionColor: palette.highlight
+    color: palette.text
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.RightButton
+        onClicked: contextMenu.open()
+        propagateComposedEvents: true
+    }
+
+    Platform.Menu {
+        id: contextMenu
+
+        Platform.MenuItem {
+            text: qsTr("Copy")
+            enabled: root.selectedText.length > 0
+            onTriggered: root.copy()
+        }
+
+        Platform.MenuItem {
+            text: qsTr("Select All")
+            enabled: root.text.length > 0
+            onTriggered: root.selectAll()
+        }
+    }
+}

ChatView/qml/parts/AttachedFilesPlace.qml

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2024-2025 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 QtQuick.Layouts
+import ChatView
+
+Flow {
+    id: root
+    
+    property alias attachedFilesModel: attachRepeater.model
+    property color accentColor: palette.mid
+    property string iconPath
+
+    signal removeFileFromListByIndex(index: int)
+
+    spacing: 5
+    leftPadding: 5
+    rightPadding: 5
+    topPadding: attachRepeater.model.length > 0 ? 2 : 0
+    bottomPadding: attachRepeater.model.length > 0 ? 2 : 0
+    
+    Repeater {
+        id: attachRepeater
+        
+        delegate: Rectangle {
+            required property int index
+            required property string modelData
+            
+            height: 30
+            width: contentRow.width + 10
+            radius: 4
+            color: palette.button
+            border.width: 1
+            border.color: mouse.hovered ? palette.highlight : root.accentColor
+
+            HoverHandler {
+                id: mouse
+            }
+            
+            Row {
+                id: contentRow
+
+                spacing: 5
+                anchors.verticalCenter: parent.verticalCenter
+                anchors.left: parent.left
+                anchors.leftMargin: 5
+
+                Image {
+                    id: icon
+
+                    anchors.verticalCenter: parent.verticalCenter
+                    source: root.iconPath
+                    sourceSize.width: 8
+                    sourceSize.height: 15
+                }
+                
+                Text {
+                    id: fileNameText
+                    
+                    anchors.verticalCenter: parent.verticalCenter
+                    color: palette.buttonText
+                    
+                    text: {
+                        const parts = modelData.split('/');
+                        return parts[parts.length - 1];
+                    }
+                }
+                
+                MouseArea {
+                    id: closeButton
+                    
+                    anchors.verticalCenter: parent.verticalCenter
+                    width: closeIcon.width + 5
+                    height: closeButton.width + 5
+                    
+                    onClicked: root.removeFileFromListByIndex(index)
+                    
+                    Image {
+                        id: closeIcon
+                        
+                        anchors.centerIn: parent
+                        source: palette.window.hslLightness > 0.5 ? "qrc:/qt/qml/ChatView/icons/close-dark.svg"
+                                                                  : "qrc:/qt/qml/ChatView/icons/close-light.svg"
+                        width: 6
+                        height: 6
+                    }
+                }
+            }
+        }
+    }
+}

ChatView/qml/parts/BottomBar.qml

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2024-2025 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 QtQuick.Layouts
+import ChatView
+import UIControls
+
+Rectangle {
+    id: root
+
+    property alias sendButton: sendButtonId
+    property alias syncOpenFiles: syncOpenFilesId
+    property alias attachFiles: attachFilesId
+    property alias linkFiles: linkFilesId
+
+
+    color: palette.window.hslLightness > 0.5 ?
+               Qt.darker(palette.window, 1.1) :
+               Qt.lighter(palette.window, 1.1)
+
+    RowLayout {
+        id: bottomBar
+
+        anchors {
+            left: parent.left
+            leftMargin: 5
+            right: parent.right
+            rightMargin: 5
+            verticalCenter: parent.verticalCenter
+        }
+
+        spacing: 10
+
+        QoAButton {
+            id: sendButtonId
+
+            icon {
+                height: 15
+                width: 15
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+        }
+
+        QoAButton {
+            id: attachFilesId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/attach-file-dark.svg"
+                height: 15
+                width: 8
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Attach file to message")
+        }
+
+        QoAButton {
+            id: linkFilesId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/link-file-dark.svg"
+                height: 15
+                width: 8
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Link file to context")
+        }
+
+        CheckBox {
+            id: syncOpenFilesId
+
+            text: qsTr("Sync open files")
+
+            ToolTip.visible: syncOpenFilesId.hovered
+            ToolTip.text: qsTr("Automatically synchronize currently opened files with the model context")
+        }
+
+        Item {
+            Layout.fillWidth: true
+        }
+    }
+}

ChatView/qml/parts/ErrorToast.qml

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2025 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: errorToast
+
+    property string errorText: ""
+    property int displayDuration: 5000
+
+    width: Math.min(parent.width - 40, errorTextItem.implicitWidth + radius)
+    height: visible ? (errorTextItem.implicitHeight + 12) : 0
+    anchors.horizontalCenter: parent.horizontalCenter
+    anchors.top: parent.top
+    anchors.topMargin: 10
+
+    color: "#d32f2f"
+    radius: height / 2
+    border.color: "#b71c1c"
+    border.width: 1
+    visible: false
+    opacity: 0
+
+    TextEdit {
+        id: errorTextItem
+
+        anchors.centerIn: parent
+        anchors.margins: 6
+        text: errorToast.errorText
+        color: "#ffffff"
+        font.pixelSize: 13
+        wrapMode: TextEdit.Wrap
+        width: Math.min(implicitWidth, errorToast.parent.width - 60)
+        horizontalAlignment: TextEdit.AlignHCenter
+        readOnly: true
+        selectByMouse: true
+        selectByKeyboard: true
+        selectionColor: "#b71c1c"
+    }
+
+    function show(message) {
+        errorText = message
+        visible = true
+        showAnimation.start()
+        hideTimer.restart()
+    }
+
+    function hide() {
+        hideAnimation.start()
+    }
+
+    NumberAnimation {
+        id: showAnimation
+
+        target: errorToast
+        property: "opacity"
+        from: 0
+        to: 1
+        duration: 200
+        easing.type: Easing.OutQuad
+    }
+
+    NumberAnimation {
+        id: hideAnimation
+
+        target: errorToast
+        property: "opacity"
+        from: 1
+        to: 0
+        duration: 200
+        easing.type: Easing.InQuad
+        onFinished: errorToast.visible = false
+    }
+
+    Timer {
+        id: hideTimer
+
+        interval: errorToast.displayDuration
+        running: false
+        repeat: false
+        onTriggered: errorToast.hide()
+    }
+}

ChatView/qml/parts/TopBar.qml

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2024-2025 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.Layouts
+import QtQuick.Controls
+import ChatView
+import UIControls
+
+Rectangle {
+    id: root
+
+    property alias saveButton: saveButtonId
+    property alias loadButton: loadButtonId
+    property alias clearButton: clearButtonId
+    property alias tokensBadge: tokensBadgeId
+    property alias recentPath: recentPathId
+    property alias openChatHistory: openChatHistoryId
+    property alias pinButton: pinButtonId
+
+    color: palette.window.hslLightness > 0.5 ?
+               Qt.darker(palette.window, 1.1) :
+               Qt.lighter(palette.window, 1.1)
+
+    RowLayout {
+        anchors {
+            left: parent.left
+            leftMargin: 5
+            right: parent.right
+            rightMargin: 5
+            verticalCenter: parent.verticalCenter
+        }
+
+        spacing: 10
+
+        QoAButton {
+            id: pinButtonId
+
+            checkable: true
+
+            icon {
+                source: checked ? "qrc:/qt/qml/ChatView/icons/window-lock.svg"
+                                : "qrc:/qt/qml/ChatView/icons/window-unlock.svg"
+                color: palette.window.hslLightness > 0.5 ? "#000000" : "#FFFFFF"
+                height: 15
+                width: 15
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: checked ? qsTr("Unpin chat window")
+                                  : qsTr("Pin chat window to the top")
+        }
+
+        QoAButton {
+            id: saveButtonId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/save-chat-dark.svg"
+                height: 15
+                width: 8
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Save chat to *.json file")
+        }
+
+        QoAButton {
+            id: loadButtonId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/load-chat-dark.svg"
+                height: 15
+                width: 8
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Load chat from *.json file")
+        }
+
+        QoAButton {
+            id: clearButtonId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/clean-icon-dark.svg"
+                height: 15
+                width: 8
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Clean chat")
+        }
+
+        Text {
+            id: recentPathId
+
+            elide: Text.ElideMiddle
+            color: palette.text
+        }
+
+        QoAButton {
+            id: openChatHistoryId
+
+            icon {
+                source: "qrc:/qt/qml/ChatView/icons/file-in-system.svg"
+                height: 15
+                width: 15
+            }
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Show in system")
+        }
+
+        Item {
+            Layout.fillWidth: true
+        }
+
+        Badge {
+            id: tokensBadgeId
+
+            ToolTip.visible: hovered
+            ToolTip.delay: 250
+            ToolTip.text: qsTr("Current amount tokens in chat and LLM limit threshold")
+        }
+    }
+}

CodeHandler.cpp

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

CodeHandler.hpp

@@ -0,0 +1,56 @@
+/* 
+ * Copyright (C) 2024-2025 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 <QRegularExpression>
+#include <QString>
+
+namespace QodeAssist {
+
+class CodeHandler
+{
+public:
+    static QString processText(QString text, QString currentFileName);
+
+    /**
+     * Detects language from line, or returns empty string if this was not possible
+     */
+    static QString detectLanguageFromLine(const QString &line);
+
+    /**
+     * Detects language file name, or returns empty string if this was not possible
+     */
+    static QString detectLanguageFromExtension(const QString &extension);
+
+    /**
+     * Detects if text contains code blocks, or returns false if this was not possible
+     */
+    static bool hasCodeBlocks(const QString &text);
+
+private:
+    static QString getCommentPrefix(const QString &language);
+
+    static const QRegularExpression &getFullCodeBlockRegex();
+    static const QRegularExpression &getPartialStartBlockRegex();
+    static const QRegularExpression &getPartialEndBlockRegex();
+};
+
+} // namespace QodeAssist

ConfigurationManager.cpp

@@ -0,0 +1,231 @@
+/* 
+ * Copyright (C) 2024-2025 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 <settings/ButtonAspect.hpp>
+#include <QTimer>
+
+#include "QodeAssisttr.h"
+
+namespace QodeAssist {
+
+ConfigurationManager &ConfigurationManager::instance()
+{
+    static ConfigurationManager instance;
+    return instance;
+}
+
+void ConfigurationManager::init()
+{
+    setupConnections();
+    updateAllTemplateDescriptions();
+    checkAllTemplate();
+}
+
+void ConfigurationManager::updateTemplateDescription(const Utils::StringAspect &templateAspect)
+{
+    LLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
+
+    if (!templ) {
+        return;
+    }
+
+    if (&templateAspect == &m_generalSettings.ccTemplate) {
+        m_generalSettings.ccTemplateDescription.setValue(templ->description());
+    } else if (&templateAspect == &m_generalSettings.caTemplate) {
+        m_generalSettings.caTemplateDescription.setValue(templ->description());
+    }
+}
+
+void ConfigurationManager::updateAllTemplateDescriptions()
+{
+    updateTemplateDescription(m_generalSettings.ccTemplate);
+    updateTemplateDescription(m_generalSettings.caTemplate);
+}
+
+void ConfigurationManager::checkTemplate(const Utils::StringAspect &templateAspect)
+{
+    LLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
+
+    if (templ->name() == templateAspect.value())
+        return;
+
+    if (&templateAspect == &m_generalSettings.ccTemplate) {
+        m_generalSettings.ccTemplate.setValue(templ->name());
+    } else if (&templateAspect == &m_generalSettings.caTemplate) {
+        m_generalSettings.caTemplate.setValue(templ->name());
+    }
+}
+
+void ConfigurationManager::checkAllTemplate()
+{
+    checkTemplate(m_generalSettings.ccTemplate);
+    checkTemplate(m_generalSettings.caTemplate);
+}
+
+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);
+
+    connect(
+        &m_generalSettings.ccPreset1SelectProvider, &Button::clicked, this, &Config::selectProvider);
+    connect(&m_generalSettings.ccPreset1SetUrl, &Button::clicked, this, &Config::selectUrl);
+    connect(&m_generalSettings.ccPreset1SelectModel, &Button::clicked, this, &Config::selectModel);
+    connect(
+        &m_generalSettings.ccPreset1SelectTemplate, &Button::clicked, this, &Config::selectTemplate);
+
+    connect(&m_generalSettings.ccTemplate, &Utils::StringAspect::changed, this, [this]() {
+        updateTemplateDescription(m_generalSettings.ccTemplate);
+    });
+
+    connect(&m_generalSettings.caTemplate, &Utils::StringAspect::changed, this, [this]() {
+        updateTemplateDescription(m_generalSettings.caTemplate);
+    });
+}
+
+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
+                           : settingsButton == &m_generalSettings.ccPreset1SelectProvider
+                               ? m_generalSettings.ccPreset1Provider
+                               : 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 bool isPreset1 = (settingsButton == &m_generalSettings.ccPreset1SelectModel);
+
+    const QString providerName = isCodeCompletion ? m_generalSettings.ccProvider.volatileValue()
+                                 : isPreset1 ? m_generalSettings.ccPreset1Provider.volatileValue()
+                                             : m_generalSettings.caProvider.volatileValue();
+
+    const auto providerUrl = isCodeCompletion ? m_generalSettings.ccUrl.volatileValue()
+                             : isPreset1      ? m_generalSettings.ccPreset1Url.volatileValue()
+                                              : m_generalSettings.caUrl.volatileValue();
+
+    auto &targetSettings = isCodeCompletion ? m_generalSettings.ccModel
+                           : isPreset1      ? m_generalSettings.ccPreset1Model
+                                            : 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 bool isPreset1 = (settingsButton == &m_generalSettings.ccPreset1SelectTemplate);
+    const QString providerName = isCodeCompletion ? m_generalSettings.ccProvider.volatileValue()
+                                 : isPreset1 ? m_generalSettings.ccPreset1Provider.volatileValue()
+                                             : m_generalSettings.caProvider.volatileValue();
+    auto providerID = m_providersManager.getProviderByName(providerName)->providerID();
+
+    const auto templateList = isCodeCompletion || isPreset1
+                                  ? m_templateManger.getFimTemplatesForProvider(providerID)
+                                  : m_templateManger.getChatTemplatesForProvider(providerID);
+
+    auto &targetSettings = isCodeCompletion ? m_generalSettings.ccTemplate
+                           : isPreset1      ? m_generalSettings.ccPreset1Template
+                                            : 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
+                           : settingsButton == &m_generalSettings.ccPreset1SetUrl
+                               ? m_generalSettings.ccPreset1Url
+                               : m_generalSettings.caUrl;
+
+    QTimer::singleShot(0, &m_generalSettings, [this, urls, &targetSettings]() {
+        m_generalSettings.showUrlSelectionDialog(targetSettings, urls);
+    });
+}
+
+} // namespace QodeAssist

ConfigurationManager.hpp

@@ -0,0 +1,63 @@
+/* 
+ * Copyright (C) 2024-2025 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();
+
+    void updateTemplateDescription(const Utils::StringAspect &templateAspect);
+    void updateAllTemplateDescriptions();
+    void checkTemplate(const Utils::StringAspect &templateAspect);
+    void checkAllTemplate();
+
+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

@@ -1,189 +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 "DocumentContextReader.hpp"
-
-#include <QFileInfo>
-#include <QTextBlock>
-#include <languageserverprotocol/lsptypes.h>
-
-#include "QodeAssistSettings.hpp"
-
-namespace QodeAssist {
-
-DocumentContextReader::DocumentContextReader(TextEditor::TextDocument *textDocument)
-    : m_textDocument(textDocument)
-    , m_document(textDocument->document())
-{
-    m_copyrightInfo = findCopyright();
-}
-
-QString DocumentContextReader::getLineText(int lineNumber, int cursorPosition) const
-{
-    if (!m_document || lineNumber < 0)
-        return QString();
-
-    QTextBlock block = m_document->begin();
-    int currentLine = 0;
-
-    while (block.isValid()) {
-        if (currentLine == lineNumber) {
-            QString text = block.text();
-            if (cursorPosition >= 0 && cursorPosition <= text.length()) {
-                text = text.left(cursorPosition);
-            }
-            return text;
-        }
-
-        block = block.next();
-        currentLine++;
-    }
-
-    return QString();
-}
-
-QString DocumentContextReader::getContextBefore(int lineNumber,
-                                                int cursorPosition,
-                                                int linesCount) const
-{
-    int effectiveStartLine;
-    if (m_copyrightInfo.found) {
-        effectiveStartLine = qMax(m_copyrightInfo.endLine + 1, lineNumber - linesCount);
-    } else {
-        effectiveStartLine = qMax(0, lineNumber - linesCount);
-    }
-
-    return getContextBetween(effectiveStartLine, lineNumber, cursorPosition);
-}
-
-QString DocumentContextReader::getContextAfter(int lineNumber,
-                                               int cursorPosition,
-                                               int linesCount) const
-{
-    int endLine = qMin(m_document->blockCount() - 1, lineNumber + linesCount);
-    return getContextBetween(lineNumber + 1, endLine, cursorPosition);
-}
-
-QString DocumentContextReader::readWholeFileBefore(int lineNumber, int cursorPosition) const
-{
-    int startLine = 0;
-    if (m_copyrightInfo.found) {
-        startLine = m_copyrightInfo.endLine + 1;
-    }
-
-    startLine = qMin(startLine, lineNumber);
-
-    QString result = getContextBetween(startLine, lineNumber, cursorPosition);
-
-    return result;
-}
-
-QString DocumentContextReader::readWholeFileAfter(int lineNumber, int cursorPosition) const
-{
-    return getContextBetween(lineNumber, m_document->blockCount() - 1, cursorPosition);
-}
-
-QString DocumentContextReader::getLanguageAndFileInfo() const
-{
-    if (!m_textDocument)
-        return QString();
-
-    QString language = LanguageServerProtocol::TextDocumentItem::mimeTypeToLanguageId(
-        m_textDocument->mimeType());
-    QString mimeType = m_textDocument->mimeType();
-    QString filePath = m_textDocument->filePath().toString();
-    QString fileExtension = QFileInfo(filePath).suffix();
-
-    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};
-
-    QString text = m_document->toPlainText();
-    QRegularExpressionMatchIterator matchIterator = getCopyrightRegex().globalMatch(text);
-
-    QList<CopyrightInfo> copyrightBlocks;
-
-    while (matchIterator.hasNext()) {
-        QRegularExpressionMatch match = matchIterator.next();
-        int startPos = match.capturedStart();
-        int endPos = match.capturedEnd();
-
-        CopyrightInfo info;
-        info.startLine = m_document->findBlock(startPos).blockNumber();
-        info.endLine = m_document->findBlock(endPos).blockNumber();
-        info.found = true;
-
-        copyrightBlocks.append(info);
-    }
-
-    for (int i = 0; i < copyrightBlocks.size() - 1; ++i) {
-        if (copyrightBlocks[i].endLine + 1 >= copyrightBlocks[i + 1].startLine) {
-            copyrightBlocks[i].endLine = copyrightBlocks[i + 1].endLine;
-            copyrightBlocks.removeAt(i + 1);
-            --i;
-        }
-    }
-
-    if (!copyrightBlocks.isEmpty()) { // temproary solution, need cache
-        return copyrightBlocks.first();
-    }
-
-    return result;
-}
-
-QString DocumentContextReader::getContextBetween(int startLine,
-                                                 int endLine,
-                                                 int cursorPosition) const
-{
-    QString context;
-    for (int i = startLine; i <= endLine; ++i) {
-        QTextBlock block = m_document->findBlockByNumber(i);
-        if (!block.isValid()) {
-            break;
-        }
-        if (i == endLine) {
-            context += block.text().left(cursorPosition);
-        } else {
-            context += block.text() + "\n";
-        }
-    }
-
-    return context;
-}
-
-const QRegularExpression &DocumentContextReader::getCopyrightRegex()
-{
-    static const QRegularExpression copyrightRegex(
-        R"((?:/\*[\s\S]*?Copyright[\s\S]*?\*/|  // Copyright[\s\S]*?(?:\n\s*//.*)*|///.*Copyright[\s\S]*?(?:\n\s*///.*)*)|(?://))",
-        QRegularExpression::MultilineOption | QRegularExpression::CaseInsensitiveOption);
-    return copyrightRegex;
-}
-
-} // namespace QodeAssist

DocumentContextReader.hpp

@@ -1,57 +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 <QTextDocument>
-#include <texteditor/textdocument.h>
-
-namespace QodeAssist {
-
-struct CopyrightInfo
-{
-    int startLine;
-    int endLine;
-    bool found;
-};
-
-class DocumentContextReader
-{
-public:
-    DocumentContextReader(TextEditor::TextDocument *textDocument);
-
-    QString getLineText(int lineNumber, int cursorPosition = -1) const;
-    QString getContextBefore(int lineNumber, int cursorPosition, int linesCount) const;
-    QString getContextAfter(int lineNumber, int cursorPosition, int linesCount) const;
-    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;
-
-private:
-    TextEditor::TextDocument *m_textDocument;
-    QTextDocument *m_document;
-    CopyrightInfo m_copyrightInfo;
-
-    static const QRegularExpression &getCopyrightRegex();
-};
-
-} // namespace QodeAssist

LLMClientInterface.cpp

@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
@@ -23,25 +23,37 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 
-#include <texteditor/textdocument.h>
-
-#include "DocumentContextReader.hpp"
-#include "LLMProvidersManager.hpp"
-#include "PromptTemplateManager.hpp"
-#include "QodeAssistSettings.hpp"
-#include "QodeAssistUtils.hpp"
+#include "CodeHandler.hpp"
+#include "context/DocumentContextReader.hpp"
+#include "context/Utils.hpp"
+#include "logger/Logger.hpp"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
+#include <llmcore/RequestConfig.hpp>
+#include <llmcore/RulesLoader.hpp>
 
 namespace QodeAssist {
 
-LLMClientInterface::LLMClientInterface()
-    : m_manager(new QNetworkAccessManager(this))
+LLMClientInterface::LLMClientInterface(
+    const Settings::GeneralSettings &generalSettings,
+    const Settings::CodeCompletionSettings &completeSettings,
+    LLMCore::IProviderRegistry &providerRegistry,
+    LLMCore::IPromptProvider *promptProvider,
+    Context::IDocumentReader &documentReader,
+    IRequestPerformanceLogger &performanceLogger)
+    : m_generalSettings(generalSettings)
+    , m_completeSettings(completeSettings)
+    , m_providerRegistry(providerRegistry)
+    , m_promptProvider(promptProvider)
+    , m_documentReader(documentReader)
+    , m_performanceLogger(performanceLogger)
+    , m_contextManager(new Context::ContextManager(this))
 {
-    updateProvider();
 }
 
 Utils::FilePath LLMClientInterface::serverDeviceTemplate() const
 {
-    return "Qode Assist";
+    return "QodeAssist";
 }
 
 void LLMClientInterface::startImpl()
@@ -49,10 +61,31 @@ void LLMClientInterface::startImpl()
     emit started();
 }
 
+void LLMClientInterface::handleFullResponse(const QString &requestId, const QString &fullText)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    const RequestContext &ctx = it.value();
+    sendCompletionToClient(fullText, ctx.originalRequest, true);
+
+    m_activeRequests.erase(it);
+    m_performanceLogger.endTimeMeasurement(requestId);
+}
+
+void LLMClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    LOG_MESSAGE(QString("Request %1 failed: %2").arg(requestId, error));
+    m_activeRequests.erase(it);
+}
+
 void LLMClientInterface::sendData(const QByteArray &data)
 {
-    updateProvider();
-
     QJsonDocument doc = QJsonDocument::fromJson(data);
     if (!doc.isObject())
         return;
@@ -69,98 +102,30 @@ void LLMClientInterface::sendData(const QByteArray &data)
     } else if (method == "textDocument/didOpen") {
         handleTextDocumentDidOpen(request);
     } else if (method == "getCompletionsCycling") {
+        QString requestId = request["id"].toString();
+        m_performanceLogger.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));
-    } else {
-        logMessage(QString("Request %1 not found").arg(id));
-    }
-}
-
-bool LLMClientInterface::processSingleLineCompletion(QNetworkReply *reply,
-                                                     const QJsonObject &request,
-                                                     const QString &accumulatedCompletion)
-{
-    int newlinePos = accumulatedCompletion.indexOf('\n');
-
-    if (newlinePos != -1) {
-        QString singleLineCompletion = accumulatedCompletion.left(newlinePos).trimmed();
-        singleLineCompletion = removeStopWords(singleLineCompletion);
-
-        QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
-
-        sendCompletionToClient(singleLineCompletion, request, position, true);
-        m_accumulatedResponses.remove(reply);
-        reply->abort();
-
-        return true;
-    }
-    return false;
-}
-
-QString LLMClientInterface::сontextBefore(TextEditor::TextEditorWidget *widget,
-                                          int lineNumber,
-                                          int cursorPosition)
-{
-    if (!widget)
-        return QString();
-
-    DocumentContextReader reader(widget->textDocument());
-    QString languageAndFileInfo = reader.getLanguageAndFileInfo();
-
-    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());
+    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
+        const RequestContext &ctx = it.value();
+        if (ctx.provider) {
+            ctx.provider->cancelRequest(it.key());
+        }
     }
 
-    return QString("%1\n%2\n%3")
-        .arg(reader.getSpecificInstructions())
-        .arg(reader.getLanguageAndFileInfo())
-        .arg(contextBefore);
-}
+    m_activeRequests.clear();
 
-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;
+    LOG_MESSAGE("All requests cancelled and state cleared");
 }
 
 void LLMClientInterface::handleInitialize(const QJsonObject &request)
@@ -177,7 +142,7 @@ void LLMClientInterface::handleInitialize(const QJsonObject &request)
     result["capabilities"] = capabilities;
 
     QJsonObject serverInfo;
-    serverInfo["name"] = "Ollama LSP Server";
+    serverInfo["name"] = "QodeAssist LSP Server";
     serverInfo["version"] = "0.1";
     result["serverInfo"] = serverInfo;
 
@@ -213,97 +178,234 @@ 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 &templateManager = PromptTemplateManager::instance();
-    const Templates::PromptTemplate *currentTemplate = templateManager.getCurrentTemplate();
-
-    auto &providerManager = LLMProvidersManager::instance();
-    bool isComplete = providerManager.getCurrentProvider()->handleResponse(reply,
-                                                                           accumulatedResponse);
-
-    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
-
-    if (!settings().multiLineCompletion()
-        && processSingleLineCompletion(reply, request, accumulatedResponse)) {
+    auto filePath = Context::extractFilePathFromRequest(request);
+    auto documentInfo = m_documentReader.readDocument(filePath);
+    if (!documentInfo.document) {
+        LOG_MESSAGE("Error: Document is not available for" + filePath);
         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 updatedContext = prepareContext(request, documentInfo);
+
+    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
+
+    const auto providerName = !isPreset1Active ? m_generalSettings.ccProvider()
+                                               : m_generalSettings.ccPreset1Provider();
+    const auto modelName = !isPreset1Active ? m_generalSettings.ccModel()
+                                            : m_generalSettings.ccPreset1Model();
+    const auto url = !isPreset1Active ? m_generalSettings.ccUrl()
+                                      : m_generalSettings.ccPreset1Url();
+
+    const auto provider = m_providerRegistry.getProviderByName(providerName);
+
+    if (!provider) {
+        LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
+        return;
     }
+
+    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
+                                         : m_generalSettings.ccPreset1Template();
+
+    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
+
+    if (!promptTemplate) {
+        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+        return;
+    }
+
+    // TODO refactor to dynamic presets system
+    LLMCore::LLMConfig config;
+    config.requestType = LLMCore::RequestType::CodeCompletion;
+    config.provider = provider;
+    config.promptTemplate = promptTemplate;
+    // TODO refactor networking
+    if (provider->providerID() == LLMCore::ProviderID::GoogleAI) {
+        QString stream = QString{"streamGenerateContent?alt=sse"};
+        config.url = QUrl(QString("%1/models/%2:%3").arg(url, modelName, stream));
+    } else {
+        config.url = QUrl(
+            QString("%1%2").arg(url, endpoint(provider, promptTemplate->type(), isPreset1Active)));
+        config.providerRequest = {{"model", modelName}, {"stream", true}};
+    }
+    config.apiKey = provider->apiKey();
+    config.multiLineCompletion = m_completeSettings.multiLineCompletion();
+
+    const auto stopWords = QJsonArray::fromStringList(config.promptTemplate->stopWords());
+    if (!stopWords.isEmpty())
+        config.providerRequest["stop"] = stopWords;
+
+    QString systemPrompt;
+    if (m_completeSettings.useSystemPrompt())
+        systemPrompt.append(
+            m_completeSettings.useUserMessageTemplateForCC()
+                    && promptTemplate->type() == LLMCore::TemplateType::Chat
+                ? m_completeSettings.systemPromptForNonFimModels()
+                : m_completeSettings.systemPrompt());
+
+    auto project = LLMCore::RulesLoader::getActiveProject();
+    if (project) {
+        QString projectRules
+            = LLMCore::RulesLoader::loadRulesForProject(project, LLMCore::RulesContext::Completions);
+
+        if (!projectRules.isEmpty()) {
+            systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
+            LOG_MESSAGE("Loaded project rules for completion");
+        }
+    }
+
+    if (updatedContext.fileContext.has_value())
+        systemPrompt.append(updatedContext.fileContext.value());
+
+    if (m_completeSettings.useOpenFilesContext()) {
+        if (provider->providerID() == LLMCore::ProviderID::LlamaCpp) {
+            for (const auto openedFilePath : m_contextManager->openedFiles({filePath})) {
+                if (!updatedContext.filesMetadata) {
+                    updatedContext.filesMetadata = QList<LLMCore::FileMetadata>();
+                }
+                updatedContext.filesMetadata->append({openedFilePath.first, openedFilePath.second});
+            }
+        } else {
+            systemPrompt.append(m_contextManager->openedFilesContext({filePath}));
+        }
+    }
+
+    updatedContext.systemPrompt = systemPrompt;
+
+    if (promptTemplate->type() == LLMCore::TemplateType::Chat) {
+        QString userMessage;
+        if (m_completeSettings.useUserMessageTemplateForCC()) {
+            userMessage = m_completeSettings.processMessageToFIM(
+                updatedContext.prefix.value_or(""), updatedContext.suffix.value_or(""));
+        } else {
+            userMessage = updatedContext.prefix.value_or("") + updatedContext.suffix.value_or("");
+        }
+
+        // TODO refactor add message
+        QVector<LLMCore::Message> messages;
+        messages.append({"user", userMessage});
+        updatedContext.history = messages;
+    }
+
+    config.provider->prepareRequest(
+        config.providerRequest,
+        promptTemplate,
+        updatedContext,
+        LLMCore::RequestType::CodeCompletion);
+
+    auto errors = config.provider->validateRequest(config.providerRequest, promptTemplate->type());
+    if (!errors.isEmpty()) {
+        LOG_MESSAGE("Validate errors for fim request:");
+        LOG_MESSAGES(errors);
+        return;
+    }
+
+    QString requestId = request["id"].toString();
+    m_performanceLogger.startTimeMeasurement(requestId);
+
+    m_activeRequests[requestId] = {request, provider};
+
+    connect(
+        provider,
+        &LLMCore::Provider::fullResponseReceived,
+        this,
+        &LLMClientInterface::handleFullResponse,
+        Qt::UniqueConnection);
+    connect(
+        provider,
+        &LLMCore::Provider::requestFailed,
+        this,
+        &LLMClientInterface::handleRequestFailed,
+        Qt::UniqueConnection);
+
+    provider->sendRequest(requestId, config.url, config.providerRequest);
 }
 
-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 Context::DocumentInfo &documentInfo)
 {
     QJsonObject params = request["params"].toObject();
     QJsonObject doc = params["doc"].toObject();
     QJsonObject position = doc["position"].toObject();
-    QString uri = doc["uri"].toString();
-
-    Utils::FilePath filePath = Utils::FilePath::fromString(QUrl(uri).toLocalFile());
-    TextEditor::TextDocument *textDocument = TextEditor::TextDocument::textDocumentForFilePath(
-        filePath);
-
-    if (!textDocument) {
-        logMessage("Error: Document is not available for" + filePath.toString());
-        return {"", ""};
-    }
-
     int cursorPosition = position["character"].toInt();
     int lineNumber = position["line"].toInt();
 
-    auto textEditor = TextEditor::BaseTextEditor::currentTextEditor();
-    TextEditor::TextEditorWidget *widget = textEditor->editorWidget();
-
-    QString contextBefore = сontextBefore(widget, lineNumber, cursorPosition);
-    QString contextAfter = сontextAfter(widget, lineNumber, cursorPosition);
-
-    QString updatedContextBefore = contextBefore + accumulatedCompletion;
-
-    return {updatedContextBefore, contextAfter};
+    Context::DocumentContextReader
+        reader(documentInfo.document, documentInfo.mimeType, documentInfo.filePath);
+    return reader.prepareContext(lineNumber, cursorPosition, m_completeSettings);
 }
 
-void LLMClientInterface::updateProvider()
+QString LLMClientInterface::endpoint(
+    LLMCore::Provider *provider, LLMCore::TemplateType type, bool isLanguageSpecify)
 {
-    m_serverUrl = QUrl(QString("%1:%2%3")
-                           .arg(settings().url.value())
-                           .arg(settings().port.value())
-                           .arg(settings().endPoint.value()));
+    QString endpoint;
+    auto endpointMode = isLanguageSpecify ? m_generalSettings.ccPreset1EndpointMode.stringValue()
+                                          : m_generalSettings.ccEndpointMode.stringValue();
+    if (endpointMode == "Auto") {
+        endpoint = type == LLMCore::TemplateType::FIM ? provider->completionEndpoint()
+                                                      : provider->chatEndpoint();
+    } else if (endpointMode == "Custom") {
+        endpoint = isLanguageSpecify ? m_generalSettings.ccPreset1CustomEndpoint()
+                                     : m_generalSettings.ccCustomEndpoint();
+    } else if (endpointMode == "FIM") {
+        endpoint = provider->completionEndpoint();
+    } else if (endpointMode == "Chat") {
+        endpoint = provider->chatEndpoint();
+    }
+    return endpoint;
 }
 
-void LLMClientInterface::sendCompletionToClient(const QString &completion,
-                                                const QJsonObject &request,
-                                                const QJsonObject &position,
-                                                bool isComplete)
+Context::ContextManager *LLMClientInterface::contextManager() const
 {
+    return m_contextManager;
+}
+
+void LLMClientInterface::sendCompletionToClient(
+    const QString &completion, const QJsonObject &request, bool isComplete)
+{
+    auto filePath = Context::extractFilePathFromRequest(request);
+    auto documentInfo = m_documentReader.readDocument(filePath);
+    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
+
+    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
+                                         : m_generalSettings.ccPreset1Template();
+
+    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
+
+    QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
+
     QJsonObject response;
     response["jsonrpc"] = "2.0";
     response[LanguageServerProtocol::idKey] = request["id"];
+
     QJsonObject result;
     QJsonArray completions;
     QJsonObject completionItem;
-    completionItem[LanguageServerProtocol::textKey] = completion;
+
+    LOG_MESSAGE(QString("Completions before filter: \n%1").arg(completion));
+
+    QString outputHandler = m_completeSettings.modelOutputHandler.stringValue();
+    QString processedCompletion;
+
+    if (outputHandler == "Raw text") {
+        processedCompletion = completion;
+    } else if (outputHandler == "Force processing") {
+        processedCompletion = CodeHandler::processText(completion,
+                                                       Context::extractFilePathFromRequest(request));
+    } else { // "Auto"
+        processedCompletion = CodeHandler::hasCodeBlocks(completion)
+                                  ? CodeHandler::processText(completion,
+                                                             Context::extractFilePathFromRequest(
+                                                                 request))
+                                  : completion;
+    }
+
+    completionItem[LanguageServerProtocol::textKey] = processedCompletion;
     QJsonObject range;
     range["start"] = position;
     QJsonObject end = position;
-    end["character"] = position["character"].toInt() + completion.length();
+    end["character"] = position["character"].toInt() + processedCompletion.length();
     range["end"] = end;
     completionItem[LanguageServerProtocol::rangeKey] = range;
     completionItem[LanguageServerProtocol::positionKey] = position;
@@ -312,71 +414,17 @@ 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")
-                   .arg(QString::fromUtf8(QJsonDocument(response).toJson(QJsonDocument::Indented))));
+    LOG_MESSAGE(
+        QString("Full response: \n%1")
+            .arg(QString::fromUtf8(QJsonDocument(response).toJson(QJsonDocument::Indented))));
 
+    QString requestId = request["id"].toString();
+    m_performanceLogger.endTimeMeasurement(requestId);
     emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
 }
 
-void LLMClientInterface::sendLLMRequest(const QJsonObject &request, const ContextPair &prompt)
-{
-    QJsonObject ollamaRequest = {{"model", settings().modelName.value()}, {"stream", true}};
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    currentTemplate->prepareRequest(ollamaRequest, prompt.prefix, prompt.suffix);
-
-    auto &providerManager = LLMProvidersManager::instance();
-    providerManager.getCurrentProvider()->prepareRequest(ollamaRequest);
-
-    logMessage(
-        QString("Sending request to llm: \nurl: %1\nRequest body:\n%2")
-            .arg(m_serverUrl.toString())
-            .arg(QString::fromUtf8(QJsonDocument(ollamaRequest).toJson(QJsonDocument::Indented))));
-
-    QNetworkRequest networkRequest(m_serverUrl);
-    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    QNetworkReply *reply = m_manager->post(networkRequest, QJsonDocument(ollamaRequest).toJson());
-    if (!reply) {
-        logMessage("Error: Failed to create network reply");
-        return;
-    }
-
-    QString requestId = request["id"].toString();
-    m_activeRequests[requestId] = reply;
-
-    connect(reply, &QNetworkReply::readyRead, this, [this, reply, request]() {
-        handleLLMResponse(reply, request);
-    });
-
-    connect(reply, &QNetworkReply::finished, this, [this, reply, requestId]() {
-        reply->deleteLater();
-        m_activeRequests.remove(requestId);
-        if (reply->error() != QNetworkReply::NoError) {
-            logMessage(QString("Error in Ollama request: %1").arg(reply->errorString()));
-        } else {
-            logMessage("Request finished successfully");
-        }
-    });
-}
-
-QString LLMClientInterface::removeStopWords(const QString &completion)
-{
-    QString filteredCompletion = completion;
-
-    auto currentTemplate = PromptTemplateManager::instance().getCurrentTemplate();
-    QStringList stopWords = currentTemplate->stopWords();
-
-    for (const QString &stopWord : stopWords) {
-        filteredCompletion = filteredCompletion.replace(stopWord, "");
-    }
-
-    return filteredCompletion;
-}
-
-void LLMClientInterface::parseCurrentMessage() {}
-
 } // namespace QodeAssist

LLMClientInterface.hpp

@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
@@ -22,6 +22,16 @@
 #include <languageclient/languageclientinterface.h>
 #include <texteditor/texteditor.h>
 
+#include <context/ContextManager.hpp>
+#include <context/IDocumentReader.hpp>
+#include <context/ProgrammingLanguage.hpp>
+#include <llmcore/ContextData.hpp>
+#include <llmcore/IPromptProvider.hpp>
+#include <llmcore/IProviderRegistry.hpp>
+#include <logger/IRequestPerformanceLogger.hpp>
+#include <settings/CodeCompletionSettings.hpp>
+#include <settings/GeneralSettings.hpp>
+
 class QNetworkReply;
 class QNetworkAccessManager;
 
@@ -32,35 +42,32 @@ class LLMClientInterface : public LanguageClient::BaseClientInterface
     Q_OBJECT
 
 public:
-    LLMClientInterface();
-
-public:
-    struct ContextPair
-    {
-        QString prefix;
-        QString suffix;
-    };
+    LLMClientInterface(
+        const Settings::GeneralSettings &generalSettings,
+        const Settings::CodeCompletionSettings &completeSettings,
+        LLMCore::IProviderRegistry &providerRegistry,
+        LLMCore::IPromptProvider *promptProvider,
+        Context::IDocumentReader &documentReader,
+        IRequestPerformanceLogger &performanceLogger);
 
     Utils::FilePath serverDeviceTemplate() const override;
 
-    void sendCompletionToClient(const QString &completion,
-                                const QJsonObject &request,
-                                const QJsonObject &position,
-                                bool isComplete);
+    void sendCompletionToClient(
+        const QString &completion, const QJsonObject &request, 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);
+    void handleCompletion(const QJsonObject &request);
 
-    ContextPair prepareContext(const QJsonObject &request,
-                               const QString &accumulatedCompletion = QString{});
-    void updateProvider();
+    // exposed for tests
+    void sendData(const QByteArray &data) override;
+
+    Context::ContextManager *contextManager() const;
 
 protected:
     void startImpl() override;
-    void sendData(const QByteArray &data) override;
-    void parseCurrentMessage() override;
+
+private slots:
+    void handleFullResponse(const QString &requestId, const QString &fullText);
+    void handleRequestFailed(const QString &requestId, const QString &error);
 
 private:
     void handleInitialize(const QJsonObject &request);
@@ -69,18 +76,26 @@ 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);
+    struct RequestContext
+    {
+        QJsonObject originalRequest;
+        LLMCore::Provider *provider;
+    };
 
-    QUrl m_serverUrl;
-    QNetworkAccessManager *m_manager;
-    QMap<QString, QNetworkReply *> m_activeRequests;
-    QMap<QNetworkReply *, QString> m_accumulatedResponses;
+    LLMCore::ContextData prepareContext(
+        const QJsonObject &request, const Context::DocumentInfo &documentInfo);
+    QString endpoint(LLMCore::Provider *provider, LLMCore::TemplateType type, bool isLanguageSpecify);
+
+    const Settings::CodeCompletionSettings &m_completeSettings;
+    const Settings::GeneralSettings &m_generalSettings;
+    LLMCore::IPromptProvider *m_promptProvider = nullptr;
+    LLMCore::IProviderRegistry &m_providerRegistry;
+    Context::IDocumentReader &m_documentReader;
+    IRequestPerformanceLogger &m_performanceLogger;
+    QElapsedTimer m_completionTimer;
+    Context::ContextManager *m_contextManager;
+    QHash<QString, RequestContext> m_activeRequests;
 };
 
 } // namespace QodeAssist

LLMSuggestion.cpp

@@ -1,8 +1,13 @@
-/* 
- * Copyright (C) 2024 Petr Mironychev
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
  * QodeAssist is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -18,63 +23,178 @@
  */
 
 #include "LLMSuggestion.hpp"
+#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)
+QString mergeWithRightText(const QString &suggestion, const QString &rightText)
 {
-    int startPos = completion.range().start().toPositionInDocument(origin);
-    int endPos = completion.range().end().toPositionInDocument(origin);
+    if (suggestion.isEmpty() || rightText.isEmpty()) {
+        return suggestion;
+    }
 
-    startPos = qBound(0, startPos, origin->characterCount() - 1);
-    endPos = qBound(startPos, endPos, origin->characterCount() - 1);
+    int j = 0;
+    QString processed = rightText;
+    QSet<int> matchedPositions;
 
-    m_start = QTextCursor(origin);
-    m_start.setPosition(startPos);
-    m_start.setKeepPositionOnInsert(true);
+    for (int i = 0; i < suggestion.length() && j < processed.length(); ++i) {
+        if (suggestion[i] == processed[j]) {
+            matchedPositions.insert(j);
+            ++j;
+        }
+    }
 
-    QTextCursor cursor(origin);
+    if (matchedPositions.isEmpty()) {
+        return suggestion + rightText;
+    }
+
+    QList<int> positions = matchedPositions.values();
+    std::sort(positions.begin(), positions.end(), std::greater<int>());
+    for (int pos : positions) {
+        processed.remove(pos, 1);
+    }
+
+    return suggestion;
+}
+
+LLMSuggestion::LLMSuggestion(
+    const QList<Data> &suggestions, QTextDocument *sourceDocument, int currentCompletion)
+    : TextEditor::CyclicSuggestion(suggestions, sourceDocument, currentCompletion)
+{
+    const auto &data = suggestions[currentCompletion];
+
+    int startPos = data.range.begin.toPositionInDocument(sourceDocument);
+    int endPos = data.range.end.toPositionInDocument(sourceDocument);
+
+    startPos = qBound(0, startPos, sourceDocument->characterCount());
+    endPos = qBound(startPos, endPos, sourceDocument->characterCount());
+
+    QTextCursor cursor(sourceDocument);
     cursor.setPosition(startPos);
-    cursor.setPosition(endPos, QTextCursor::KeepAnchor);
-
     QTextBlock block = cursor.block();
     QString blockText = block.text();
 
-    int startPosInBlock = startPos - block.position();
-    int endPosInBlock = endPos - block.position();
+    int cursorPositionInBlock = cursor.positionInBlock();
 
-    blockText.replace(startPosInBlock, endPosInBlock - startPosInBlock, completion.text());
+    QString rightText = blockText.mid(cursorPositionInBlock);
 
-    document()->setPlainText(blockText);
-
-    setCurrentPosition(m_start.position());
-}
-
-bool LLMSuggestion::apply()
-{
-    QTextCursor cursor = m_completion.range().toSelection(m_start.document());
-    cursor.beginEditBlock();
-    cursor.removeSelectedText();
-    cursor.insertText(m_completion.text());
-    cursor.endEditBlock();
-    return true;
+    if (!data.text.contains('\n')) {
+        QString processedRightText = mergeWithRightText(data.text, rightText);
+        processedRightText = processedRightText.mid(data.text.length());
+        QString displayText = blockText.left(cursorPositionInBlock) + data.text
+                              + processedRightText;
+        replacementDocument()->setPlainText(displayText);
+    } else {
+        QString displayText = blockText.left(cursorPositionInBlock) + data.text;
+        replacementDocument()->setPlainText(displayText);
+    }
 }
 
 bool LLMSuggestion::applyWord(TextEditor::TextEditorWidget *widget)
 {
-    Q_UNUSED(widget)
-    return apply();
+    return applyPart(Word, widget);
 }
 
-void LLMSuggestion::reset()
+bool LLMSuggestion::applyLine(TextEditor::TextEditorWidget *widget)
 {
-    m_start.removeSelectedText();
+    return applyPart(Line, widget);
 }
 
-int LLMSuggestion::position()
+bool LLMSuggestion::applyPart(Part part, TextEditor::TextEditorWidget *widget)
 {
-    return m_start.position();
+    const Utils::Text::Range range = suggestions()[currentSuggestion()].range;
+    const QTextCursor cursor = range.begin.toTextCursor(sourceDocument());
+    QTextCursor currentCursor = widget->textCursor();
+    const QString text = suggestions()[currentSuggestion()].text;
+
+    const int startPos = currentCursor.positionInBlock() - cursor.positionInBlock()
+                         + (cursor.selectionEnd() - cursor.selectionStart());
+
+    int next = part == Word ? Utils::endOfNextWord(text, startPos) : text.indexOf('\n', startPos);
+
+    if (next == -1) {
+        if (part == Line) {
+            next = text.length();
+        } else {
+            return apply();
+        }
+    }
+
+    if (part == Line)
+        ++next;
+
+    QString subText = text.mid(startPos, next - startPos);
+
+    if (subText.isEmpty()) {
+        return false;
+    }
+
+    if (!subText.contains('\n')) {
+        currentCursor.insertText(subText);
+
+        const QString remainingText = text.mid(next);
+        if (!remainingText.isEmpty()) {
+            QTextCursor newCursor = widget->textCursor();
+            const Utils::Text::Position newStart = Utils::Text::Position::fromPositionInDocument(
+                newCursor.document(), newCursor.position());
+            const Utils::Text::Position
+                newEnd{newStart.line, newStart.column + int(remainingText.length())};
+            const Utils::Text::Range newRange{newStart, newEnd};
+            const QList<Data> newSuggestion{{newRange, newStart, remainingText}};
+            widget->insertSuggestion(
+                std::make_unique<LLMSuggestion>(newSuggestion, widget->document(), 0));
+        }
+    } else {
+        currentCursor.insertText(subText);
+
+        if (const int seperatorPos = subText.lastIndexOf('\n'); seperatorPos >= 0) {
+            const QString newCompletionText = text.mid(startPos + seperatorPos + 1);
+            if (!newCompletionText.isEmpty()) {
+                const Utils::Text::Position newStart{int(range.begin.line + subText.count('\n')), 0};
+                const Utils::Text::Position newEnd{newStart.line, int(newCompletionText.length())};
+                const Utils::Text::Range newRange{newStart, newEnd};
+                const QList<Data> newSuggestion{{newRange, newEnd, newCompletionText}};
+                widget->insertSuggestion(
+                    std::make_unique<LLMSuggestion>(newSuggestion, widget->document(), 0));
+            }
+        }
+    }
+
+    return false;
+}
+
+bool LLMSuggestion::apply()
+{
+    const Utils::Text::Range range = suggestions()[currentSuggestion()].range;
+    const QTextCursor cursor = range.begin.toTextCursor(sourceDocument());
+    const QString text = suggestions()[currentSuggestion()].text;
+
+    QTextBlock currentBlock = cursor.block();
+    QString textAfterCursor = currentBlock.text().mid(cursor.positionInBlock());
+
+    QTextCursor editCursor = cursor;
+
+    int firstLineEnd = text.indexOf('\n');
+    if (firstLineEnd != -1) {
+        QString firstLine = text.left(firstLineEnd);
+        QString restOfText = text.mid(firstLineEnd);
+
+        editCursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
+        editCursor.removeSelectedText();
+
+        QString mergedFirstLine = mergeWithRightText(firstLine, textAfterCursor);
+        editCursor.insertText(mergedFirstLine + restOfText);
+    } else {
+        editCursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
+        editCursor.removeSelectedText();
+
+        QString mergedText = mergeWithRightText(text, textAfterCursor);
+        editCursor.insertText(mergedText);
+    }
+
+    return true;
 }
 
 } // namespace QodeAssist

LLMSuggestion.hpp

@@ -1,8 +1,13 @@
-/* 
- * Copyright (C) 2024 Petr Mironychev
+/*
+ * Copyright (C) 2023 The Qt Company Ltd.
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
+ * The Qt Company portions:
+ * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
+ *
+ * Petr Mironychev portions:
  * QodeAssist is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -19,27 +24,22 @@
 
 #pragma once
 
-#include <texteditor/textdocumentlayout.h>
-
-#include "LSPCompletion.hpp"
+#include <texteditor/texteditor.h>
+#include <texteditor/textsuggestion.h>
 
 namespace QodeAssist {
 
-class LLMSuggestion final : public TextEditor::TextSuggestion
+class LLMSuggestion : public TextEditor::CyclicSuggestion
 {
 public:
-    LLMSuggestion(const Completion &completion, QTextDocument *origin);
+    enum Part { Word, Line };
 
-    bool apply() final;
-    bool applyWord(TextEditor::TextEditorWidget *widget) final;
-    void reset() final;
-    int position() final;
+    LLMSuggestion(
+        const QList<Data> &suggestions, QTextDocument *sourceDocument, int currentCompletion = 0);
 
-    const Completion &completion() const { return m_completion; }
-
-private:
-    Completion m_completion;
-    QTextCursor m_start;
+    bool applyWord(TextEditor::TextEditorWidget *widget) override;
+    bool applyLine(TextEditor::TextEditorWidget *widget) override;
+    bool applyPart(Part part, TextEditor::TextEditorWidget *widget);
+    bool apply() override;
 };
-
 } // namespace QodeAssist

LSPCompletion.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2023 The Qt Company Ltd.
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
@@ -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);
@@ -64,9 +68,10 @@ class GetCompletionParams : public LanguageServerProtocol::JsonObject
 public:
     static constexpr LanguageServerProtocol::Key docKey{"doc"};
 
-    GetCompletionParams(const LanguageServerProtocol::TextDocumentIdentifier &document,
-                        int version,
-                        const LanguageServerProtocol::Position &position)
+    GetCompletionParams(
+        const LanguageServerProtocol::TextDocumentIdentifier &document,
+        int version,
+        const LanguageServerProtocol::Position &position)
     {
         setTextDocument(document);
         setVersion(version);

QodeAssist.json.in

@@ -1,16 +1,14 @@
 {
+    "Id" : "qodeassist",
     "Name" : "QodeAssist",
-    "Version" : "0.0.4",
-    "CompatVersion" : "${IDE_VERSION_COMPAT}",
+    "Version" : "0.7.1",
+    "CompatVersion" : "${IDE_VERSION}",
     "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" : "https://github.com/Palm1r/QodeAssist",
     ${IDE_PLUGIN_DEPENDENCIES}
 }

QodeAssist.qrc

@@ -2,5 +2,13 @@
     <qresource prefix="/">
         <file>resources/images/qoderassist-icon@2x.png</file>
         <file>resources/images/qoderassist-icon.png</file>
+        <file>resources/images/repeat-last-instruct-icon@2x.png</file>
+        <file>resources/images/repeat-last-instruct-icon.png</file>
+        <file>resources/images/improve-current-code-icon@2x.png</file>
+        <file>resources/images/improve-current-code-icon.png</file>
+        <file>resources/images/suggest-new-icon.png</file>
+        <file>resources/images/suggest-new-icon@2x.png</file>
+        <file>resources/images/qode-assist-chat-icon.png</file>
+        <file>resources/images/qode-assist-chat-icon@2x.png</file>
     </qresource>
 </RCC>

QodeAssistClient.cpp

@@ -1,8 +1,8 @@
 /*
  * Copyright (C) 2023 The Qt Company Ltd.
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
- * This file is part of Qode Assist.
+ * This file is part of QodeAssist.
  *
  * The Qt Company portions:
  * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
@@ -24,14 +24,20 @@
 
 #include "QodeAssistClient.hpp"
 
+#include <QInputDialog>
 #include <QTimer>
 
+#include <coreplugin/icore.h>
 #include <languageclient/languageclientsettings.h>
 #include <projectexplorer/projectmanager.h>
 
 #include "LLMClientInterface.hpp"
 #include "LLMSuggestion.hpp"
-#include "QodeAssistSettings.hpp"
+#include "settings/CodeCompletionSettings.hpp"
+#include "settings/GeneralSettings.hpp"
+#include "settings/ProjectSettings.hpp"
+#include <context/ChangesManager.h>
+#include <logger/Logger.hpp>
 
 using namespace LanguageServerProtocol;
 using namespace TextEditor;
@@ -41,16 +47,20 @@ using namespace Core;
 
 namespace QodeAssist {
 
-QodeAssistClient::QodeAssistClient()
-    : LanguageClient::Client(new LLMClientInterface())
+QodeAssistClient::QodeAssistClient(LLMClientInterface *clientInterface)
+    : LanguageClient::Client(clientInterface)
+    , m_llmClient(clientInterface)
+    , m_recentCharCount(0)
 {
-    setName("Qode Assist");
+    setName("QodeAssist");
     LanguageClient::LanguageFilter filter;
     filter.mimeTypes = QStringList() << "*";
     setSupportedLanguage(filter);
 
     start();
     setupConnections();
+
+    m_typingTimer.start();
 }
 
 QodeAssistClient::~QodeAssistClient()
@@ -65,29 +75,70 @@ void QodeAssistClient::openDocument(TextEditor::TextDocument *document)
         return;
 
     Client::openDocument(document);
-    connect(document,
-            &TextDocument::contentsChangedWithPosition,
-            this,
-            [this, document](int position, int charsRemoved, int charsAdded) {
-                Q_UNUSED(charsRemoved)
-                if (!settings().enableAutoComplete())
-                    return;
+    connect(
+        document,
+        &TextDocument::contentsChangedWithPosition,
+        this,
+        [this, document](int position, int charsRemoved, int charsAdded) {
+            if (!Settings::codeCompletionSettings().autoCompletion())
+                return;
 
-                auto project = ProjectManager::projectForFile(document->filePath());
-                if (!isEnabled(project))
-                    return;
+            auto project = ProjectManager::projectForFile(document->filePath());
+            if (!isEnabled(project))
+                return;
 
-                auto textEditor = BaseTextEditor::currentTextEditor();
-                if (!textEditor || textEditor->document() != document)
-                    return;
-                TextEditorWidget *widget = textEditor->editorWidget();
-                if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
-                    return;
-                const int cursorPosition = widget->textCursor().position();
-                if (cursorPosition < position || cursorPosition > position + charsAdded)
-                    return;
+            auto textEditor = BaseTextEditor::currentTextEditor();
+            if (!textEditor || textEditor->document() != document)
+                return;
+
+            if (Settings::codeCompletionSettings().useProjectChangesCache())
+                Context::ChangesManager::instance()
+                    .addChange(document, position, charsRemoved, charsAdded);
+
+            TextEditorWidget *widget = textEditor->editorWidget();
+            if (widget->isReadOnly() || widget->multiTextCursor().hasMultipleCursors())
+                return;
+
+            const int cursorPosition = widget->textCursor().position();
+            if (cursorPosition < position || cursorPosition > position + charsAdded)
+                return;
+
+            if (charsRemoved > 0 || charsAdded <= 0) {
+                m_recentCharCount = 0;
+                m_typingTimer.restart();
+                return;
+            }
+
+            QTextCursor cursor = widget->textCursor();
+            cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor, 1);
+            QString lastChar = cursor.selectedText();
+
+            if (lastChar.isEmpty() || lastChar[0].isPunct()) {
+                m_recentCharCount = 0;
+                m_typingTimer.restart();
+                return;
+            }
+
+            m_recentCharCount += charsAdded;
+
+            if (m_typingTimer.elapsed()
+                > Settings::codeCompletionSettings().autoCompletionTypingInterval()) {
+                m_recentCharCount = charsAdded;
+                m_typingTimer.restart();
+            }
+
+            if (m_recentCharCount
+                > Settings::codeCompletionSettings().autoCompletionCharThreshold()) {
                 scheduleRequest(widget);
-            });
+            }
+        });
+
+    // auto editors = BaseTextEditor::textEditorsForDocument(document);
+    // connect(
+    //     editors.first()->editorWidget(),
+    //     &TextEditorWidget::selectionChanged,
+    //     this,
+    //     [this, editors]() { m_chatButtonHandler.showButton(editors.first()->editorWidget()); });
 }
 
 bool QodeAssistClient::canOpenProject(ProjectExplorer::Project *project)
@@ -102,14 +153,26 @@ void QodeAssistClient::requestCompletions(TextEditor::TextEditorWidget *editor)
     if (!isEnabled(project))
         return;
 
+    if (m_llmClient->contextManager()
+            ->ignoreManager()
+            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+        LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
+                        .arg(editor->textDocument()->filePath().toUrlishString()));
+        return;
+    }
+
     MultiTextCursor cursor = editor->multiTextCursor();
     if (cursor.hasMultipleCursors() || cursor.hasSelection() || editor->suggestionVisible())
         return;
 
     const FilePath filePath = editor->textDocument()->filePath();
-    GetCompletionRequest request{{TextDocumentIdentifier(hostPathToServerUri(filePath)),
-                                  documentVersion(filePath),
-                                  Position(cursor.mainCursor())}};
+    GetCompletionRequest request{
+        {TextDocumentIdentifier(hostPathToServerUri(filePath)),
+         documentVersion(filePath),
+         Position(cursor.mainCursor())}};
+    if (Settings::codeCompletionSettings().showProgressWidget()) {
+        m_progressHandler.showProgress(editor);
+    }
     request.setResponseCallback([this, editor = QPointer<TextEditorWidget>(editor)](
                                     const GetCompletionRequest::Response &response) {
         QTC_ASSERT(editor, return);
@@ -119,6 +182,35 @@ void QodeAssistClient::requestCompletions(TextEditor::TextEditorWidget *editor)
     sendMessage(request);
 }
 
+void QodeAssistClient::requestQuickRefactor(
+    TextEditor::TextEditorWidget *editor, const QString &instructions)
+{
+    auto project = ProjectManager::projectForFile(editor->textDocument()->filePath());
+
+    if (!isEnabled(project))
+        return;
+
+    if (m_llmClient->contextManager()
+            ->ignoreManager()
+            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+        LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
+                        .arg(editor->textDocument()->filePath().toUrlishString()));
+        return;
+    }
+
+    if (!m_refactorHandler) {
+        m_refactorHandler = new QuickRefactorHandler(this);
+        connect(
+            m_refactorHandler,
+            &QuickRefactorHandler::refactoringCompleted,
+            this,
+            &QodeAssistClient::handleRefactoringResult);
+    }
+
+    m_progressHandler.showProgress(editor);
+    m_refactorHandler->sendRefactorRequest(editor, instructions);
+}
+
 void QodeAssistClient::scheduleRequest(TextEditor::TextEditorWidget *editor)
 {
     cancelRunningRequest(editor);
@@ -130,7 +222,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,11 +238,10 @@ 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)
+void QodeAssistClient::handleCompletions(
+    const GetCompletionRequest::Response &response, TextEditor::TextEditorWidget *editor)
 {
     if (response.error())
         log(*response.error());
@@ -168,8 +261,8 @@ void QodeAssistClient::handleCompletions(const GetCompletionRequest::Response &r
         auto isValidCompletion = [](const Completion &completion) {
             return completion.isValid() && !completion.text().trimmed().isEmpty();
         };
-        QList<Completion> completions = Utils::filtered(result->completions().toListOrEmpty(),
-                                                        isValidCompletion);
+        QList<Completion> completions
+            = Utils::filtered(result->completions().toListOrEmpty(), isValidCompletion);
 
         // remove trailing whitespaces from the end of the completions
         for (Completion &completion : completions) {
@@ -186,11 +279,19 @@ void QodeAssistClient::handleCompletions(const GetCompletionRequest::Response &r
             if (delta > 0)
                 completion.setText(completionText.chopped(delta));
         }
+        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()};
+        });
+        m_progressHandler.hideProgress();
         if (completions.isEmpty())
             return;
-        editor->insertSuggestion(
-            std::make_unique<LLMSuggestion>(completions.first(), editor->document()));
-        editor->addHoverHandler(&m_hoverHandler);
+        editor->insertSuggestion(std::make_unique<LLMSuggestion>(suggestions, editor->document()));
     }
 }
 
@@ -199,13 +300,18 @@ void QodeAssistClient::cancelRunningRequest(TextEditor::TextEditorWidget *editor
     const auto it = m_runningRequests.constFind(editor);
     if (it == m_runningRequests.constEnd())
         return;
+    m_progressHandler.hideProgress();
     cancelRequest(it->id());
     m_runningRequests.erase(it);
 }
 
 bool QodeAssistClient::isEnabled(ProjectExplorer::Project *project) const
 {
-    return settings().enableQodeAssist();
+    if (!project)
+        return Settings::generalSettings().enableQodeAssist();
+
+    Settings::ProjectSettings settings(project);
+    return settings.isEnabled();
 }
 
 void QodeAssistClient::setupConnections()
@@ -215,18 +321,13 @@ void QodeAssistClient::setupConnections()
             openDocument(textDocument);
     };
 
-    m_documentOpenedConnection = connect(EditorManager::instance(),
-                                         &EditorManager::documentOpened,
-                                         this,
-                                         openDoc);
-    m_documentClosedConnection = connect(EditorManager::instance(),
-                                         &EditorManager::documentClosed,
-                                         this,
-                                         [this](IDocument *document) {
-                                             if (auto textDocument = qobject_cast<TextDocument *>(
-                                                     document))
-                                                 closeDocument(textDocument);
-                                         });
+    m_documentOpenedConnection
+        = connect(EditorManager::instance(), &EditorManager::documentOpened, this, openDoc);
+    m_documentClosedConnection = connect(
+        EditorManager::instance(), &EditorManager::documentClosed, this, [this](IDocument *document) {
+            if (auto textDocument = qobject_cast<TextDocument *>(document))
+                closeDocument(textDocument);
+        });
 
     for (IDocument *doc : DocumentModel::openedDocuments())
         openDoc(doc);
@@ -237,13 +338,36 @@ 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();
 }
 
+void QodeAssistClient::handleRefactoringResult(const RefactorResult &result)
+{
+    if (!result.success) {
+        LOG_MESSAGE(QString("Refactoring failed: %1").arg(result.errorMessage));
+        return;
+    }
+
+    auto editor = BaseTextEditor::currentTextEditor();
+    if (!editor) {
+        LOG_MESSAGE("Refactoring failed: No active editor found");
+        return;
+    }
+
+    auto editorWidget = editor->editorWidget();
+
+    QTextCursor cursor = editorWidget->textCursor();
+    cursor.beginEditBlock();
+
+    int startPos = result.insertRange.begin.toPositionInDocument(editorWidget->document());
+    int endPos = result.insertRange.end.toPositionInDocument(editorWidget->document());
+
+    cursor.setPosition(startPos);
+    cursor.setPosition(endPos, QTextCursor::KeepAnchor);
+
+    cursor.insertText(result.newText);
+    cursor.endEditBlock();
+    m_progressHandler.hideProgress();
+}
 } // namespace QodeAssist

QodeAssistClient.hpp

@@ -1,8 +1,8 @@
 /*
  * Copyright (C) 2023 The Qt Company Ltd.
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
- * This file is part of Qode Assist.
+ * This file is part of QodeAssist.
  *
  * The Qt Company portions:
  * SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
@@ -24,39 +24,55 @@
 
 #pragma once
 
-#include <languageclient/client.h>
+#include <QObject>
 
+#include "LLMClientInterface.hpp"
 #include "LSPCompletion.hpp"
-#include "QodeAssistHoverHandler.hpp"
+#include "QuickRefactorHandler.hpp"
+#include "widgets/CompletionProgressHandler.hpp"
+#include "widgets/EditorChatButtonHandler.hpp"
+#include <languageclient/client.h>
+#include <llmcore/IPromptProvider.hpp>
+#include <llmcore/IProviderRegistry.hpp>
 
 namespace QodeAssist {
 
 class QodeAssistClient : public LanguageClient::Client
 {
+    Q_OBJECT
 public:
-    explicit QodeAssistClient();
+    explicit QodeAssistClient(LLMClientInterface *clientInterface);
     ~QodeAssistClient() override;
 
     void openDocument(TextEditor::TextDocument *document) override;
     bool canOpenProject(ProjectExplorer::Project *project) override;
 
     void requestCompletions(TextEditor::TextEditorWidget *editor);
+    void requestQuickRefactor(
+        TextEditor::TextEditorWidget *editor, const QString &instructions = QString());
 
 private:
     void scheduleRequest(TextEditor::TextEditorWidget *editor);
-    void handleCompletions(const GetCompletionRequest::Response &response,
-                           TextEditor::TextEditorWidget *editor);
+    void handleCompletions(
+        const GetCompletionRequest::Response &response, TextEditor::TextEditorWidget *editor);
     void cancelRunningRequest(TextEditor::TextEditorWidget *editor);
     bool isEnabled(ProjectExplorer::Project *project) const;
 
     void setupConnections();
     void cleanupConnections();
+    void handleRefactoringResult(const RefactorResult &result);
 
     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;
+    CompletionProgressHandler m_progressHandler;
+    EditorChatButtonHandler m_chatButtonHandler;
+    QuickRefactorHandler *m_refactorHandler{nullptr};
+    LLMClientInterface *m_llmClient;
 };
 
 } // namespace QodeAssist

QodeAssistConstants.hpp

@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *
@@ -24,41 +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 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

QodeAssistSettings.cpp

@@ -1,392 +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, 10.0);
-
-    useTopK.setSettingsKey(Constants::USE_TOP_K);
-    useTopK.setDefaultValue(false);
-
-    topK.setSettingsKey(Constants::TOP_K);
-    topK.setLabelText(Tr::tr("top_k"));
-    topK.setDefaultValue(0.1);
-    topK.setRange(0, 10.0);
-
-    usePresencePenalty.setSettingsKey(Constants::USE_PRESENCE_PENALTY);
-    usePresencePenalty.setDefaultValue(false);
-
-    presencePenalty.setSettingsKey(Constants::PRESENCE_PENALTY);
-    presencePenalty.setLabelText(Tr::tr("presence_penalty"));
-    presencePenalty.setDefaultValue(0.0);
-    presencePenalty.setRange(-2.0, 2.0);
-
-    useFrequencyPenalty.setSettingsKey(Constants::USE_FREQUENCY_PENALTY);
-    useFrequencyPenalty.setDefaultValue(false);
-
-    frequencyPenalty.setSettingsKey(Constants::FREQUENCY_PENALTY);
-    frequencyPenalty.setLabelText(Tr::tr("frequency_penalty"));
-    frequencyPenalty.setDefaultValue(0.0);
-    frequencyPenalty.setRange(-2.0, 2.0);
-
-    providerPaths.setSettingsKey(Constants::PROVIDER_PATHS);
-    providerPaths.setLabelText(Tr::tr("Provider Paths:"));
-
-    startSuggestionTimer.setSettingsKey(Constants::START_SUGGESTION_TIMER);
-    startSuggestionTimer.setLabelText(Tr::tr("Start Suggestion Timer:"));
-    startSuggestionTimer.setRange(10, 10000);
-    startSuggestionTimer.setDefaultValue(500);
-
-    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"));
-
-    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,
-                                        maxFileThreshold,
-                                        ollamaLivetime,
-                                        specificInstractions,
-                                        temperature,
-                                        maxTokens,
-                                        readFullFile,
-                                        readStringsBeforeCursor,
-                                        readStringsAfterCursor,
-                                        startSuggestionTimer,
-                                        Row{useTopP, topP, Stretch{1}},
-                                        Row{useTopK, topK, Stretch{1}},
-                                        Row{usePresencePenalty, presencePenalty, Stretch{1}},
-                                        Row{useFrequencyPenalty, frequencyPenalty, Stretch{1}}}}},
-                      st};
-    });
-
-    setupConnections();
-}
-
-void QodeAssistSettings::setupConnections()
-{
-    connect(&llmProviders, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
-        int index = llmProviders.volatileValue();
-        logMessage(QString("currentProvider %1").arg(llmProviders.displayForIndex(index)));
-        LLMProvidersManager::instance().setCurrentProvider(llmProviders.displayForIndex(index));
-        updateProviderSettings();
-    });
-
-    connect(&fimPrompts, &Utils::SelectionAspect::volatileValueChanged, this, [this]() {
-        int index = fimPrompts.volatileValue();
-        logMessage(QString("currentPrompt %1").arg(fimPrompts.displayForIndex(index)));
-        PromptTemplateManager::instance().setCurrentTemplate(fimPrompts.displayForIndex(index));
-    });
-
-    connect(&selectModels, &ButtonAspect::clicked, this, [this]() { showModelSelectionDialog(); });
-    connect(&useTopP, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        topP.setEnabled(useTopP.volatileValue());
-    });
-    connect(&useTopK, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        topK.setEnabled(useTopK.volatileValue());
-    });
-    connect(&usePresencePenalty, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        presencePenalty.setEnabled(usePresencePenalty.volatileValue());
-    });
-    connect(&useFrequencyPenalty, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        frequencyPenalty.setEnabled(useFrequencyPenalty.volatileValue());
-    });
-    connect(&readFullFile, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        readStringsAfterCursor.setEnabled(!readFullFile.volatileValue());
-        readStringsBeforeCursor.setEnabled(!readFullFile.volatileValue());
-    });
-    connect(&resetToDefaults,
-            &ButtonAspect::clicked,
-            this,
-            &QodeAssistSettings::resetSettingsToDefaults);
-    connect(&enableLogging, &Utils::BoolAspect::volatileValueChanged, this, [this]() {
-        setLoggingEnabled(enableLogging.volatileValue());
-    });
-}
-
-void QodeAssistSettings::updateProviderSettings()
-{
-    auto *provider = LLMProvidersManager::instance().getCurrentProvider();
-
-    if (provider) {
-        logMessage(QString("currentProvider %1").arg(provider->name()));
-        url.setValue(provider->url());
-        port.setValue(provider->defaultPort());
-        endPoint.setValue(provider->completionEndpoint());
-        ollamaLivetime.setEnabled(provider->name() == "Ollama");
-    }
-}
-
-QStringList QodeAssistSettings::getInstalledModels()
-{
-    auto *provider = LLMProvidersManager::instance().getCurrentProvider();
-    if (provider) {
-        auto env = getEnvironmentWithProviderPaths();
-        return provider->getInstalledModels(env);
-    }
-    return {};
-}
-
-void QodeAssistSettings::showModelSelectionDialog()
-{
-    QStringList models = getInstalledModels();
-
-    bool ok;
-    QString selectedModel = QInputDialog::getItem(Core::ICore::dialogParent(),
-                                                  Tr::tr("Select LLM Model"),
-                                                  Tr::tr("Choose a model:"),
-                                                  models,
-                                                  0,
-                                                  false,
-                                                  &ok);
-
-    if (ok && !selectedModel.isEmpty()) {
-        modelName.setValue(selectedModel);
-        writeSettings();
-    }
-}
-
-Utils::Environment QodeAssistSettings::getEnvironmentWithProviderPaths() const
-{
-    Utils::Environment env = Utils::Environment::systemEnvironment();
-    const QStringList additionalPaths = providerPaths.volatileValue();
-    for (const QString &path : additionalPaths) {
-        env.prependOrSetPath(path);
-    }
-    return env;
-}
-
-void QodeAssistSettings::resetSettingsToDefaults()
-{
-    QMessageBox::StandardButton reply;
-    reply = QMessageBox::question(
-        Core::ICore::dialogParent(),
-        Tr::tr("Reset Settings"),
-        Tr::tr("Are you sure you want to reset all settings to default values?"),
-        QMessageBox::Yes | QMessageBox::No);
-
-    if (reply == QMessageBox::Yes) {
-        resetAspect(enableQodeAssist);
-        resetAspect(enableAutoComplete);
-        resetAspect(llmProviders);
-        resetAspect(url);
-        resetAspect(port);
-        resetAspect(endPoint);
-        resetAspect(modelName);
-        resetAspect(fimPrompts);
-        resetAspect(temperature);
-        resetAspect(maxTokens);
-        resetAspect(readFullFile);
-        resetAspect(maxFileThreshold);
-        resetAspect(readStringsBeforeCursor);
-        resetAspect(readStringsAfterCursor);
-        resetAspect(useTopP);
-        resetAspect(topP);
-        resetAspect(useTopK);
-        resetAspect(topK);
-        resetAspect(usePresencePenalty);
-        resetAspect(presencePenalty);
-        resetAspect(useFrequencyPenalty);
-        resetAspect(frequencyPenalty);
-        resetAspect(startSuggestionTimer);
-        resetAspect(enableLogging);
-        resetAspect(ollamaLivetime);
-        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

QodeAssistSettings.hpp

@@ -1,114 +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 <QPushButton>
-#include <utils/aspects.h>
-#include <utils/layoutbuilder.h>
-
-namespace QodeAssist {
-
-template<typename AspectType>
-void resetAspect(AspectType &aspect)
-{
-    aspect.setValue(aspect.defaultValue());
-}
-
-class ButtonAspect : public Utils::BaseAspect
-{
-    Q_OBJECT
-
-public:
-    ButtonAspect(Utils::AspectContainer *container = nullptr)
-        : Utils::BaseAspect(container)
-    {}
-
-    void addToLayout(Layouting::Layout &parent) override
-    {
-        auto button = new QPushButton(m_buttonText);
-        connect(button, &QPushButton::clicked, this, &ButtonAspect::clicked);
-        parent.addItem(button);
-    }
-
-    QString m_buttonText;
-signals:
-    void clicked();
-};
-
-class QodeAssistSettings : public Utils::AspectContainer
-{
-public:
-    QodeAssistSettings();
-
-    Utils::BoolAspect enableQodeAssist{this};
-    Utils::BoolAspect enableAutoComplete{this};
-    Utils::BoolAspect enableLogging{this};
-
-    Utils::SelectionAspect llmProviders{this};
-    Utils::StringAspect url{this};
-    Utils::IntegerAspect port{this};
-    Utils::StringAspect endPoint{this};
-
-    Utils::StringAspect modelName{this};
-    ButtonAspect selectModels{this};
-
-    Utils::SelectionAspect fimPrompts{this};
-    Utils::DoubleAspect temperature{this};
-    Utils::IntegerAspect maxTokens{this};
-
-    Utils::BoolAspect readFullFile{this};
-    Utils::IntegerAspect readStringsBeforeCursor{this};
-    Utils::IntegerAspect readStringsAfterCursor{this};
-
-    Utils::BoolAspect useTopP{this};
-    Utils::DoubleAspect topP{this};
-
-    Utils::BoolAspect useTopK{this};
-    Utils::DoubleAspect topK{this};
-
-    Utils::BoolAspect usePresencePenalty{this};
-    Utils::DoubleAspect presencePenalty{this};
-
-    Utils::BoolAspect useFrequencyPenalty{this};
-    Utils::DoubleAspect frequencyPenalty{this};
-
-    Utils::StringListAspect providerPaths{this};
-
-    Utils::IntegerAspect startSuggestionTimer{this};
-    Utils::IntegerAspect maxFileThreshold{this};
-
-    Utils::StringAspect ollamaLivetime{this};
-    Utils::StringAspect specificInstractions{this};
-    Utils::BoolAspect multiLineCompletion{this};
-
-    ButtonAspect resetToDefaults{this};
-
-private:
-    void setupConnections();
-    void updateProviderSettings();
-    QStringList getInstalledModels();
-    void showModelSelectionDialog();
-    Utils::Environment getEnvironmentWithProviderPaths() const;
-    void resetSettingsToDefaults();
-};
-
-QodeAssistSettings &settings();
-
-} // 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

QodeAssist_en_001.ts

@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE TS>
-<TS version="2.1" language="en_001"></TS>

QodeAssisttr.h

@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2024 Petr Mironychev
+ * Copyright (C) 2024-2025 Petr Mironychev
  *
  * This file is part of QodeAssist.
  *

QuickRefactorHandler.cpp

@@ -0,0 +1,331 @@
+/*
+ * Copyright (C) 2025 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 "QuickRefactorHandler.hpp"
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QUuid>
+
+#include <context/DocumentContextReader.hpp>
+#include <context/DocumentReaderQtCreator.hpp>
+#include <context/Utils.hpp>
+#include <llmcore/PromptTemplateManager.hpp>
+#include <llmcore/ProvidersManager.hpp>
+#include <llmcore/RequestConfig.hpp>
+#include <llmcore/RulesLoader.hpp>
+#include <logger/Logger.hpp>
+#include <settings/ChatAssistantSettings.hpp>
+#include <settings/GeneralSettings.hpp>
+
+namespace QodeAssist {
+
+QuickRefactorHandler::QuickRefactorHandler(QObject *parent)
+    : QObject(parent)
+    , m_currentEditor(nullptr)
+    , m_isRefactoringInProgress(false)
+    , m_contextManager(this)
+{
+}
+
+QuickRefactorHandler::~QuickRefactorHandler() {}
+
+void QuickRefactorHandler::sendRefactorRequest(
+    TextEditor::TextEditorWidget *editor, const QString &instructions)
+{
+    if (m_isRefactoringInProgress) {
+        cancelRequest();
+    }
+
+    m_currentEditor = editor;
+
+    Utils::Text::Range range;
+    if (editor->textCursor().hasSelection()) {
+        QTextCursor cursor = editor->textCursor();
+        int startPos = cursor.selectionStart();
+        int endPos = cursor.selectionEnd();
+
+        QTextBlock startBlock = editor->document()->findBlock(startPos);
+        int startLine = startBlock.blockNumber() + 1;
+        int startColumn = startPos - startBlock.position();
+
+        QTextBlock endBlock = editor->document()->findBlock(endPos);
+        int endLine = endBlock.blockNumber() + 1;
+        int endColumn = endPos - endBlock.position();
+
+        Utils::Text::Position startPosition;
+        startPosition.line = startLine;
+        startPosition.column = startColumn;
+
+        Utils::Text::Position endPosition;
+        endPosition.line = endLine;
+        endPosition.column = endColumn;
+
+        range = Utils::Text::Range();
+        range.begin = startPosition;
+        range.end = endPosition;
+    } else {
+        QTextCursor cursor = editor->textCursor();
+        int cursorPos = cursor.position();
+
+        QTextBlock block = editor->document()->findBlock(cursorPos);
+        int line = block.blockNumber() + 1;
+        int column = cursorPos - block.position();
+
+        Utils::Text::Position cursorPosition;
+        cursorPosition.line = line;
+        cursorPosition.column = column;
+        range = Utils::Text::Range();
+        range.begin = cursorPosition;
+        range.end = cursorPosition;
+    }
+
+    m_currentRange = range;
+    prepareAndSendRequest(editor, instructions, range);
+}
+
+void QuickRefactorHandler::prepareAndSendRequest(
+    TextEditor::TextEditorWidget *editor,
+    const QString &instructions,
+    const Utils::Text::Range &range)
+{
+    auto &settings = Settings::generalSettings();
+
+    auto &providerRegistry = LLMCore::ProvidersManager::instance();
+    auto &promptManager = LLMCore::PromptTemplateManager::instance();
+
+    const auto providerName = settings.caProvider();
+    auto provider = providerRegistry.getProviderByName(providerName);
+
+    if (!provider) {
+        LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
+        RefactorResult result;
+        result.success = false;
+        result.errorMessage = QString("No provider found with name: %1").arg(providerName);
+        emit refactoringCompleted(result);
+        return;
+    }
+
+    const auto templateName = settings.caTemplate();
+    auto promptTemplate = promptManager.getChatTemplateByName(templateName);
+
+    if (!promptTemplate) {
+        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+        RefactorResult result;
+        result.success = false;
+        result.errorMessage = QString("No template found with name: %1").arg(templateName);
+        emit refactoringCompleted(result);
+        return;
+    }
+
+    LLMCore::LLMConfig config;
+    config.requestType = LLMCore::RequestType::Chat;
+    config.provider = provider;
+    config.promptTemplate = promptTemplate;
+    config.url = QString("%1%2").arg(settings.caUrl(), provider->chatEndpoint());
+    config.providerRequest = {{"model", settings.caModel()}, {"stream", true}};
+    config.apiKey = provider->apiKey();
+
+    LLMCore::ContextData context = prepareContext(editor, range, instructions);
+
+    provider
+        ->prepareRequest(config.providerRequest, promptTemplate, context, LLMCore::RequestType::Chat);
+
+    QString requestId = QUuid::createUuid().toString();
+    m_lastRequestId = requestId;
+    QJsonObject request{{"id", requestId}};
+
+    m_isRefactoringInProgress = true;
+
+    m_activeRequests[requestId] = {request, provider};
+
+    connect(
+        provider,
+        &LLMCore::Provider::fullResponseReceived,
+        this,
+        &QuickRefactorHandler::handleFullResponse,
+        Qt::UniqueConnection);
+
+    connect(
+        provider,
+        &LLMCore::Provider::requestFailed,
+        this,
+        &QuickRefactorHandler::handleRequestFailed,
+        Qt::UniqueConnection);
+
+    provider->sendRequest(requestId, config.url, config.providerRequest);
+}
+
+LLMCore::ContextData QuickRefactorHandler::prepareContext(
+    TextEditor::TextEditorWidget *editor,
+    const Utils::Text::Range &range,
+    const QString &instructions)
+{
+    LLMCore::ContextData context;
+
+    auto textDocument = editor->textDocument();
+    Context::DocumentReaderQtCreator documentReader;
+    auto documentInfo = documentReader.readDocument(textDocument->filePath().toUrlishString());
+
+    if (!documentInfo.document) {
+        LOG_MESSAGE("Error: Document is not available");
+        return context;
+    }
+
+    QTextCursor cursor = editor->textCursor();
+    int cursorPos = cursor.position();
+
+    // TODO add selecting content before and after cursor/selection
+    QString fullContent = documentInfo.document->toPlainText();
+    QString taggedContent = fullContent;
+
+    if (cursor.hasSelection()) {
+        int selEnd = cursor.selectionEnd();
+        int selStart = cursor.selectionStart();
+        taggedContent
+            .insert(selEnd, selEnd == cursorPos ? "<selection_end><cursor>" : "<selection_end>");
+        taggedContent.insert(
+            selStart, selStart == cursorPos ? "<cursor><selection_start>" : "<selection_start>");
+    } else {
+        taggedContent.insert(cursorPos, "<cursor>");
+    }
+
+    QString systemPrompt = Settings::codeCompletionSettings().quickRefactorSystemPrompt();
+
+    auto project = LLMCore::RulesLoader::getActiveProject();
+    if (project) {
+        QString projectRules = LLMCore::RulesLoader::loadRulesForProject(
+            project, LLMCore::RulesContext::QuickRefactor);
+
+        if (!projectRules.isEmpty()) {
+            systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
+            LOG_MESSAGE("Loaded project rules for quick refactor");
+        }
+    }
+
+    systemPrompt += "\n\nFile information:";
+    systemPrompt += "\nLanguage: " + documentInfo.mimeType;
+    systemPrompt += "\nFile path: " + documentInfo.filePath;
+
+    systemPrompt += "\n\nCode context with position markers:";
+    systemPrompt += taggedContent;
+
+    systemPrompt += "\n\nOutput format:";
+    systemPrompt += "\n- Generate ONLY the code that should replace the current selection "
+                    "between<selection_start><selection_end> or be "
+                    "inserted at cursor position<cursor>";
+    systemPrompt += "\n- Do not include any explanations, comments about the code, or markdown "
+                    "code block markers";
+    systemPrompt += "\n- The output should be ready to insert directly into the editor";
+    systemPrompt += "\n- Follow the existing code style and indentation patterns";
+
+    if (Settings::codeCompletionSettings().useOpenFilesInQuickRefactor()) {
+        systemPrompt += "\n\n" + m_contextManager.openedFilesContext({documentInfo.filePath});
+    }
+
+    context.systemPrompt = systemPrompt;
+
+    QVector<LLMCore::Message> messages;
+    messages.append(
+        {"user",
+         instructions.isEmpty() ? "Refactor the code to improve its quality and maintainability."
+                                : instructions});
+    context.history = messages;
+
+    return context;
+}
+
+void QuickRefactorHandler::handleLLMResponse(
+    const QString &response, const QJsonObject &request, bool isComplete)
+{
+    if (request["id"].toString() != m_lastRequestId) {
+        return;
+    }
+
+    if (isComplete) {
+        QString cleanedResponse = response.trimmed();
+        if (cleanedResponse.startsWith("```")) {
+            int firstNewLine = cleanedResponse.indexOf('\n');
+            int lastFence = cleanedResponse.lastIndexOf("```");
+
+            if (firstNewLine != -1 && lastFence > firstNewLine) {
+                cleanedResponse
+                    = cleanedResponse.mid(firstNewLine + 1, lastFence - firstNewLine - 1).trimmed();
+            } else if (lastFence != -1) {
+                cleanedResponse = cleanedResponse.mid(3, lastFence - 3).trimmed();
+            }
+        }
+
+        RefactorResult result;
+        result.newText = cleanedResponse;
+        result.insertRange = m_currentRange;
+        result.success = true;
+
+        LOG_MESSAGE("Refactoring completed successfully. New code to insert: ");
+        LOG_MESSAGE("---------- BEGIN REFACTORED CODE ----------");
+        LOG_MESSAGE(cleanedResponse);
+        LOG_MESSAGE("----------- END REFACTORED CODE -----------");
+
+        emit refactoringCompleted(result);
+    }
+}
+
+void QuickRefactorHandler::cancelRequest()
+{
+    if (m_isRefactoringInProgress) {
+        auto id = m_lastRequestId;
+
+        for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
+            if (it.key() == id) {
+                const RequestContext &ctx = it.value();
+                ctx.provider->cancelRequest(id);
+                m_activeRequests.erase(it);
+                break;
+            }
+        }
+
+        m_isRefactoringInProgress = false;
+
+        RefactorResult result;
+        result.success = false;
+        result.errorMessage = "Refactoring request was cancelled";
+        emit refactoringCompleted(result);
+    }
+}
+
+void QuickRefactorHandler::handleFullResponse(const QString &requestId, const QString &fullText)
+{
+    if (requestId == m_lastRequestId) {
+        QJsonObject request{{"id", requestId}};
+        handleLLMResponse(fullText, request, true);
+    }
+}
+
+void QuickRefactorHandler::handleRequestFailed(const QString &requestId, const QString &error)
+{
+    if (requestId == m_lastRequestId) {
+        m_isRefactoringInProgress = false;
+        RefactorResult result;
+        result.success = false;
+        result.errorMessage = error;
+        emit refactoringCompleted(result);
+    }
+}
+
+} // namespace QodeAssist

QuickRefactorHandler.hpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2025 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 <QObject>
+
+#include <texteditor/texteditor.h>
+#include <utils/textutils.h>
+
+#include <context/ContextManager.hpp>
+#include <context/IDocumentReader.hpp>
+#include <llmcore/ContextData.hpp>
+#include <llmcore/Provider.hpp>
+
+namespace QodeAssist {
+
+struct RefactorResult
+{
+    QString newText;
+    Utils::Text::Range insertRange;
+    bool success;
+    QString errorMessage;
+};
+
+class QuickRefactorHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit QuickRefactorHandler(QObject *parent = nullptr);
+    ~QuickRefactorHandler() override;
+
+    void sendRefactorRequest(TextEditor::TextEditorWidget *editor, const QString &instructions);
+
+    void cancelRequest();
+
+signals:
+    void refactoringCompleted(const QodeAssist::RefactorResult &result);
+
+private slots:
+    void handleFullResponse(const QString &requestId, const QString &fullText);
+    void handleRequestFailed(const QString &requestId, const QString &error);
+
+private:
+    void prepareAndSendRequest(
+        TextEditor::TextEditorWidget *editor,
+        const QString &instructions,
+        const Utils::Text::Range &range);
+
+    void handleLLMResponse(const QString &response, const QJsonObject &request, bool isComplete);
+    LLMCore::ContextData prepareContext(
+        TextEditor::TextEditorWidget *editor,
+        const Utils::Text::Range &range,
+        const QString &instructions);
+
+    struct RequestContext
+    {
+        QJsonObject originalRequest;
+        LLMCore::Provider *provider;
+    };
+
+    QHash<QString, RequestContext> m_activeRequests;
+    TextEditor::TextEditorWidget *m_currentEditor;
+    Utils::Text::Range m_currentRange;
+    bool m_isRefactoringInProgress;
+    QString m_lastRequestId;
+    Context::ContextManager m_contextManager;
+};
+
+} // namespace QodeAssist

README.md

@@ -1,61 +1,387 @@
-# QodeAssist
+# QodeAssist - AI-powered coding assistant plugin for Qt Creator
 [![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-16.0.2-brightgreen)
+![Static Badge](https://img.shields.io/badge/QtCreator-17.0.1-brightgreen)
+[![](https://dcbadge.limes.pink/api/server/BGMkUsXUgf?style=flat)](https://discord.gg/BGMkUsXUgf)
 
-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)
+⚠️ **Important Notice About Paid Providers**
+> When using paid providers like Claude, OpenRouter or OpenAI-compatible services:
+> - These services will consume API tokens which may result in charges to your account
+> - The QodeAssist developer bears no responsibility for any charges incurred
+> - Please carefully review the provider's pricing and your account settings before use
 
-## Supported Models
-QodeAssist has been tested with the following language models:
+## Table of Contents
+1. [Overview](#overview)
+2. [Install plugin to QtCreator](#install-plugin-to-qtcreator)
+3. [Configure for Anthropic Claude](#configure-for-anthropic-claude)
+4. [Configure for OpenAI](#configure-for-openai)
+5. [Configure for Mistral AI](#configure-for-mistral-ai)
+6. [Configure for Google AI](#configure-for-google-ai)
+7. [Configure for Ollama](#configure-for-ollama)
+8. [Configure for llama.cpp](#configure-for-llamacpp)
+9. [System Prompt Configuration](#system-prompt-configuration)
+10. [File Context Feature](#file-context-feature)
+11. [Quick Refactoring Feature](#quick-refactoring-feature)
+12. [QtCreator Version Compatibility](#qtcreator-version-compatibility)
+13. [Development Progress](#development-progress)
+14. [Hotkeys](#hotkeys)
+15. [Ignoring Files](#ignoring-files)
+14. [Troubleshooting](#troubleshooting)
+15. [Support the Development](#support-the-development-of-qodeassist)
+16. [How to Build](#how-to-build)
 
-Ollama:
-- [starcoder2](https://ollama.com/library/starcoder2)
-- [codellama](https://ollama.com/library/codellama)
+## Overview
 
-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)
+- AI-powered code completion
+  - Sharing IDE opened files with model context (disabled by default, need enable in settings)
+  - Quick refactor code via fast chat command and opened files
+- Chat functionality:
+  - Side and Bottom panels(enabling in chat settings due stability reason with QQuickWidget problem)
+  - Chat in additional popup window with pinning(recommended)
+  - Chat history autosave and restore
+  - Token usage monitoring and management
+  - Attach files for one-time code analysis
+  - Link files for persistent context with auto update in conversations
+  - Automatic syncing with open editor files (optional)
+- Support for multiple LLM providers:
+  - Ollama
+  - llama.cpp
+  - OpenAI
+  - Anthropic Claude
+  - LM Studio
+  - Mistral AI
+  - Google AI
+  - OpenAI-compatible providers (eg. llama.cpp, https://openrouter.ai)
+- Extensive library of model-specific templates
+- Easy configuration and model selection
+- Support tools/function calling (enabled by default)
 
-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.
+Join our Discord Community: Have questions or want to discuss QodeAssist? Join our [Discord server](https://discord.gg/BGMkUsXUgf) to connect with other users and get support!
+
+<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>
+
+<details>
+  <summary>Quick refactor in code: (click to expand)</summary>
+  <img src="https://github.com/user-attachments/assets/4a9092e0-429f-41eb-8723-cbb202fd0a8c" width="600" alt="QodeAssistPreview">
+</details>
+
+<details>
+  <summary>Multiline Code completion: (click to expand)</summary>
+  <img src="https://github.com/user-attachments/assets/c18dfbd2-8c54-4a7b-90d1-66e3bb51adb0" width="600" alt="QodeAssistPreview">
+</details>
+
+<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>
+
+<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>
+
+<details>
+  <summary>Chat in addtional window: (click to expand)</summary>
+  <img width="851" height="865" alt="image" src="https://github.com/user-attachments/assets/a68894b7-886e-4501-a61b-7161ae34b427" />
+</details>
+
+<details>
+  <summary>Automatic syncing with open editor files: (click to expand)</summary>
+  <img width="600" alt="OpenedDocumentsSync" src="https://github.com/user-attachments/assets/08efda2f-dc4d-44c3-927c-e6a975090d2f">
+</details>
+
+<details>
+  <summary>Example how tools works: (click to expand)</summary>
+  <img width="600" alt="ToolsDemo" src="https://github.com/user-attachments/assets/cf6273ad-d5c8-47fc-81e6-23d929547f6c">
+</details>
+
+## Install plugin to QtCreator
+1. Install Latest Qt Creator
+2. Download the QodeAssist plugin for your Qt Creator
+   - Remove old version plugin if already was installed
+      - on macOS for QtCreator 16: ~/Library/Application Support/QtProject/Qt Creator/plugins/16.0.0/petrmironychev.qodeassist
+      - on windows for QtCreator 16: C:\Users\<user>\AppData\Local\QtProject\qtcreator\plugins\16.0.0\petrmironychev.qodeassist\lib\qtcreator\plugins  
+3. Launch Qt Creator and install the plugin:
+   - Go to: 
+     - MacOS: Qt Creator -> About Plugins...
+     - Windows\Linux: Help -> About Plugins...
+   - Click on "Install Plugin..."
+   - Select the downloaded QodeAssist plugin archive file
+
+## Configure for Anthropic Claude
+1. Open Qt Creator settings and navigate to the QodeAssist section
+2. Go to Provider Settings tab and configure Claude api key
+3. Return to General tab and configure:
+   - Set "Claude" as the provider for code completion or/and chat assistant
+   - Set the Claude URL (https://api.anthropic.com)
+   - Select your preferred model (e.g., claude-3-5-sonnet-20241022)
+   - Choose the Claude template for code completion or/and chat
+<details>
+  <summary>Example of Claude settings: (click to expand)</summary>
+<img width="823" alt="Claude Settings" src="https://github.com/user-attachments/assets/828e09ea-e271-4a7a-8271-d3d5dd5c13fd" />
+</details>
+
+## Configure for OpenAI
+1. Open Qt Creator settings and navigate to the QodeAssist section
+2. Go to Provider Settings tab and configure OpenAI api key
+3. Return to General tab and configure:
+   - Set "OpenAI" as the provider for code completion or/and chat assistant
+   - Set the OpenAI URL (https://api.openai.com)
+   - Select your preferred model (e.g., gpt-4o)
+   - Choose the OpenAI template for code completion or/and chat
+<details>
+  <summary>Example of OpenAI settings: (click to expand)</summary>
+  <img width="829" alt="OpenAI Settings" src="https://github.com/user-attachments/assets/4716f790-6159-44d0-a8f4-565ccb6eb713" />
+</details>
+
+## Configure for Mistral AI
+1. Open Qt Creator settings and navigate to the QodeAssist section
+2. Go to Provider Settings tab and configure Mistral AI api key
+3. Return to General tab and configure:
+   - Set "Mistral AI" as the provider for code completion or/and chat assistant
+   - Set the OpenAI URL (https://api.mistral.ai)
+   - Select your preferred model (e.g., mistral-large-latest)
+   - Choose the Mistral AI template for code completion or/and chat
+<details>
+  <summary>Example of Mistral AI settings: (click to expand)</summary>
+  <img width="829" alt="Mistral AI Settings" src="https://github.com/user-attachments/assets/1c5ed13b-a29b-43f7-b33f-2e05fdea540c" />
+</details>
+
+## Configure for Google AI
+1. Open Qt Creator settings and navigate to the QodeAssist section
+2. Go to Provider Settings tab and configure Google AI api key
+3. Return to General tab and configure:
+   - Set "Google AI" as the provider for code completion or/and chat assistant
+   - Set the OpenAI URL (https://generativelanguage.googleapis.com/v1beta)
+   - Select your preferred model (e.g., gemini-2.0-flash)
+   - Choose the Google AI template
+<details>
+  <summary>Example of Google AI settings: (click to expand)</summary>
+  <img width="829" alt="Google AI Settings" src="https://github.com/user-attachments/assets/046ede65-a94d-496c-bc6c-41f3750be12a" />
+</details>
+
+## Configure for Ollama
+
+1. Install [Ollama](https://ollama.com). Make sure to review the system requirements before installation.
+2. Install a language models in Ollama via terminal. For example, you can run:
+
+For standard computers (minimum 8GB RAM):
+```
+ollama run qwen2.5-coder:7b
+```
+For better performance (16GB+ RAM):
+```
+ollama run qwen2.5-coder:14b
+```
+For high-end systems (32GB+ RAM):
+```
+ollama run qwen2.5-coder:32b
+```
+
+1. Open Qt Creator settings (Edit > Preferences on Linux/Windows, Qt Creator > Preferences on macOS)
+2. Navigate to the "QodeAssist" tab
+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 or Ollama Auto Chat for chat assistance. You can specify template if it is not work correct
+    - Disable using tools if your model doesn't support tooling
+4. Click Apply if you made any changes
+
+You're all set! QodeAssist is now ready to use in Qt Creator.
+<details>
+  <summary>Example of Ollama settings: (click to expand)</summary>
+  <img width="824" alt="Ollama Settings" src="https://github.com/user-attachments/assets/ed64e03a-a923-467a-aa44-4f790e315b53" />
+</details>
+
+## Configure for llama.cpp
+1. Open Qt Creator settings and navigate to the QodeAssist section
+2. Go to General tab and configure:
+   - Set "llama.cpp" as the provider for code completion or/and chat assistant
+   - Set the llama.cpp URL (e.g. http://localhost:8080)
+   - Fill in model name
+   - Choose template for model(e.g. llama.cpp FIM for any model with FIM support)
+   - Disable using tools if your model doesn't support tooling
+<details>
+  <summary>Example of llama.cpp settings: (click to expand)</summary>
+  <img width="829" alt="llama.cpp Settings" src="https://github.com/user-attachments/assets/8c75602c-60f3-49ed-a7a9-d3c972061ea2" />
+</details>
+
+## System Prompt Configuration
+
+The plugin comes with default system prompts optimized for chat and instruct models, as these currently provide better results for code assistance. If you prefer using FIM (Fill-in-Middle) models, you can easily customize the system prompt in the settings.
+
+## Project Rules Configuration
+
+QodeAssist supports project-specific rules to customize AI behavior for your codebase. Create a `.qodeassist/rules/` directory in your project root.
+
+### Quick Start
+```bash
+mkdir -p .qodeassist/rules/{common,completion,chat,quickrefactor}
+```
+```
+.qodeassist/
+└── rules/
+    ├── common/           # Applied to all contexts
+    ├── completion/       # Code completion only
+    ├── chat/            # Chat assistant only
+    └── quickrefactor/   # Quick refactor only
+```
+All .md files in each directory are automatically loaded and added to the system prompt.
+
+Example
+Create .qodeassist/rules/common/general.md:
+```markdown
+# Project Guidelines
+- Use snake_case for private members
+- Prefix interfaces with 'I'
+- Always document public APIs
+- Prefer Qt containers over STL
+```
+
+## File Context Feature
+
+QodeAssist provides two powerful ways to include source code files in your chat conversations: Attachments and Linked Files. Each serves a distinct purpose and helps provide better context for the AI assistant.
+
+### Attached Files
+
+Attachments are designed for one-time code analysis and specific queries:
+  - Files are included only in the current message
+  - Content is discarded after the message is processed
+  - Ideal for:
+    - Getting specific feedback on code changes
+    - Code review requests
+    - Analyzing isolated code segments
+    - Quick implementation questions
+  - Files can be attached using the paperclip icon in the chat interface
+  - Multiple files can be attached to a single message
+
+### Linked Files
+
+Linked files provide persistent context throughout the conversation:
+
+  - Files remain accessible for the entire chat session
+  - Content is included in every message exchange
+  - Files are automatically refreshed - always using latest content from disk
+  - Perfect for:
+    - Long-term refactoring discussions
+    - Complex architectural changes
+    - Multi-file implementations
+    - Maintaining context across related questions
+  - Can be managed using the link icon in the chat interface
+  - Supports automatic syncing with open editor files (can be enabled in settings)
+  - Files can be added/removed at any time during the conversation
+
+## Quick Refactoring Feature
+### Setup
+  Since this is actually a small chat with redirected output, the main settings of the provider, model and template are taken from the chat settings
+### Using
+  The request to model consist of instructions to model, selection code and cursor position
+  The default instruction is: "Refactor the code to improve its quality and maintainability." and sending if text field is empty
+  Also there buttons to quick call instractions:
+  * Repeat latest instruction, will activate after sending first request in QtCreator session
+  * Improve current selection code
+  * Suggestion alternative variant of selection code
+  * Other instructions[TBD]
+
+## QtCreator Version Compatibility
+
+- QtCreator 17.0.0 - 0.6.0 - 0.x.x
+- QtCreator 16.0.2 - 0.5.13 - 0.x.x
+- QtCreator 16.0.1 - 0.5.7 - 0.5.13
+- QtCreator 16.0.0 - 0.5.2 - 0.5.6
+- QtCreator 15.0.1 - 0.4.8 - 0.5.1
+- QtCreator 15.0.0 - 0.4.0 - 0.4.7 
+- 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
-- [ ] Improve and automate settings
-- [ ] Add chat 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
+- [ ] Support MCP
 
-## Installation Plugin
+## Hotkeys
+All hotkeys available in QtCreator Settings
+Also you can find default hotkeys here:
+- To call chat with llm in separate window, you can use:
+    - on Mac: Option + Command + W
+    - on Windows: Ctrl + Alt + W
+    - on Linux: Ctrl + Alt + W
+- To close chat with llm in separate window, you can use:
+    - on Mac: Option + Command + S
+    - on Windows: Ctrl + Alt + S
+    - on Linux: Ctrl + Alt + S
+- To call manual request to suggestion, you can use or change it in settings
+    - on Mac: Option + Command + Q
+    - on Windows: Ctrl + Alt + Q
+    - on Linux with KDE Plasma: Ctrl + Alt + Q
+- To insert the full suggestion, you can use the TAB key
+- To insert word of suggistion, you can use Alt + Right Arrow for Win/Lin, or Option + Right Arrow for Mac
+- To call Quick Refactor dialog, select some code or place cursor and press
+    - on Mac: Option + Command + R
+    - on Windows: Ctrl + Alt + R
+    - on Linux with KDE Plasma: Ctrl + Alt + R
 
-1. Install QtCreator 14.0
-2. Install [Ollama](https://ollama.com). Make sure to review the system requirements before installation.
-3. Install a language model in Ollama. For example, you can run:
+## Ignoring Files
+QodeAssist supports the ability to ignore files in context using a .qodeassistignore file. This allows you to exclude specific files from the context during code completion and in the chat assistant, which is especially useful for large projects.
+
+### How to Use .qodeassistignore
+- Create a .qodeassistignore file in the root directory of your project near CMakeLists.txt or pro.
+- Add patterns for files and directories that should be excluded from the context.
+- QodeAssist will automatically detect this file and apply the exclusion rules.
+
+### .qodeassistignore File Format
+The file format is similar to .gitignore:
+- Each pattern is written on a separate line
+- Empty lines are ignored
+- Lines starting with # are considered comments
+- Standard wildcards work the same as in .gitignore
+- To negate a pattern, use ! at the beginning of the line
 ```
-ollama run starcoder2:7b
+# Ignore all files in the build directory
+/build
+*.tmp
+# Ignore a specific file
+src/generated/autogen.cpp
+
 ```
-4. Download the QodeAssist plugin.
-5. Launch Qt Creator and install the plugin:
-   - Go to MacOS: Qt Creator -> About Plugins...
-           Windows\Linux: Help -> About Plugins...
-   - Click on "Install Plugin..."
-   - Select the downloaded QodeAssist plugin archive file
+    
+## Troubleshooting
 
-## Configure Plugin
+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. 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
+
+3. On Linux the prebuilt binaries support only ubuntu 22.04+ or simililliar os. 
+If you need compatiblity with another os, you have to build manualy. our experiments and resolution you can check here: https://github.com/Palm1r/QodeAssist/issues/48
+
+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. Choose your LLM provider (e.g., Ollama)
-   - If you haven't added the provider to your system PATH, specify the path to the provider executable in the "Provider Paths" field
-4. Select the installed model
-   - If you need to enter the model name manually, it indicates that the plugin cannot locate the provider's executable file. However, this doesn't affect the plugin's functionality – it will still work correctly. This autoselector input option is provided for your convenience, allowing you to easily select and use different models
-5. Choose the prompt template that corresponds to your model
-6. Apply the settings
-
-You're all set! QodeAssist is now ready to use in Qt Creator.
+2. Navigate to the "QodeAssist" 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 +392,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 +411,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)
+

TaskFlow/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_subdirectory(core)
+add_subdirectory(Editor)
+# add_subdirectory(serialization)
+# add_subdirectory(tasks)
+
+qt_add_library(TaskFlow STATIC)
+
+target_link_libraries(TaskFlow
+    PUBLIC
+    TaskFlowCore
+    TaskFlowEditorplugin
+    # TaskFlowSerialization
+    # TaskFlowTasks
+)

TaskFlow/Editor/CMakeLists.txt

@@ -0,0 +1,41 @@
+qt_add_library(TaskFlowEditor STATIC)
+
+qt_policy(SET QTP0001 NEW)
+qt_policy(SET QTP0004 NEW)
+
+qt_add_qml_module(TaskFlowEditor
+    URI TaskFlow.Editor
+    VERSION 1.0
+    DEPENDENCIES QtQuick
+    RESOURCES
+    QML_FILES
+    qml/FlowEditorView.qml
+    qml/Flow.qml
+    qml/Task.qml
+    qml/TaskPort.qml
+    qml/TaskParameter.qml
+    qml/TaskConnection.qml
+    SOURCES
+    FlowEditor.hpp FlowEditor.cpp
+    FlowsModel.hpp FlowsModel.cpp
+    TaskItem.hpp TaskItem.cpp
+    FlowItem.hpp FlowItem.cpp
+    TaskModel.hpp TaskModel.cpp
+    TaskPortItem.hpp TaskPortItem.cpp
+    TaskPortModel.hpp TaskPortModel.cpp
+    TaskConnectionsModel.hpp TaskConnectionsModel.cpp
+    TaskConnectionItem.hpp TaskConnectionItem.cpp
+    GridBackground.hpp GridBackground.cpp
+)
+
+target_link_libraries(TaskFlowEditor
+    PUBLIC
+    Qt::Quick
+    PRIVATE
+    TaskFlowCore
+)
+
+target_include_directories(TaskFlowEditor
+    PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)

TaskFlow/Editor/FlowEditor.cpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2025 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:
+ */
+
+#include "FlowEditor.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+FlowEditor::FlowEditor(QQuickItem *parent)
+    : QQuickItem(parent)
+{}
+
+void FlowEditor::initialize()
+{
+    emit availableTaskTypesChanged();
+    emit availableFlowsChanged();
+
+    m_flowsModel = new FlowsModel(m_flowManager, this);
+
+    emit flowsModelChanged();
+
+    if (m_flowsModel->rowCount() > 0) {
+        setCurrentFlowIndex(0);
+    }
+
+    // setCurrentFlowId(m_flowManager->flows().begin().value()->flowId());
+    m_currentFlow = m_flowManager->getFlow();
+    emit currentFlowChanged();
+}
+
+QString FlowEditor::currentFlowId() const
+{
+    return m_currentFlowId;
+}
+
+void FlowEditor::setCurrentFlowId(const QString &newCurrentFlowId)
+{
+    if (m_currentFlowId == newCurrentFlowId)
+        return;
+    m_currentFlowId = newCurrentFlowId;
+    emit currentFlowIdChanged();
+}
+
+QStringList FlowEditor::availableTaskTypes() const
+{
+    if (m_flowManager)
+        return m_flowManager->getAvailableTasksTypes();
+    else {
+        return {"No flow manager"};
+    }
+}
+
+QStringList FlowEditor::availableFlows() const
+{
+    if (m_flowManager) {
+        auto flows = m_flowManager->getAvailableFlows();
+        return flows.size() > 0 ? flows : QStringList{"No flows"};
+    } else {
+        return {"No flow manager"};
+    }
+}
+
+void FlowEditor::setFlowManager(FlowManager *newFlowManager)
+{
+    if (m_flowManager == newFlowManager)
+        return;
+    m_flowManager = newFlowManager;
+
+    initialize();
+}
+
+FlowsModel *FlowEditor::flowsModel() const
+{
+    return m_flowsModel;
+}
+
+int FlowEditor::currentFlowIndex() const
+{
+    return m_currentFlowIndex;
+}
+
+void FlowEditor::setCurrentFlowIndex(int newCurrentFlowIndex)
+{
+    if (m_currentFlowIndex == newCurrentFlowIndex)
+        return;
+    m_currentFlowIndex = newCurrentFlowIndex;
+    emit currentFlowIndexChanged();
+}
+
+Flow *FlowEditor::getFlow(const QString &flowName)
+{
+    return m_flowManager->getFlow(flowName);
+}
+
+Flow *FlowEditor::getCurrentFlow()
+{
+    return m_flowManager->getFlow(m_currentFlowId);
+}
+
+Flow *FlowEditor::currentFlow() const
+{
+    return m_currentFlow;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/FlowEditor.hpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2025 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:
+ */
+
+#pragma once
+
+#include <QQuickItem>
+
+#include "FlowsModel.hpp"
+#include <FlowManager.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class FlowEditor : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(
+        QString currentFlowId READ currentFlowId WRITE setCurrentFlowId NOTIFY currentFlowIdChanged)
+    Q_PROPERTY(
+        QStringList availableTaskTypes READ availableTaskTypes NOTIFY availableTaskTypesChanged)
+    Q_PROPERTY(QStringList availableFlows READ availableFlows NOTIFY availableFlowsChanged)
+    Q_PROPERTY(FlowsModel *flowsModel READ flowsModel NOTIFY flowsModelChanged)
+    Q_PROPERTY(int currentFlowIndex READ currentFlowIndex WRITE setCurrentFlowIndex NOTIFY
+                   currentFlowIndexChanged)
+
+    Q_PROPERTY(Flow *currentFlow READ currentFlow NOTIFY currentFlowChanged FINAL)
+
+public:
+    FlowEditor(QQuickItem *parent = nullptr);
+
+    void initialize();
+
+    QString currentFlowId() const;
+    void setCurrentFlowId(const QString &newCurrentFlowId);
+
+    QStringList availableTaskTypes() const;
+    QStringList availableFlows() const;
+
+    void setFlowManager(FlowManager *newFlowManager);
+
+    FlowsModel *flowsModel() const;
+
+    int currentFlowIndex() const;
+    void setCurrentFlowIndex(int newCurrentFlowIndex);
+
+    Q_INVOKABLE Flow *getFlow(const QString &flowName);
+    Q_INVOKABLE Flow *getCurrentFlow();
+
+    Flow *currentFlow() const;
+
+signals:
+    void currentFlowIdChanged();
+    void availableTaskTypesChanged();
+    void availableFlowsChanged();
+    void flowsModelChanged();
+
+    void currentFlowIndexChanged();
+
+    void currentFlowChanged();
+
+private:
+    FlowManager *m_flowManager = nullptr;
+    QString m_currentFlowId;
+    FlowsModel *m_flowsModel;
+    int m_currentFlowIndex;
+    Flow *m_currentFlow = nullptr;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/FlowItem.cpp

@@ -0,0 +1,90 @@
+#include "FlowItem.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+FlowItem::FlowItem(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    connect(this, &QQuickItem::childrenChanged, this, [this]() { updateFlowLayout(); });
+}
+
+QString FlowItem::flowId() const
+{
+    if (!m_flow)
+        return {"no flow"};
+    return m_flow->flowId();
+}
+
+void FlowItem::setFlowId(const QString &newFlowId)
+{
+    if (m_flow->flowId() == newFlowId)
+        return;
+    m_flow->setFlowId(newFlowId);
+    emit flowIdChanged();
+}
+
+Flow *FlowItem::flow() const
+{
+    return m_flow;
+}
+
+void FlowItem::setFlow(Flow *newFlow)
+{
+    if (m_flow == newFlow)
+        return;
+    m_flow = newFlow;
+    emit flowChanged();
+    emit flowIdChanged();
+    qDebug() << "FlowItem::setFlow" << m_flow->flowId() << newFlow;
+
+    m_taskModel = new TaskModel(m_flow, this);
+    m_connectionsModel = new TaskConnectionsModel(m_flow, this);
+
+    emit taskModelChanged();
+    emit connectionsModelChanged();
+}
+
+TaskModel *FlowItem::taskModel() const
+{
+    return m_taskModel;
+}
+
+TaskConnectionsModel *FlowItem::connectionsModel() const
+{
+    return m_connectionsModel;
+}
+
+QVariantList FlowItem::taskItems() const
+{
+    return m_taskItems;
+}
+
+void FlowItem::setTaskItems(const QVariantList &newTaskItems)
+{
+    qDebug() << "FlowItem::setTaskItems" << newTaskItems;
+    if (m_taskItems == newTaskItems)
+        return;
+    m_taskItems = newTaskItems;
+    emit taskItemsChanged();
+}
+
+void FlowItem::updateFlowLayout()
+{
+    auto allItems = this->childItems();
+
+    for (auto child : allItems) {
+        if (child->objectName() == QString("TaskItem")) {
+            qDebug() << "Found TaskItem:" << child;
+            auto taskItem = qobject_cast<TaskItem *>(child);
+            m_taskItemsList.insert(taskItem, taskItem->task());
+        }
+
+        if (child->objectName() == QString("TaskConnectionItem")) {
+            qDebug() << "Found TaskConnectionItem:" << child;
+            auto connectionItem = qobject_cast<TaskConnectionItem *>(child);
+            m_taskConnectionsList.insert(connectionItem, connectionItem->connection());
+        }
+    }
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/FlowItem.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <QQuickItem>
+
+#include "TaskConnectionItem.hpp"
+#include "TaskConnectionsModel.hpp"
+#include "TaskItem.hpp"
+#include "TaskModel.hpp"
+#include <Flow.hpp>
+#include <TaskConnection.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class FlowItem : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(QString flowId READ flowId WRITE setFlowId NOTIFY flowIdChanged)
+    Q_PROPERTY(Flow *flow READ flow WRITE setFlow NOTIFY flowChanged)
+    Q_PROPERTY(TaskModel *taskModel READ taskModel NOTIFY taskModelChanged)
+    Q_PROPERTY(
+        TaskConnectionsModel *connectionsModel READ connectionsModel NOTIFY connectionsModelChanged)
+    Q_PROPERTY(QVariantList taskItems READ taskItems WRITE setTaskItems NOTIFY taskItemsChanged)
+
+public:
+    explicit FlowItem(QQuickItem *parent = nullptr);
+
+    QString flowId() const;
+    void setFlowId(const QString &newFlowId);
+
+    Flow *flow() const;
+    void setFlow(Flow *newFlow);
+
+    TaskModel *taskModel() const;
+
+    TaskConnectionsModel *connectionsModel() const;
+
+    QVariantList taskItems() const;
+    void setTaskItems(const QVariantList &newTaskItems);
+
+    void updateFlowLayout();
+
+signals:
+    void flowIdChanged();
+    void flowChanged();
+    void taskModelChanged();
+    void connectionsModelChanged();
+    void taskItemsChanged();
+
+private:
+    Flow *m_flow = nullptr;
+    TaskModel *m_taskModel = nullptr;
+    TaskConnectionsModel *m_connectionsModel = nullptr;
+    QVariantList m_taskItems;
+
+    QHash<TaskItem *, BaseTask *> m_taskItemsList;
+    QHash<TaskConnectionItem *, TaskConnection *> m_taskConnectionsList;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/FlowsModel.cpp

@@ -0,0 +1,54 @@
+#include "FlowsModel.hpp"
+
+#include "FlowManager.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+FlowsModel::FlowsModel(FlowManager *flowManager, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_flowManager(flowManager)
+{
+    connect(m_flowManager, &FlowManager::flowAdded, this, &FlowsModel::onFlowAdded);
+}
+
+int FlowsModel::rowCount(const QModelIndex &parent) const
+{
+    return m_flowManager->flows().size();
+}
+
+QVariant FlowsModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || !m_flowManager || index.row() >= m_flowManager->flows().size())
+        return QVariant();
+
+    const auto flows = m_flowManager->flows().values();
+
+    switch (role) {
+    case FlowRoles::FlowIdRole:
+        return flows.at(index.row())->flowId();
+    case FlowRoles::FlowDataRole:
+        return QVariant::fromValue(flows.at(index.row()));
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> FlowsModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[FlowRoles::FlowIdRole] = "flowId";
+    roles[FlowRoles::FlowDataRole] = "flowData";
+    return roles;
+}
+
+void FlowsModel::onFlowAdded(const QString &flowId)
+{
+    // qDebug() << "FlowsModel::Flow added: " << flowId;
+    // int newIndex = m_flowManager->flows().size();
+    // beginInsertRows(QModelIndex(), newIndex, newIndex);
+    // endInsertRows();
+}
+
+void FlowsModel::onFlowRemoved(const QString &flowId) {}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/FlowsModel.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+
+// #include "tasks/Flow.hpp"
+#include <FlowManager.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class FlowsModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum FlowRoles { FlowIdRole = Qt::UserRole, FlowDataRole };
+
+    FlowsModel(FlowManager *flowManager, 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;
+
+public slots:
+    void onFlowAdded(const QString &flowId);
+    void onFlowRemoved(const QString &flowId);
+
+private:
+    FlowManager *m_flowManager;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/GridBackground.cpp

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2025 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 "GridBackground.hpp"
+#include <QPainter>
+#include <QPixmap>
+#include <QQuickWindow>
+#include <QSGSimpleRectNode>
+#include <QSGSimpleTextureNode>
+
+namespace QodeAssist::TaskFlow {
+
+GridBackground::GridBackground(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    setFlag(QQuickItem::ItemHasContents, true);
+}
+
+int GridBackground::gridSize() const
+{
+    return m_gridSize;
+}
+
+void GridBackground::setGridSize(int size)
+{
+    if (m_gridSize != size) {
+        m_gridSize = size;
+        update();
+        emit gridSizeChanged();
+    }
+}
+
+QColor GridBackground::gridColor() const
+{
+    return m_gridColor;
+}
+
+void GridBackground::setGridColor(const QColor &color)
+{
+    if (m_gridColor != color) {
+        m_gridColor = color;
+        update();
+        emit gridColorChanged();
+    }
+}
+
+QSGNode *GridBackground::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+{
+    QSGSimpleTextureNode *node = static_cast<QSGSimpleTextureNode *>(oldNode);
+    if (!node) {
+        node = new QSGSimpleTextureNode();
+    }
+
+    QPixmap pixmap(width(), height());
+    pixmap.fill(Qt::transparent);
+
+    QPainter painter(&pixmap);
+    painter.setRenderHint(QPainter::Antialiasing, false);
+
+    QPen pen(m_gridColor);
+    pen.setWidth(1);
+    painter.setPen(pen);
+    painter.setOpacity(this->opacity());
+
+    for (int x = 0; x < width(); x += m_gridSize) {
+        painter.drawLine(x, 0, x, height());
+    }
+
+    for (int y = 0; y < height(); y += m_gridSize) {
+        painter.drawLine(0, y, width(), y);
+    }
+
+    painter.end();
+
+    QSGTexture *texture = window()->createTextureFromImage(pixmap.toImage());
+    node->setTexture(texture);
+    node->setRect(boundingRect());
+
+    return node;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/GridBackground.hpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2025 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 <QColor>
+#include <QPainter>
+#include <QQuickItem>
+
+namespace QodeAssist::TaskFlow {
+
+class GridBackground : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(int gridSize READ gridSize WRITE setGridSize NOTIFY gridSizeChanged)
+    Q_PROPERTY(QColor gridColor READ gridColor WRITE setGridColor NOTIFY gridColorChanged)
+
+public:
+    explicit GridBackground(QQuickItem *parent = nullptr);
+
+    int gridSize() const;
+    void setGridSize(int size);
+
+    QColor gridColor() const;
+    void setGridColor(const QColor &color);
+
+signals:
+    void gridSizeChanged();
+    void gridColorChanged();
+
+protected:
+    QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) override;
+
+private:
+    int m_gridSize = 20;
+    QColor m_gridColor = QColor(128, 128, 128);
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskConnectionItem.cpp

@@ -0,0 +1,153 @@
+#include "TaskConnectionItem.hpp"
+#include "TaskItem.hpp"
+#include "TaskPortItem.hpp"
+#include <QDebug>
+
+namespace QodeAssist::TaskFlow {
+
+TaskConnectionItem::TaskConnectionItem(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    setObjectName("TaskConnectionItem");
+}
+
+void TaskConnectionItem::setConnection(TaskConnection *connection)
+{
+    if (m_connection == connection)
+        return;
+
+    m_connection = connection;
+    emit connectionChanged();
+
+    calculatePositions();
+}
+
+void TaskConnectionItem::updatePositions()
+{
+    // calculatePositions();
+}
+
+void TaskConnectionItem::calculatePositions()
+{
+    if (!m_connection) {
+        return;
+    }
+
+    // Find source task item
+    QQuickItem *sourceTaskItem = findTaskItem(m_connection->sourceTask());
+    QQuickItem *targetTaskItem = findTaskItem(m_connection->targetTask());
+
+    if (!sourceTaskItem || !targetTaskItem) {
+        return;
+    }
+
+    // Find port items within tasks
+    QQuickItem *sourcePortItem = findPortItem(sourceTaskItem, m_connection->sourcePort());
+    QQuickItem *targetPortItem = findPortItem(targetTaskItem, m_connection->targetPort());
+
+    if (!sourcePortItem || !targetPortItem) {
+        return;
+    }
+
+    // Calculate global positions
+    QPointF sourceGlobal
+        = sourcePortItem
+              ->mapToItem(parentItem(), sourcePortItem->width() / 2, sourcePortItem->height() / 2);
+    QPointF targetGlobal
+        = targetPortItem
+              ->mapToItem(parentItem(), targetPortItem->width() / 2, targetPortItem->height() / 2);
+
+    if (m_startPoint != sourceGlobal) {
+        m_startPoint = sourceGlobal;
+        emit startPointChanged();
+    }
+
+    if (m_endPoint != targetGlobal) {
+        m_endPoint = targetGlobal;
+        emit endPointChanged();
+    }
+}
+
+QQuickItem *TaskConnectionItem::findTaskItem(BaseTask *task)
+{
+    for (const QVariant &item : m_taskItems) {
+        QQuickItem *taskItem = qvariant_cast<QQuickItem *>(item);
+        if (!taskItem)
+            continue;
+
+        QVariant taskProp = taskItem->property("task");
+        if (taskProp.isValid() && taskProp.value<BaseTask *>() == task) {
+            return taskItem;
+        }
+    }
+    return nullptr;
+}
+
+QQuickItem *TaskConnectionItem::findTaskItemRecursive(QQuickItem *item, BaseTask *task)
+{
+    // Проверяем objectName и task property
+    if (item->objectName() == "TaskItem") {
+        QVariant taskProp = item->property("task");
+        if (taskProp.isValid()) {
+            BaseTask *itemTask = taskProp.value<BaseTask *>();
+            if (itemTask == task) {
+                return item;
+            }
+        }
+    }
+
+    // Рекурсивно ищем в детях
+    auto children = item->childItems();
+
+    for (QQuickItem *child : children) {
+        if (QQuickItem *found = findTaskItemRecursive(child, task)) {
+            return found;
+        }
+    }
+
+    return nullptr;
+}
+
+QQuickItem *TaskConnectionItem::findPortItem(QQuickItem *taskItem, TaskPort *port)
+{
+    std::function<QQuickItem *(QQuickItem *)> findPortRecursive =
+        [&](QQuickItem *item) -> QQuickItem * {
+        // Проверяем objectName и port property
+        if (item->objectName() == "TaskPortItem") {
+            QVariant portProp = item->property("port");
+            if (portProp.isValid()) {
+                TaskPort *itemPort = portProp.value<TaskPort *>();
+                if (itemPort == port) {
+                    return item;
+                }
+            }
+        }
+
+        // Рекурсивно ищем в детях
+        for (QQuickItem *child : item->childItems()) {
+            if (QQuickItem *found = findPortRecursive(child)) {
+                return found;
+            }
+        }
+        return nullptr;
+    };
+
+    return findPortRecursive(taskItem);
+}
+
+QVariantList TaskConnectionItem::taskItems() const
+{
+    return m_taskItems;
+}
+
+void TaskConnectionItem::setTaskItems(const QVariantList &newTaskItems)
+{
+    if (m_taskItems == newTaskItems)
+        return;
+    m_taskItems = newTaskItems;
+    emit taskItemsChanged();
+
+    calculatePositions();
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskConnectionItem.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "TaskConnection.hpp"
+#include <QPointF>
+#include <QQuickItem>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskConnectionItem : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(QPointF startPoint READ startPoint NOTIFY startPointChanged)
+    Q_PROPERTY(QPointF endPoint READ endPoint NOTIFY endPointChanged)
+    Q_PROPERTY(
+        TaskConnection *connection READ connection WRITE setConnection NOTIFY connectionChanged)
+
+    Q_PROPERTY(QVariantList taskItems READ taskItems WRITE setTaskItems NOTIFY taskItemsChanged)
+
+public:
+    TaskConnectionItem(QQuickItem *parent = nullptr);
+
+    QPointF startPoint() const { return m_startPoint; }
+    QPointF endPoint() const { return m_endPoint; }
+
+    TaskConnection *connection() const { return m_connection; }
+    void setConnection(TaskConnection *connection);
+
+    Q_INVOKABLE void updatePositions();
+
+    QVariantList taskItems() const;
+    void setTaskItems(const QVariantList &newTaskItems);
+
+signals:
+    void startPointChanged();
+    void endPointChanged();
+    void connectionChanged();
+
+    void taskItemsChanged();
+
+private:
+    void calculatePositions();
+    QQuickItem *findTaskItem(BaseTask *task);
+    QQuickItem *findTaskItemRecursive(QQuickItem *item, BaseTask *task);
+    QQuickItem *findPortItem(QQuickItem *taskItem, TaskPort *port);
+
+private:
+    TaskConnection *m_connection = nullptr;
+    QPointF m_startPoint;
+    QPointF m_endPoint;
+    QVariantList m_taskItems;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskConnectionsModel.cpp

@@ -0,0 +1,29 @@
+#include "TaskConnectionsModel.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+TaskConnectionsModel::TaskConnectionsModel(Flow *flow, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_flow(flow)
+{}
+
+int TaskConnectionsModel::rowCount(const QModelIndex &parent) const
+{
+    return m_flow->connections().size();
+}
+
+QVariant TaskConnectionsModel::data(const QModelIndex &index, int role) const
+{
+    if (role == TaskConnectionsRoles::TaskConnectionsRole)
+        return QVariant::fromValue(m_flow->connections().at(index.row()));
+    return QVariant();
+}
+
+QHash<int, QByteArray> TaskConnectionsModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[TaskConnectionsRoles::TaskConnectionsRole] = "connectionData";
+    return roles;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskConnectionsModel.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+
+#include <Flow.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskConnectionsModel : public QAbstractListModel
+{
+public:
+    enum TaskConnectionsRoles { TaskConnectionsRole = Qt::UserRole };
+
+    explicit TaskConnectionsModel(Flow *flow, 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;
+
+private:
+    Flow *m_flow;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskItem.cpp

@@ -0,0 +1,69 @@
+#include "TaskItem.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+TaskItem::TaskItem(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    setObjectName("TaskItem");
+}
+
+QString TaskItem::taskId() const
+{
+    return m_taskId;
+}
+
+void TaskItem::setTaskId(const QString &newTaskId)
+{
+    if (m_taskId == newTaskId)
+        return;
+    m_taskId = newTaskId;
+    emit taskIdChanged();
+}
+
+QString TaskItem::taskType() const
+{
+    return m_task ? m_task->taskType() : QString();
+}
+
+BaseTask *TaskItem::task() const
+{
+    return m_task;
+}
+
+void TaskItem::setTask(BaseTask *newTask)
+{
+    if (m_task == newTask)
+        return;
+
+    m_task = newTask;
+
+    if (m_task) {
+        m_taskId = m_task->taskId();
+
+        // Обновляем модели портов
+        m_inputPorts = new TaskPortModel(m_task->getInputPorts(), this);
+        m_outputPorts = new TaskPortModel(m_task->getOutputPorts(), this);
+    } else {
+        m_inputPorts = nullptr;
+        m_outputPorts = nullptr;
+    }
+
+    emit taskChanged();
+    emit inputPortsChanged();
+    emit outputPortsChanged();
+    emit taskIdChanged();
+    emit taskTypeChanged();
+}
+
+TaskPortModel *TaskItem::inputPorts() const
+{
+    return m_inputPorts;
+}
+
+TaskPortModel *TaskItem::outputPorts() const
+{
+    return m_outputPorts;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskItem.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <QQuickItem>
+
+#include "TaskPortModel.hpp"
+#include <BaseTask.hpp>
+#include <TaskPort.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskItem : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(QString taskId READ taskId WRITE setTaskId NOTIFY taskIdChanged)
+    Q_PROPERTY(QString taskType READ taskType NOTIFY taskTypeChanged)
+    Q_PROPERTY(BaseTask *task READ task WRITE setTask NOTIFY taskChanged)
+    Q_PROPERTY(TaskPortModel *inputPorts READ inputPorts NOTIFY inputPortsChanged)
+    Q_PROPERTY(TaskPortModel *outputPorts READ outputPorts NOTIFY outputPortsChanged)
+
+public:
+    TaskItem(QQuickItem *parent = nullptr);
+
+    QString taskId() const;
+    void setTaskId(const QString &newTaskId);
+    QString taskType() const;
+
+    BaseTask *task() const;
+    void setTask(BaseTask *newTask);
+
+    TaskPortModel *inputPorts() const;
+    TaskPortModel *outputPorts() const;
+
+signals:
+    void taskIdChanged();
+    void taskTypeChanged();
+    void taskChanged();
+    void inputPortsChanged();
+    void outputPortsChanged();
+
+private:
+    QString m_taskId;
+    BaseTask *m_task = nullptr;
+    TaskPortModel *m_inputPorts = nullptr;
+    TaskPortModel *m_outputPorts = nullptr;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskModel.cpp

@@ -0,0 +1,40 @@
+#include "TaskModel.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+TaskModel::TaskModel(Flow *flow, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_flow(flow)
+{}
+
+int TaskModel::rowCount(const QModelIndex &parent) const
+{
+    return m_flow->tasks().size();
+}
+
+QVariant TaskModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || !m_flow || index.row() >= m_flow->tasks().size())
+        return QVariant();
+
+    const auto &task = m_flow->tasks().values();
+
+    switch (role) {
+    case TaskRoles::TaskIdRole:
+        return task.at(index.row())->taskId();
+    case TaskRoles::TaskDataRole:
+        return QVariant::fromValue(task.at(index.row()));
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> TaskModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[TaskRoles::TaskIdRole] = "taskId";
+    roles[TaskRoles::TaskDataRole] = "taskData";
+    return roles;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskModel.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QAbstractListModel>
+
+#include <Flow.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum TaskRoles { TaskIdRole = Qt::UserRole, TaskDataRole };
+
+    TaskModel(Flow *flow, QObject *parent);
+
+    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;
+
+private:
+    Flow *m_flow;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskPortItem.cpp

@@ -0,0 +1,29 @@
+#include "TaskPortItem.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+TaskPortItem::TaskPortItem(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    setObjectName("TaskPortItem");
+}
+
+TaskPort *TaskPortItem::port() const
+{
+    return m_port;
+}
+
+void TaskPortItem::setPort(TaskPort *newPort)
+{
+    if (m_port == newPort)
+        return;
+    m_port = newPort;
+    emit portChanged();
+}
+
+QString TaskPortItem::name() const
+{
+    return m_port->name();
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskPortItem.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <TaskPort.hpp>
+#include <QQuickItem>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskPortItem : public QQuickItem
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(TaskPort *port READ port WRITE setPort NOTIFY portChanged)
+    Q_PROPERTY(QString name READ name CONSTANT)
+
+public:
+    TaskPortItem(QQuickItem *parent = nullptr);
+
+    TaskPort *port() const;
+    void setPort(TaskPort *newPort);
+
+    QString name() const;
+
+signals:
+    void portChanged();
+
+private:
+    TaskPort *m_port = nullptr;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskPortModel.cpp

@@ -0,0 +1,39 @@
+#include "TaskPortModel.hpp"
+#include "TaskPort.hpp"
+
+namespace QodeAssist::TaskFlow {
+
+TaskPortModel::TaskPortModel(const QList<TaskPort *> &ports, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_ports(ports)
+{}
+
+int TaskPortModel::rowCount(const QModelIndex &parent) const
+{
+    return m_ports.size();
+}
+
+QVariant TaskPortModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_ports.size())
+        return QVariant();
+
+    switch (role) {
+    case TaskPortRoles::TaskPortNameRole:
+        return m_ports.at(index.row())->name();
+    case TaskPortRoles::TaskPortDataRole:
+        return QVariant::fromValue(m_ports.at(index.row()));
+    default:
+        return QVariant();
+    }
+}
+
+QHash<int, QByteArray> TaskPortModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[TaskPortRoles::TaskPortNameRole] = "taskPortName";
+    roles[TaskPortRoles::TaskPortDataRole] = "taskPortData";
+    return roles;
+}
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/TaskPortModel.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QAbstractListModel>
+
+#include <BaseTask.hpp>
+
+namespace QodeAssist::TaskFlow {
+
+class TaskPortModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum TaskPortRoles { TaskPortNameRole = Qt::UserRole, TaskPortDataRole };
+
+    TaskPortModel(const QList<TaskPort *> &ports, 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;
+
+private:
+    QList<TaskPort *> m_ports;
+};
+
+} // namespace QodeAssist::TaskFlow

TaskFlow/Editor/qml/Flow.qml

@@ -0,0 +1,134 @@
+import QtQuick
+import TaskFlow.Editor
+
+FlowItem {
+    id: root
+
+    Repeater {
+        id: tasks
+
+        model: root.taskModel
+        delegate: Task {
+            // task: taskData
+        }
+    }
+
+    Repeater {
+        id: connections
+
+        model: root.taskModel
+        delegate: TaskConnection {
+            // task: taskData
+        }
+    }
+
+    // property var qtaskItems: []
+
+    // // Flow container background
+    // Rectangle {
+    //     anchors.fill: parent
+    //     color: palette.alternateBase
+    //     border.color: palette.mid
+    //     border.width: 2
+    //     radius: 8
+
+    //     // Flow header
+    //     Rectangle {
+    //         id: flowHeader
+    //         anchors.top: parent.top
+    //         anchors.left: parent.left
+    //         anchors.right: parent.right
+    //         height: 40
+    //         color: palette.button
+    //         radius: 6
+
+    //         Rectangle {
+    //             anchors.bottom: parent.bottom
+    //             anchors.left: parent.left
+    //             anchors.right: parent.right
+    //             height: parent.radius
+    //             color: parent.color
+    //         }
+
+    //         Text {
+    //             anchors.centerIn: parent
+    //             text: root.flowId
+    //             color: palette.buttonText
+    //             font.pixelSize: 14
+    //             font.bold: true
+    //         }
+    //     }
+
+    //     // // Tasks container
+    //     // Row {
+    //     //     id: tasksRow
+    //     //     anchors.top: flowHeader.bottom
+    //     //     anchors.left: parent.left
+    //     //     anchors.margins: 25
+    //     //     anchors.topMargin: 25
+    //     //     objectName: "FlowTaskRow"
+
+    //     //     spacing: 40
+
+    //     //     Repeater {
+    //     //         model: root.taskModel
+
+    //     //         delegate: Task {
+    //     //             task: taskData
+    //     //         }
+
+    //     //         onItemAdded: function(index, item){
+    //     //             console.log("task added", index, item)
+    //     //             qtaskItems.push(item)
+    //     //             root.insertTaskItem(index, item)
+    //     //         }
+
+    //     //         onItemRemoved: function(index, item){
+    //     //             console.log("task added", index, item)
+    //     //             var idx = qtaskItems.indexOf(item)
+    //     //             if (idx !== -1) qtaskItems.splice(idx, 1)
+    //     //         }
+    //     //     }
+    //     // }
+
+    //     // Repeater {
+    //     //     model: root.connectionsModel
+
+    //     //     delegate: TaskConnection {
+    //     //         connection: connectionData
+    //     //     }
+    //     // }
+    // }
+
+    // // Flow info tooltip
+    // Rectangle {
+    //     id: infoTooltip
+    //     anchors.top: parent.bottom
+    //     anchors.left: parent.left
+    //     anchors.topMargin: 5
+    //     width: infoText.width + 20
+    //     height: infoText.height + 10
+    //     color: palette.base
+    //     border.color: palette.shadow
+    //     border.width: 1
+    //     radius: 4
+    //     visible: false
+
+    //     Text {
+    //         id: infoText
+    //         anchors.centerIn: parent
+    //         text: "Tasks: " + (root.taskModel ? root.taskModel.rowCount() : 0)
+    //         color: palette.text
+    //         font.pixelSize: 10
+    //     }
+    // }
+
+    // MouseArea {
+    //     anchors.fill: parent
+    //     hoverEnabled: true
+
+    //     onEntered: infoTooltip.visible = true
+    //     onExited: infoTooltip.visible = false
+    // }
+
+}

TaskFlow/Editor/qml/FlowEditorView.qml

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2025 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 TaskFlow.Editor
+
+FlowEditor {
+    id: root
+
+    width: 1200
+    height: 800
+
+    property SystemPalette sysPalette: SystemPalette {
+        colorGroup: SystemPalette.Active
+    }
+    palette {
+        window: sysPalette.window
+        windowText: sysPalette.windowText
+        base: sysPalette.base
+        alternateBase: sysPalette.alternateBase
+        text: sysPalette.text
+        button: sysPalette.button
+        buttonText: sysPalette.buttonText
+        highlight: sysPalette.highlight
+        highlightedText: sysPalette.highlightedText
+        light: sysPalette.light
+        mid: sysPalette.mid
+        dark: sysPalette.dark
+        shadow: sysPalette.shadow
+        brightText: sysPalette.brightText
+    }
+
+    // Background with grid pattern
+    Rectangle {
+        anchors.fill: parent
+        color: palette.window
+
+        // Grid pattern using C++ implementation
+        GridBackground {
+            anchors.fill: parent
+            gridSize: 20
+            gridColor: palette.mid
+            opacity: 0.3
+        }
+    }
+
+    // Header panel
+    Rectangle {
+        id: headerPanel
+        anchors.top: parent.top
+        anchors.left: parent.left
+        anchors.right: parent.right
+        height: 60
+        color: palette.base
+        border.color: palette.mid
+        border.width: 1
+
+        Row {
+            anchors.left: parent.left
+            anchors.verticalCenter: parent.verticalCenter
+            anchors.leftMargin: 20
+            spacing: 20
+
+            Text {
+                text: "Flow Editor"
+                color: palette.windowText
+                font.pixelSize: 18
+                font.bold: true
+            }
+
+            Rectangle {
+                width: 2
+                height: 30
+                color: palette.mid
+            }
+
+            Text {
+                text: "Flow:"
+                color: palette.text
+                font.pixelSize: 14
+            }
+
+            ComboBox {
+                id: flowComboBox
+
+                model: root.flowsModel
+                textRole: "flowId"
+                currentIndex: root.currentFlowIndex
+
+                onActivated: {
+                    root.currentFlowIndex = currentIndex
+                }
+            }
+
+            Text {
+                text: "Available Tasks: " + root.availableTaskTypes.join(", ")
+                color: palette.text
+                font.pixelSize: 12
+            }
+        }
+    }
+
+    // Main flow area
+    ScrollView {
+        id: scrollView
+        anchors.top: headerPanel.bottom
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.bottom: parent.bottom
+
+        contentWidth: flow.width
+        contentHeight: flow.height
+
+        Flow {
+            id: flow
+
+            // flow: root.currentFlow
+
+            width: Math.max(root.width, 0)
+            height: Math.min(root.height, 0)
+        }
+    }
+}