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

sources/context/CMakeLists.txt

@@ -0,0 +1,29 @@
+add_library(Context STATIC
+    DocumentContextReader.hpp DocumentContextReader.cpp
+    ChangesManager.h ChangesManager.cpp
+    ContextManager.hpp ContextManager.cpp
+    ContentFile.hpp
+    DocumentReaderQtCreator.hpp
+    IDocumentReader.hpp
+    TokenUtils.hpp TokenUtils.cpp
+    ProgrammingLanguage.hpp ProgrammingLanguage.cpp
+    IContextManager.hpp
+    IgnoreManager.hpp IgnoreManager.cpp
+    ProjectUtils.hpp ProjectUtils.cpp
+    RulesLoader.hpp RulesLoader.cpp
+)
+
+target_link_libraries(Context
+    PUBLIC
+    Qt::Core
+    Qt::Gui
+    QtCreator::Core
+    QtCreator::TextEditor
+    QtCreator::Utils
+    QtCreator::ProjectExplorer
+    PRIVATE
+    QodeAssistLogger
+    QodeAssistSettings
+)
+
+target_include_directories(Context PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/sources)

sources/context/ChangesManager.h

@@ -0,0 +1,144 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <texteditor/textdocument.h>
+#include <QDateTime>
+#include <QHash>
+#include <QMutex>
+#include <QQueue>
+#include <QTimer>
+#include <QUndoStack>
+
+namespace QodeAssist::Context {
+
+class ChangesManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    struct ChangeInfo
+    {
+        QString fileName;
+        int lineNumber;
+        QString lineContent;
+    };
+
+    enum FileEditStatus { Pending, Applied, Rejected, Archived };
+
+    struct DiffHunk
+    {
+        int oldStartLine;       // Starting line in old file (1-based)
+        int oldLineCount;       // Number of lines in old file
+        int newStartLine;       // Starting line in new file (1-based)
+        int newLineCount;       // Number of lines in new file
+        QStringList contextBefore;  // Lines of context before the change (for anchoring)
+        QStringList removedLines;   // Lines to remove (prefixed with -)
+        QStringList addedLines;     // Lines to add (prefixed with +)
+        QStringList contextAfter;   // Lines of context after the change (for anchoring)
+    };
+
+    struct DiffInfo
+    {
+        QList<DiffHunk> hunks;       // List of diff hunks
+        QString originalContent;     // Full original file content (for fallback)
+        QString modifiedContent;     // Full modified file content (for fallback)
+        int contextLines = 3;        // Number of context lines to keep
+        bool useFallback = false;    // If true, use original content-based approach
+    };
+
+    struct FileEdit
+    {
+        QString editId;
+        QString filePath;
+        QString oldContent;      // Kept for backward compatibility and fallback
+        QString newContent;      // Kept for backward compatibility and fallback
+        DiffInfo diffInfo;       // Initial diff (created once, may become stale after formatting)
+        FileEditStatus status;
+        QDateTime timestamp;
+        bool wasAutoApplied = false;  // Track if edit was already auto-applied once
+        bool isFromHistory = false;   // Track if edit was loaded from chat history
+        QString statusMessage;
+    };
+
+    static ChangesManager &instance();
+
+    void addChange(
+        TextEditor::TextDocument *document, int position, int charsRemoved, int charsAdded);
+    QString getRecentChangesContext(const TextEditor::TextDocument *currentDocument) const;
+
+    void addFileEdit(
+        const QString &editId,
+        const QString &filePath,
+        const QString &oldContent,
+        const QString &newContent,
+        bool autoApply = true,
+        bool isFromHistory = false,
+        const QString &requestId = QString());
+    bool applyFileEdit(const QString &editId);
+    bool rejectFileEdit(const QString &editId);
+    bool undoFileEdit(const QString &editId);
+    FileEdit getFileEdit(const QString &editId) const;
+    QList<FileEdit> getPendingEdits() const;
+    
+    bool applyPendingEditsForRequest(const QString &requestId, QString *errorMsg = nullptr);
+    
+    QList<FileEdit> getEditsForRequest(const QString &requestId) const;
+    
+    bool undoAllEditsForRequest(const QString &requestId, QString *errorMsg = nullptr);
+    
+    bool reapplyAllEditsForRequest(const QString &requestId, QString *errorMsg = nullptr);
+    
+    void archiveAllNonArchivedEdits();
+
+signals:
+    void fileEditAdded(const QString &editId);
+    void fileEditApplied(const QString &editId);
+    void fileEditRejected(const QString &editId);
+    void fileEditUndone(const QString &editId);
+    void fileEditArchived(const QString &editId);
+
+private:
+    ChangesManager();
+    ~ChangesManager();
+    ChangesManager(const ChangesManager &) = delete;
+    ChangesManager &operator=(const ChangesManager &) = delete;
+
+    bool performFileEdit(const QString &filePath, const QString &oldContent, const QString &newContent, QString *errorMsg = nullptr);
+    bool performFileEditWithDiff(const QString &filePath, const DiffInfo &diffInfo, bool reverse, QString *errorMsg = nullptr);
+    QString readFileContent(const QString &filePath) const;
+    
+    DiffInfo createDiffInfo(const QString &originalContent, const QString &modifiedContent, const QString &filePath);
+    bool applyDiffToContent(QString &content, const DiffInfo &diffInfo, bool reverse, QString *errorMsg = nullptr);
+    bool findHunkLocation(const QStringList &fileLines, const DiffHunk &hunk, int &actualStartLine, QString *debugInfo = nullptr) const;
+    
+    // Helper method for fragment-based apply/undo operations
+    bool performFragmentReplacement(
+        const QString &filePath,
+        const QString &searchContent,
+        const QString &replaceContent,
+        bool isAppendOperation,
+        QString *errorMsg = nullptr,
+        bool isUndo = false);
+    
+    int levenshteinDistance(const QString &s1, const QString &s2) const;
+    QString findBestMatch(const QString &fileContent, const QString &searchContent, double threshold = 0.82, double *outSimilarity = nullptr) const;
+    QString findBestMatchLineBased(const QString &fileContent, const QString &searchContent, double threshold = 0.82, double *outSimilarity = nullptr) const;
+    QString findBestMatchWithNormalization(const QString &fileContent, const QString &searchContent, double *outSimilarity = nullptr, QString *outMatchType = nullptr) const;
+
+    struct RequestEdits
+    {
+        QStringList editIds;
+        bool autoApplyPending = false;
+    };
+
+    QHash<TextEditor::TextDocument *, QQueue<ChangeInfo>> m_documentChanges;
+    QHash<QString, FileEdit> m_fileEdits;
+    QHash<QString, RequestEdits> m_requestEdits;  // requestId → ordered edits
+    QUndoStack *m_undoStack;
+    mutable QMutex m_mutex;
+};
+
+} // namespace QodeAssist::Context

sources/context/ContentFile.hpp

@@ -0,0 +1,17 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QString>
+
+namespace QodeAssist::Context {
+
+struct ContentFile
+{
+    QString filename;
+    QString content;
+};
+
+} // namespace QodeAssist::Context

sources/context/ContextManager.cpp

@@ -0,0 +1,176 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "ContextManager.hpp"
+
+#include <QFile>
+#include <QFileInfo>
+#include <QJsonObject>
+#include <QTextStream>
+
+#include "settings/GeneralSettings.hpp"
+#include <coreplugin/editormanager/editormanager.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+#include <projectexplorer/projectnodes.h>
+#include <texteditor/textdocument.h>
+
+#include "Logger.hpp"
+
+namespace QodeAssist::Context {
+
+ContextManager::ContextManager(QObject *parent)
+    : QObject(parent)
+    , m_ignoreManager(new IgnoreManager(this))
+{}
+
+QString ContextManager::readFile(const QString &filePath) const
+{
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        LOG_MESSAGE(QString("Failed to open file for reading: %1 - %2")
+                        .arg(filePath, file.errorString()));
+        return QString();
+    }
+
+    QTextStream in(&file);
+    QString content = in.readAll();
+    file.close();
+    
+    return content;
+}
+
+QList<ContentFile> ContextManager::getContentFiles(const QStringList &filePaths) const
+{
+    QList<ContentFile> files;
+    for (const QString &path : filePaths) {
+        auto project = ProjectExplorer::ProjectManager::projectForFile(
+            Utils::FilePath::fromString(path));
+        if (project && m_ignoreManager->shouldIgnore(path, project)) {
+            LOG_MESSAGE(QString("Ignoring file in context due to .qodeassistignore: %1").arg(path));
+            continue;
+        }
+
+        ContentFile contentFile = createContentFile(path);
+        files.append(contentFile);
+    }
+    return files;
+}
+
+QStringList ContextManager::getProjectSourceFiles(ProjectExplorer::Project *project) const
+{
+    QStringList sourceFiles;
+    if (!project)
+        return sourceFiles;
+
+    auto projectNode = project->rootProjectNode();
+    if (!projectNode)
+        return sourceFiles;
+
+    projectNode->forEachNode(
+        [&sourceFiles, this](ProjectExplorer::FileNode *fileNode) {
+            if (fileNode /*&& shouldProcessFile(fileNode->filePath().toString())*/) {
+                sourceFiles.append(fileNode->filePath().toUrlishString());
+            }
+        },
+        nullptr);
+
+    return sourceFiles;
+}
+
+ContentFile ContextManager::createContentFile(const QString &filePath) const
+{
+    ContentFile contentFile;
+    QFileInfo fileInfo(filePath);
+    contentFile.filename = fileInfo.fileName();
+    contentFile.content = readFile(filePath);
+    return contentFile;
+}
+
+ProgrammingLanguage ContextManager::getDocumentLanguage(const DocumentInfo &documentInfo) const
+{
+    if (!documentInfo.document) {
+        LOG_MESSAGE("Error: Document is not available for" + documentInfo.filePath);
+        return Context::ProgrammingLanguage::Unknown;
+    }
+
+    return Context::ProgrammingLanguageUtils::fromMimeType(documentInfo.mimeType);
+}
+
+bool ContextManager::isSpecifyCompletion(const DocumentInfo &documentInfo) const
+{
+    const auto &generalSettings = Settings::generalSettings();
+
+    Context::ProgrammingLanguage documentLanguage = getDocumentLanguage(documentInfo);
+    Context::ProgrammingLanguage preset1Language = Context::ProgrammingLanguageUtils::fromString(
+        generalSettings.preset1Language.displayForIndex(generalSettings.preset1Language()));
+
+    return generalSettings.specifyPreset1() && documentLanguage == preset1Language;
+}
+
+QList<QPair<QString, QString>> ContextManager::openedFiles(const QStringList excludeFiles) const
+{
+    auto documents = Core::DocumentModel::openedDocuments();
+
+    QList<QPair<QString, QString>> files;
+
+    for (const auto *document : std::as_const(documents)) {
+        auto textDocument = qobject_cast<const TextEditor::TextDocument *>(document);
+        if (!textDocument)
+            continue;
+
+        auto filePath = textDocument->filePath().toUrlishString();
+
+        auto project = ProjectExplorer::ProjectManager::projectForFile(textDocument->filePath());
+        if (project && m_ignoreManager->shouldIgnore(filePath, project)) {
+            LOG_MESSAGE(
+                QString("Ignoring file in context due to .qodeassistignore: %1").arg(filePath));
+            continue;
+        }
+
+        if (!excludeFiles.contains(filePath)) {
+            files.append({filePath, textDocument->plainText()});
+        }
+    }
+
+    return files;
+}
+
+QString ContextManager::openedFilesContext(const QStringList excludeFiles)
+{
+    QString context = "User files context:\n";
+
+    auto documents = Core::DocumentModel::openedDocuments();
+
+    for (const auto *document : documents) {
+        auto textDocument = qobject_cast<const TextEditor::TextDocument *>(document);
+        if (!textDocument)
+            continue;
+
+        auto filePath = textDocument->filePath().toUrlishString();
+        if (excludeFiles.contains(filePath))
+            continue;
+
+        auto project = ProjectExplorer::ProjectManager::projectForFile(textDocument->filePath());
+        if (project && m_ignoreManager->shouldIgnore(filePath, project)) {
+            LOG_MESSAGE(
+                QString("Ignoring file in context due to .qodeassistignore: %1").arg(filePath));
+            continue;
+        }
+
+        context += QString("File: %1\n").arg(filePath);
+        context += textDocument->plainText();
+
+        context += "\n";
+    }
+
+    return context;
+}
+
+IgnoreManager *ContextManager::ignoreManager() const
+{
+    return m_ignoreManager;
+}
+
+} // namespace QodeAssist::Context

sources/context/ContextManager.hpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+
+#include "ContentFile.hpp"
+#include "IContextManager.hpp"
+#include "IgnoreManager.hpp"
+#include "ProgrammingLanguage.hpp"
+
+namespace ProjectExplorer {
+class Project;
+}
+
+namespace QodeAssist::Context {
+
+class ContextManager : public QObject, public IContextManager
+{
+    Q_OBJECT
+
+public:
+    explicit ContextManager(QObject *parent = nullptr);
+    ~ContextManager() override = default;
+
+    QString readFile(const QString &filePath) const override;
+    QList<ContentFile> getContentFiles(const QStringList &filePaths) const override;
+    QStringList getProjectSourceFiles(ProjectExplorer::Project *project) const override;
+    ContentFile createContentFile(const QString &filePath) const override;
+
+    ProgrammingLanguage getDocumentLanguage(const DocumentInfo &documentInfo) const override;
+    bool isSpecifyCompletion(const DocumentInfo &documentInfo) const override;
+    QList<QPair<QString, QString>> openedFiles(const QStringList excludeFiles = QStringList{}) const;
+    QString openedFilesContext(const QStringList excludeFiles = QStringList{});
+
+    IgnoreManager *ignoreManager() const;
+
+private:
+    IgnoreManager *m_ignoreManager;
+};
+
+} // namespace QodeAssist::Context

sources/context/DocumentContextReader.cpp

@@ -0,0 +1,284 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "DocumentContextReader.hpp"
+
+#include <languageserverprotocol/lsptypes.h>
+#include <QFileInfo>
+#include <QTextBlock>
+
+#include "CodeCompletionSettings.hpp"
+
+#include "ChangesManager.h"
+
+const QRegularExpression &getYearRegex()
+{
+    static const QRegularExpression yearRegex("\\b(19|20)\\d{2}\\b");
+    return yearRegex;
+}
+
+const QRegularExpression &getNameRegex()
+{
+    static const QRegularExpression nameRegex("\\b[A-Z][a-z.]+ [A-Z][a-z.]+\\b");
+    return nameRegex;
+}
+
+const QRegularExpression &getCommentRegex()
+{
+    static const QRegularExpression commentRegex(
+        R"((/\*[\s\S]*?\*/|//.*$|#.*$|//{2,}[\s\S]*?//{2,}))", QRegularExpression::MultilineOption);
+    return commentRegex;
+}
+
+namespace QodeAssist::Context {
+
+DocumentContextReader::DocumentContextReader(
+    QTextDocument *document, const QString &mimeType, const QString &filePath)
+    : m_document(document)
+    , m_mimeType(mimeType)
+    , m_filePath(filePath)
+{
+    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 startLine = lineNumber - linesCount + 1;
+    if (m_copyrightInfo.found) {
+        startLine = qMax(m_copyrightInfo.endLine + 1, startLine);
+    }
+
+    return getContextBetween(startLine, -1, lineNumber, cursorPosition);
+}
+
+QString DocumentContextReader::getContextAfter(
+    int lineNumber, int cursorPosition, int linesCount) const
+{
+    int endLine = lineNumber + linesCount - 1;
+    if (m_copyrightInfo.found && m_copyrightInfo.endLine >= lineNumber) {
+        lineNumber = m_copyrightInfo.endLine + 1;
+        cursorPosition = -1;
+    }
+    return getContextBetween(lineNumber, cursorPosition, endLine, -1);
+}
+
+QString DocumentContextReader::readWholeFileBefore(int lineNumber, int cursorPosition) const
+{
+    int startLine = 0;
+    if (m_copyrightInfo.found) {
+        startLine = m_copyrightInfo.endLine + 1;
+    }
+
+    return getContextBetween(startLine, -1, lineNumber, cursorPosition);
+}
+
+QString DocumentContextReader::readWholeFileAfter(int lineNumber, int cursorPosition) const
+{
+    int endLine = m_document->blockCount() - 1;
+    if (m_copyrightInfo.found && m_copyrightInfo.endLine >= lineNumber) {
+        lineNumber = m_copyrightInfo.endLine + 1;
+        cursorPosition = -1;
+    }
+    return getContextBetween(lineNumber, cursorPosition, endLine, -1);
+}
+
+QString DocumentContextReader::getLanguageAndFileInfo() const
+{
+    QString language = LanguageServerProtocol::TextDocumentItem::mimeTypeToLanguageId(m_mimeType);
+    QString fileExtension = QFileInfo(m_filePath).suffix();
+
+    return QString("Language: %1 (MIME: %2) filepath: %3(%4)\n\n")
+        .arg(language, m_mimeType, m_filePath, fileExtension);
+}
+
+CopyrightInfo DocumentContextReader::findCopyright()
+{
+    CopyrightInfo result = {-1, -1, false};
+
+    QString text = m_document->toPlainText();
+    QRegularExpressionMatchIterator matchIterator = getCommentRegex().globalMatch(text);
+
+    QList<CopyrightInfo> copyrightBlocks;
+
+    while (matchIterator.hasNext()) {
+        QRegularExpressionMatch match = matchIterator.next();
+        QString matchedText = match.captured().toLower();
+
+        bool hasCopyrightIndicator = matchedText.contains("copyright")
+                                     || matchedText.contains("(c)") || matchedText.contains("©")
+                                     || matchedText.contains("copr.")
+                                     || matchedText.contains("all rights reserved")
+                                     || matchedText.contains("proprietary")
+                                     || matchedText.contains("licensed under")
+                                     || matchedText.contains("license:")
+                                     || matchedText.contains("gpl") || matchedText.contains("lgpl")
+                                     || matchedText.contains("mit license")
+                                     || matchedText.contains("apache license")
+                                     || matchedText.contains("bsd license")
+                                     || matchedText.contains("mozilla public license")
+                                     || matchedText.contains("copyleft");
+
+        bool hasYear = getYearRegex().match(matchedText).hasMatch();
+        bool hasName = getNameRegex().match(matchedText).hasMatch();
+
+        if ((hasCopyrightIndicator && (hasYear || hasName)) || (hasYear && hasName)) {
+            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 startCursorPosition, int endLine, int endCursorPosition) const
+{
+    QString context;
+
+    startLine = qMax(startLine, 0);
+    endLine = qMin(endLine, m_document->blockCount() - 1);
+
+    if (startLine > endLine) {
+        return context;
+    }
+
+    if (startLine == endLine) {
+        auto block = m_document->findBlockByNumber(startLine);
+        if (!block.isValid()) {
+            return context;
+        }
+
+        auto text = block.text();
+
+        if (startCursorPosition < 0) {
+            startCursorPosition = 0;
+        }
+        if (endCursorPosition < 0) {
+            endCursorPosition = text.size();
+        }
+
+        if (startCursorPosition >= endCursorPosition) {
+            return context;
+        }
+
+        return text.mid(startCursorPosition, endCursorPosition - startCursorPosition);
+    }
+
+    // first line
+    {
+        auto block = m_document->findBlockByNumber(startLine);
+        if (!block.isValid()) {
+            return context;
+        }
+        auto text = block.text();
+        if (startCursorPosition < 0) {
+            context += text + "\n";
+        } else {
+            context += text.right(text.size() - startCursorPosition) + "\n";
+        }
+    }
+
+    // intermediate lines, if any
+    for (int i = startLine + 1; i <= endLine - 1; ++i) {
+        auto block = m_document->findBlockByNumber(i);
+        if (!block.isValid()) {
+            return context;
+        }
+        context += block.text() + "\n";
+    }
+
+    // last line
+    {
+        auto block = m_document->findBlockByNumber(endLine);
+        if (!block.isValid()) {
+            return context;
+        }
+        auto text = block.text();
+        if (endCursorPosition < 0) {
+            context += text;
+        } else {
+            context += text.left(endCursorPosition);
+        }
+    }
+
+    return context;
+}
+
+CopyrightInfo DocumentContextReader::copyrightInfo() const
+{
+    return m_copyrightInfo;
+}
+
+LLMCore::ContextData DocumentContextReader::prepareContext(
+    int lineNumber, int cursorPosition, const Settings::CodeCompletionSettings &settings) const
+{
+    QString contextBefore;
+    QString contextAfter;
+    if (settings.readFullFile()) {
+        contextBefore = readWholeFileBefore(lineNumber, cursorPosition);
+        contextAfter = readWholeFileAfter(lineNumber, cursorPosition);
+    } else {
+        // Note that readStrings{After,Before}Cursor include current line, but linesCount argument of
+        // getContext{After,Before} do not
+        contextBefore
+            = getContextBefore(lineNumber, cursorPosition, settings.readStringsBeforeCursor() + 1);
+        contextAfter
+            = getContextAfter(lineNumber, cursorPosition, settings.readStringsAfterCursor() + 1);
+    }
+
+    QString fileContext;
+    fileContext.append("\n ").append(getLanguageAndFileInfo());
+
+    if (settings.useProjectChangesCache())
+        fileContext.append("Recent Project Changes Context:\n ")
+            .append(ChangesManager::instance().getRecentChangesContext(m_textDocument));
+
+    return {.prefix = contextBefore, .suffix = contextAfter, .fileContext = fileContext};
+}
+
+} // namespace QodeAssist::Context

sources/context/DocumentContextReader.hpp

@@ -0,0 +1,77 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <texteditor/textdocument.h>
+#include <QTextDocument>
+
+#include "llmcore/ContextData.hpp"
+#include <settings/CodeCompletionSettings.hpp>
+
+namespace QodeAssist::Context {
+
+struct CopyrightInfo
+{
+    int startLine;
+    int endLine;
+    bool found;
+};
+
+class DocumentContextReader
+{
+public:
+    DocumentContextReader(
+        QTextDocument *m_document, const QString &mimeType, const QString &filePath);
+
+    QString getLineText(int lineNumber, int cursorPosition = -1) const;
+
+    /**
+     * @brief Retrieves @c linesCount lines of context ending at @c lineNumber at
+     * @c cursorPosition in that line. The line at @c lineNumber is inclusive regardless of
+     * @c cursorPosition.
+     */
+    QString getContextBefore(int lineNumber, int cursorPosition, int linesCount) const;
+
+    /**
+     * @brief Retrieves @c linesCount lines of context starting at @c lineNumber at
+     * @c cursorPosition in that line. The line at @c lineNumber is inclusive regardless of
+     * @c cursorPosition.
+     */
+    QString getContextAfter(int lineNumber, int cursorPosition, int linesCount) const;
+
+    /**
+     * @brief Retrieves whole file ending at @c lineNumber at @c cursorPosition in that line.
+     */
+    QString readWholeFileBefore(int lineNumber, int cursorPosition) const;
+
+    /**
+     * @brief Retrieves whole file starting at @c lineNumber at @c cursorPosition in that line.
+     */
+    QString readWholeFileAfter(int lineNumber, int cursorPosition) const;
+
+    QString getLanguageAndFileInfo() const;
+    CopyrightInfo findCopyright();
+    QString getContextBetween(
+        int startLine, int startCursorPosition, int endLine, int endCursorPosition) const;
+
+    CopyrightInfo copyrightInfo() const;
+
+    LLMCore::ContextData prepareContext(
+        int lineNumber, int cursorPosition, const Settings::CodeCompletionSettings &settings) const;
+
+private:
+    TextEditor::TextDocument *m_textDocument;
+    QTextDocument *m_document;
+    QString m_mimeType;
+    QString m_filePath;
+
+    // Used to omit copyright headers from context. If context would otherwise include copyright
+    // header it is excluded by deleting it from the returned context. This means, that the
+    // returned context may contain less information than requested. If the cursor is within copyright
+    // header, then the context may be empty if the context window is small.
+    CopyrightInfo m_copyrightInfo;
+};
+
+} // namespace QodeAssist::Context

sources/context/DocumentReaderQtCreator.hpp

@@ -0,0 +1,30 @@
+// Copyright (C) 2025 Povilas Kanapickas
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include "IDocumentReader.hpp"
+
+#include <texteditor/textdocument.h>
+
+namespace QodeAssist::Context {
+
+class DocumentReaderQtCreator : public IDocumentReader
+{
+public:
+    DocumentInfo readDocument(const QString &path) const override
+    {
+        auto *textDocument = TextEditor::TextDocument::textDocumentForFilePath(
+            Utils::FilePath::fromString(path));
+        if (!textDocument) {
+            return {};
+        }
+        return {
+            .document = textDocument->document(),
+            .mimeType = textDocument->mimeType(),
+            .filePath = path};
+    }
+};
+
+} // namespace QodeAssist::Context

sources/context/IContextManager.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+
+#include "ContentFile.hpp"
+#include "IDocumentReader.hpp"
+#include "ProgrammingLanguage.hpp"
+
+namespace ProjectExplorer {
+class Project;
+}
+
+namespace QodeAssist::Context {
+
+class IContextManager
+{
+public:
+    virtual ~IContextManager() = default;
+
+    virtual QString readFile(const QString &filePath) const = 0;
+    virtual QList<ContentFile> getContentFiles(const QStringList &filePaths) const = 0;
+    virtual QStringList getProjectSourceFiles(ProjectExplorer::Project *project) const = 0;
+    virtual ContentFile createContentFile(const QString &filePath) const = 0;
+
+    virtual ProgrammingLanguage getDocumentLanguage(const DocumentInfo &documentInfo) const = 0;
+    virtual bool isSpecifyCompletion(const DocumentInfo &documentInfo) const = 0;
+};
+
+} // namespace QodeAssist::Context

sources/context/IDocumentReader.hpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2025 Povilas Kanapickas
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QTextDocument>
+
+namespace QodeAssist::Context {
+
+struct DocumentInfo
+{
+    QTextDocument *document = nullptr; // not owned
+    QString mimeType;
+    QString filePath;
+};
+
+class IDocumentReader
+{
+public:
+    virtual ~IDocumentReader() = default;
+
+    virtual DocumentInfo readDocument(const QString &path) const = 0;
+};
+
+} // namespace QodeAssist::Context

sources/context/IgnoreManager.cpp

@@ -0,0 +1,259 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "IgnoreManager.hpp"
+
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+#include <QCoreApplication>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QRegularExpression>
+#include <QTextStream>
+
+#include "logger/Logger.hpp"
+
+namespace QodeAssist::Context {
+
+IgnoreManager::IgnoreManager(QObject *parent)
+    : QObject(parent)
+{
+    auto projectManager = ProjectExplorer::ProjectManager::instance();
+    if (projectManager) {
+        connect(
+            projectManager,
+            &ProjectExplorer::ProjectManager::projectRemoved,
+            this,
+            &IgnoreManager::removeIgnorePatterns);
+    }
+
+    connect(
+        QCoreApplication::instance(),
+        &QCoreApplication::aboutToQuit,
+        this,
+        &IgnoreManager::cleanupConnections);
+}
+
+IgnoreManager::~IgnoreManager()
+{
+    cleanupConnections();
+}
+
+void IgnoreManager::cleanupConnections()
+{
+    QList<ProjectExplorer::Project *> projects = m_projectConnections.keys();
+    for (ProjectExplorer::Project *project : projects) {
+        if (project) {
+            disconnect(m_projectConnections.take(project));
+        }
+    }
+    m_projectConnections.clear();
+    m_projectIgnorePatterns.clear();
+    m_ignoreCache.clear();
+}
+
+bool IgnoreManager::shouldIgnore(const QString &filePath, ProjectExplorer::Project *project) const
+{
+    if (!project)
+        return false;
+
+    if (!m_projectIgnorePatterns.contains(project)) {
+        const_cast<IgnoreManager *>(this)->reloadIgnorePatterns(project);
+    }
+
+    const QStringList &patterns = m_projectIgnorePatterns[project];
+    if (patterns.isEmpty())
+        return false;
+
+    QDir projectDir(project->projectDirectory().toUrlishString());
+    QString relativePath = projectDir.relativeFilePath(filePath);
+
+    return matchesIgnorePatterns(relativePath, patterns);
+}
+
+bool IgnoreManager::matchesIgnorePatterns(const QString &path, const QStringList &patterns) const
+{
+    QString cacheKey = path + ":" + patterns.join("|");
+    if (m_ignoreCache.contains(cacheKey))
+        return m_ignoreCache[cacheKey];
+
+    bool result = isPathExcluded(path, patterns);
+    m_ignoreCache.insert(cacheKey, result);
+    return result;
+}
+
+bool IgnoreManager::isPathExcluded(const QString &path, const QStringList &patterns) const
+{
+    bool excluded = false;
+
+    for (const QString &pattern : patterns) {
+        if (pattern.isEmpty() || pattern.startsWith('#'))
+            continue;
+
+        bool isNegative = pattern.startsWith('!');
+        QString actualPattern = isNegative ? pattern.mid(1) : pattern;
+
+        bool matches = matchPathWithPattern(path, actualPattern);
+
+        if (matches) {
+            excluded = !isNegative;
+        }
+    }
+
+    return excluded;
+}
+
+bool IgnoreManager::matchPathWithPattern(const QString &path, const QString &pattern) const
+{
+    QString adjustedPattern = pattern.trimmed();
+
+    bool matchFromRoot = adjustedPattern.startsWith('/');
+    if (matchFromRoot)
+        adjustedPattern = adjustedPattern.mid(1);
+
+    bool matchDirOnly = adjustedPattern.endsWith('/');
+    if (matchDirOnly)
+        adjustedPattern.chop(1);
+
+    QString regexPattern = QRegularExpression::escape(adjustedPattern);
+
+    regexPattern.replace("\\*\\*", ".*");
+
+    regexPattern.replace("\\*", "[^/]*");
+
+    regexPattern.replace("\\?", ".");
+
+    if (matchFromRoot)
+        regexPattern = QString("^%1").arg(regexPattern);
+    else
+        regexPattern = QString("(^|/)%1").arg(regexPattern);
+
+    if (matchDirOnly)
+        regexPattern = QString("%1$").arg(regexPattern);
+    else
+        regexPattern = QString("%1($|/)").arg(regexPattern);
+
+    QRegularExpression regex(regexPattern);
+    QRegularExpressionMatch match = regex.match(path);
+    return match.hasMatch();
+}
+
+QStringList IgnoreManager::loadIgnorePatterns(ProjectExplorer::Project *project)
+{
+    QStringList patterns;
+    if (!project)
+        return patterns;
+
+    QString ignoreFile = ignoreFilePath(project);
+    if (ignoreFile.isEmpty() || !QFile::exists(ignoreFile)) {
+        // LOG_MESSAGE(
+        //     QString("No .qodeassistignore file found for project: %1").arg(project->displayName()));
+        return patterns;
+    }
+
+    QFile file(ignoreFile);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        LOG_MESSAGE(QString("Could not open .qodeassistignore file: %1").arg(ignoreFile));
+        return patterns;
+    }
+
+    QTextStream in(&file);
+    while (!in.atEnd()) {
+        QString line = in.readLine().trimmed();
+        if (!line.isEmpty() && !line.startsWith('#'))
+            patterns << line;
+    }
+
+    LOG_MESSAGE(QString("Successfully loaded .qodeassistignore file: %1 with %2 patterns")
+                    .arg(ignoreFile)
+                    .arg(patterns.size()));
+
+    return patterns;
+}
+
+void IgnoreManager::reloadIgnorePatterns(ProjectExplorer::Project *project)
+{
+    if (!project)
+        return;
+
+    QStringList patterns = loadIgnorePatterns(project);
+    m_projectIgnorePatterns[project] = patterns;
+
+    QStringList keysToRemove;
+    QString projectPath = project->projectDirectory().toUrlishString();
+    for (auto it = m_ignoreCache.begin(); it != m_ignoreCache.end(); ++it) {
+        if (it.key().contains(projectPath))
+            keysToRemove << it.key();
+    }
+
+    for (const QString &key : keysToRemove)
+        m_ignoreCache.remove(key);
+
+    if (!m_projectConnections.contains(project)) {
+        QPointer<ProjectExplorer::Project> projectPtr(project);
+        auto connection = connect(project, &QObject::destroyed, this, [this, projectPtr]() {
+            if (projectPtr) {
+                m_projectIgnorePatterns.remove(projectPtr);
+                m_projectConnections.remove(projectPtr);
+
+                QStringList keysToRemove;
+                for (auto it = m_ignoreCache.begin(); it != m_ignoreCache.end(); ++it) {
+                    if (it.key().contains(projectPtr->projectDirectory().toUrlishString()))
+                        keysToRemove << it.key();
+                }
+
+                for (const QString &key : keysToRemove)
+                    m_ignoreCache.remove(key);
+            }
+        });
+
+        m_projectConnections[project] = connection;
+    }
+}
+
+void IgnoreManager::removeIgnorePatterns(ProjectExplorer::Project *project)
+{
+    m_projectIgnorePatterns.remove(project);
+
+    QStringList keysToRemove;
+    for (auto it = m_ignoreCache.begin(); it != m_ignoreCache.end(); ++it) {
+        if (it.key().contains(project->projectDirectory().toUrlishString()))
+            keysToRemove << it.key();
+    }
+
+    for (const QString &key : keysToRemove)
+        m_ignoreCache.remove(key);
+
+    if (m_projectConnections.contains(project)) {
+        disconnect(m_projectConnections[project]);
+        m_projectConnections.remove(project);
+    }
+
+    LOG_MESSAGE(QString("Removed ignore patterns for project: %1").arg(project->displayName()));
+}
+
+void IgnoreManager::reloadAllPatterns()
+{
+    QList<ProjectExplorer::Project *> projects = m_projectIgnorePatterns.keys();
+
+    for (ProjectExplorer::Project *project : projects) {
+        if (project) {
+            reloadIgnorePatterns(project);
+        }
+    }
+
+    m_ignoreCache.clear();
+}
+
+QString IgnoreManager::ignoreFilePath(ProjectExplorer::Project *project) const
+{
+    if (!project) {
+        return QString();
+    }
+
+    return project->projectDirectory().toUrlishString() + "/.qodeassistignore";
+}
+
+} // namespace QodeAssist::Context

sources/context/IgnoreManager.hpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QHash>
+#include <QObject>
+#include <QPointer>
+#include <QStringList>
+
+namespace ProjectExplorer {
+class Project;
+}
+
+namespace QodeAssist::Context {
+
+class IgnoreManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit IgnoreManager(QObject *parent = nullptr);
+    ~IgnoreManager() override;
+
+    bool shouldIgnore(const QString &filePath, ProjectExplorer::Project *project = nullptr) const;
+    void reloadIgnorePatterns(ProjectExplorer::Project *project);
+    void removeIgnorePatterns(ProjectExplorer::Project *project);
+
+    void reloadAllPatterns();
+
+private slots:
+    void cleanupConnections();
+
+private:
+    bool matchesIgnorePatterns(const QString &path, const QStringList &patterns) const;
+    bool isPathExcluded(const QString &path, const QStringList &patterns) const;
+    bool matchPathWithPattern(const QString &path, const QString &pattern) const;
+    QStringList loadIgnorePatterns(ProjectExplorer::Project *project);
+    QString ignoreFilePath(ProjectExplorer::Project *project) const;
+
+    QHash<ProjectExplorer::Project *, QStringList> m_projectIgnorePatterns;
+    mutable QHash<QString, bool> m_ignoreCache;
+    QHash<ProjectExplorer::Project *, QMetaObject::Connection> m_projectConnections;
+};
+
+} // namespace QodeAssist::Context

sources/context/ProgrammingLanguage.cpp

@@ -0,0 +1,55 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "ProgrammingLanguage.hpp"
+
+namespace QodeAssist::Context {
+
+ProgrammingLanguage ProgrammingLanguageUtils::fromMimeType(const QString &mimeType)
+{
+    if (mimeType == "text/x-qml" || mimeType == "application/javascript"
+        || mimeType == "text/javascript" || mimeType == "text/x-javascript") {
+        return ProgrammingLanguage::QML;
+    }
+    if (mimeType == "text/x-c++src" || mimeType == "text/x-c++hdr" || mimeType == "text/x-csrc"
+        || mimeType == "text/x-chdr") {
+        return ProgrammingLanguage::Cpp;
+    }
+    if (mimeType == "text/x-python") {
+        return ProgrammingLanguage::Python;
+    }
+    return ProgrammingLanguage::Unknown;
+}
+
+QString ProgrammingLanguageUtils::toString(ProgrammingLanguage language)
+{
+    switch (language) {
+    case ProgrammingLanguage::Cpp:
+        return "c/c++";
+    case ProgrammingLanguage::QML:
+        return "qml";
+    case ProgrammingLanguage::Python:
+        return "python";
+    case ProgrammingLanguage::Unknown:
+    default:
+        return QString();
+    }
+}
+
+ProgrammingLanguage ProgrammingLanguageUtils::fromString(const QString &str)
+{
+    QString lower = str.toLower();
+    if (lower == "c/c++") {
+        return ProgrammingLanguage::Cpp;
+    }
+    if (lower == "qml") {
+        return ProgrammingLanguage::QML;
+    }
+    if (lower == "python") {
+        return ProgrammingLanguage::Python;
+    }
+    return ProgrammingLanguage::Unknown;
+}
+
+} // namespace QodeAssist::Context

sources/context/ProgrammingLanguage.hpp

@@ -0,0 +1,28 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QString>
+
+namespace QodeAssist::Context {
+
+enum class ProgrammingLanguage {
+    QML, // QML/JavaScript
+    Cpp, // C/C++
+    Python,
+    Unknown,
+};
+
+namespace ProgrammingLanguageUtils {
+
+ProgrammingLanguage fromMimeType(const QString &mimeType);
+
+QString toString(ProgrammingLanguage language);
+
+ProgrammingLanguage fromString(const QString &str);
+
+} // namespace ProgrammingLanguageUtils
+
+} // namespace QodeAssist::Context

sources/context/ProjectUtils.cpp

@@ -0,0 +1,71 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "ProjectUtils.hpp"
+
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+#include <utils/filepath.h>
+
+namespace QodeAssist::Context {
+
+bool ProjectUtils::isFileInProject(const QString &filePath)
+{
+    QList<ProjectExplorer::Project *> projects = ProjectExplorer::ProjectManager::projects();
+    Utils::FilePath targetPath = Utils::FilePath::fromString(filePath);
+
+    for (auto project : projects) {
+        if (!project)
+            continue;
+
+        Utils::FilePaths projectFiles = project->files(ProjectExplorer::Project::SourceFiles);
+        for (const auto &projectFile : std::as_const(projectFiles)) {
+            if (projectFile == targetPath) {
+                return true;
+            }
+        }
+
+        Utils::FilePath projectDir = project->projectDirectory();
+        if (targetPath.isChildOf(projectDir)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+QString ProjectUtils::findFileInProject(const QString &filename)
+{
+    QList<ProjectExplorer::Project *> projects = ProjectExplorer::ProjectManager::projects();
+
+    for (auto project : projects) {
+        if (!project)
+            continue;
+
+        Utils::FilePaths projectFiles = project->files(ProjectExplorer::Project::SourceFiles);
+        for (const auto &projectFile : std::as_const(projectFiles)) {
+            if (projectFile.fileName() == filename) {
+                return projectFile.toFSPathString();
+            }
+        }
+    }
+
+    return QString();
+}
+
+QString ProjectUtils::getProjectRoot()
+{
+    QList<ProjectExplorer::Project *> projects = ProjectExplorer::ProjectManager::projects();
+
+    if (!projects.isEmpty()) {
+        auto project = projects.first();
+        if (project) {
+            return project->projectDirectory().toFSPathString();
+        }
+    }
+
+    return QString();
+}
+
+} // namespace QodeAssist::Context

sources/context/ProjectUtils.hpp

@@ -0,0 +1,51 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QString>
+
+namespace QodeAssist::Context {
+
+/**
+ * @brief Utility functions for working with Qt Creator projects
+ */
+class ProjectUtils
+{
+public:
+    /**
+     * @brief Check if a file is part of any open project
+     * 
+     * Checks if the given file path is either:
+     * 1. Explicitly listed in project source files
+     * 2. Located within a project directory
+     * 
+     * @param filePath Absolute or canonical file path to check
+     * @return true if file is part of any open project, false otherwise
+     */
+    static bool isFileInProject(const QString &filePath);
+
+    /**
+     * @brief Find a file in open projects by filename
+     * 
+     * Searches all open projects for a file matching the given filename.
+     * If multiple files with the same name exist, returns the first match.
+     * 
+     * @param filename File name to search for (e.g., "main.cpp")
+     * @return Absolute file path if found, empty string otherwise
+     */
+    static QString findFileInProject(const QString &filename);
+
+    /**
+     * @brief Get the project root directory
+     * 
+     * Returns the root directory of the first open project.
+     * If multiple projects are open, returns the first one.
+     * 
+     * @return Absolute path to project root, or empty string if no project is open
+     */
+    static QString getProjectRoot();
+};
+
+} // namespace QodeAssist::Context

sources/context/RulesLoader.cpp

@@ -0,0 +1,166 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "context/RulesLoader.hpp"
+
+#include <QDir>
+#include <QFile>
+
+#include <coreplugin/editormanager/editormanager.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+
+namespace QodeAssist::Context {
+
+QString RulesLoader::loadRules(const QString &projectPath, RulesContext context)
+{
+    if (projectPath.isEmpty()) {
+        return QString();
+    }
+
+    QString combined;
+    QString basePath = projectPath + "/.qodeassist/rules";
+
+    switch (context) {
+    case RulesContext::Completions:
+        combined += loadAllMarkdownFiles(basePath + "/completions");
+        break;
+    case RulesContext::Chat:
+        combined += loadAllMarkdownFiles(basePath + "/common");
+        combined += loadAllMarkdownFiles(basePath + "/chat");
+        break;
+    case RulesContext::QuickRefactor:
+        combined += loadAllMarkdownFiles(basePath + "/common");
+        combined += loadAllMarkdownFiles(basePath + "/quickrefactor");
+        break;
+    }
+
+    return combined;
+}
+
+QString RulesLoader::loadRulesForProject(ProjectExplorer::Project *project, RulesContext context)
+{
+    if (!project) {
+        return QString();
+    }
+
+    QString projectPath = getProjectPath(project);
+    return loadRules(projectPath, context);
+}
+
+ProjectExplorer::Project *RulesLoader::getActiveProject()
+{
+    auto currentEditor = Core::EditorManager::currentEditor();
+    if (currentEditor && currentEditor->document()) {
+        Utils::FilePath filePath = currentEditor->document()->filePath();
+        auto project = ProjectExplorer::ProjectManager::projectForFile(filePath);
+        if (project) {
+            return project;
+        }
+    }
+
+    return ProjectExplorer::ProjectManager::startupProject();
+}
+
+QString RulesLoader::loadAllMarkdownFiles(const QString &dirPath)
+{
+    QString combined;
+    QDir dir(dirPath);
+
+    if (!dir.exists()) {
+        return QString();
+    }
+
+    QStringList mdFiles = dir.entryList({"*.md"}, QDir::Files, QDir::Name);
+
+    for (const QString &fileName : mdFiles) {
+        QFile file(dir.filePath(fileName));
+        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            combined += file.readAll();
+            combined += "\n\n";
+        }
+    }
+
+    return combined;
+}
+
+QString RulesLoader::getProjectPath(ProjectExplorer::Project *project)
+{
+    if (!project) {
+        return QString();
+    }
+
+    return project->projectDirectory().toUrlishString();
+}
+
+QVector<RuleFileInfo> RulesLoader::getRuleFiles(const QString &projectPath, RulesContext context)
+{
+    if (projectPath.isEmpty()) {
+        return QVector<RuleFileInfo>();
+    }
+
+    QVector<RuleFileInfo> result;
+    QString basePath = projectPath + "/.qodeassist/rules";
+
+    // Always include common rules
+    result.append(collectMarkdownFiles(basePath + "/common", "common"));
+
+    // Add context-specific rules
+    switch (context) {
+    case RulesContext::Completions:
+        result.append(collectMarkdownFiles(basePath + "/completions", "completions"));
+        break;
+    case RulesContext::Chat:
+        result.append(collectMarkdownFiles(basePath + "/chat", "chat"));
+        break;
+    case RulesContext::QuickRefactor:
+        result.append(collectMarkdownFiles(basePath + "/quickrefactor", "quickrefactor"));
+        break;
+    }
+
+    return result;
+}
+
+QVector<RuleFileInfo> RulesLoader::getRuleFilesForProject(
+    ProjectExplorer::Project *project, RulesContext context)
+{
+    if (!project) {
+        return QVector<RuleFileInfo>();
+    }
+
+    QString projectPath = getProjectPath(project);
+    return getRuleFiles(projectPath, context);
+}
+
+QString RulesLoader::loadRuleFileContent(const QString &filePath)
+{
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return QString();
+    }
+
+    return file.readAll();
+}
+
+QVector<RuleFileInfo> RulesLoader::collectMarkdownFiles(
+    const QString &dirPath, const QString &category)
+{
+    QVector<RuleFileInfo> result;
+    QDir dir(dirPath);
+
+    if (!dir.exists()) {
+        return result;
+    }
+
+    QStringList mdFiles = dir.entryList({"*.md"}, QDir::Files, QDir::Name);
+
+    for (const QString &fileName : mdFiles) {
+        QString fullPath = dir.filePath(fileName);
+        result.append({fullPath, fileName, category});
+    }
+
+    return result;
+}
+
+} // namespace QodeAssist::Context

sources/context/RulesLoader.hpp

@@ -0,0 +1,42 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QString>
+
+namespace ProjectExplorer {
+class Project;
+}
+
+namespace QodeAssist::Context {
+
+enum class RulesContext { Completions, Chat, QuickRefactor };
+
+struct RuleFileInfo
+{
+    QString filePath;
+    QString fileName;
+    QString category; // "common", "chat", "completions", "quickrefactor"
+};
+
+class RulesLoader
+{
+public:
+    static QString loadRules(const QString &projectPath, RulesContext context);
+    static QString loadRulesForProject(ProjectExplorer::Project *project, RulesContext context);
+    static ProjectExplorer::Project *getActiveProject();
+    
+    // New methods for getting rule files info
+    static QVector<RuleFileInfo> getRuleFiles(const QString &projectPath, RulesContext context);
+    static QVector<RuleFileInfo> getRuleFilesForProject(ProjectExplorer::Project *project, RulesContext context);
+    static QString loadRuleFileContent(const QString &filePath);
+
+private:
+    static QString loadAllMarkdownFiles(const QString &dirPath);
+    static QVector<RuleFileInfo> collectMarkdownFiles(const QString &dirPath, const QString &category);
+    static QString getProjectPath(ProjectExplorer::Project *project);
+};
+
+} // namespace QodeAssist::Context

sources/context/TokenUtils.cpp

@@ -0,0 +1,87 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#include "TokenUtils.hpp"
+
+#include <QFileInfo>
+#include <QImageReader>
+#include <QSet>
+#include <QSize>
+
+#include <algorithm>
+#include <cmath>
+
+namespace QodeAssist::Context {
+
+int TokenUtils::estimateTokens(const QString &text)
+{
+    if (text.isEmpty()) {
+        return 0;
+    }
+
+    // TODO: need to improve
+    return text.length() / 4;
+}
+
+bool TokenUtils::isImageFilePath(const QString &filePath)
+{
+    static const QSet<QString> imageExtensions = {"png", "jpg", "jpeg", "gif", "webp", "bmp"};
+    return imageExtensions.contains(QFileInfo(filePath).suffix().toLower());
+}
+
+int TokenUtils::estimateImageAttachmentTokens(const QString &filePath)
+{
+    QImageReader reader(filePath);
+    QSize size = reader.size();
+    if (!size.isValid() || size.isEmpty())
+        return 1500;
+
+    double w = size.width();
+    double h = size.height();
+
+    const double longSide = std::max(w, h);
+    if (longSide > 2048.0) {
+        const double s = 2048.0 / longSide;
+        w *= s;
+        h *= s;
+    }
+
+    const double shortSide = std::min(w, h);
+    if (shortSide > 768.0) {
+        const double s = 768.0 / shortSide;
+        w *= s;
+        h *= s;
+    }
+
+    const int tilesW = static_cast<int>(std::ceil(w / 512.0));
+    const int tilesH = static_cast<int>(std::ceil(h / 512.0));
+    const int tiles = std::max(1, tilesW * tilesH);
+
+    return 85 + tiles * 170;
+}
+
+int TokenUtils::estimateFileTokens(const Context::ContentFile &file)
+{
+    if (isImageFilePath(file.filename))
+        return estimateImageAttachmentTokens(QString());
+
+    int total = 0;
+
+    total += estimateTokens(file.filename);
+    total += estimateTokens(file.content);
+    total += 5;
+
+    return total;
+}
+
+int TokenUtils::estimateFilesTokens(const QList<Context::ContentFile> &files)
+{
+    int total = 0;
+    for (const auto &file : files) {
+        total += estimateFileTokens(file);
+    }
+    return total;
+}
+
+} // namespace QodeAssist::Context

sources/context/TokenUtils.hpp

@@ -0,0 +1,23 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include "ContentFile.hpp"
+#include <QList>
+#include <QString>
+
+namespace QodeAssist::Context {
+
+class TokenUtils
+{
+public:
+    static int estimateTokens(const QString &text);
+    static int estimateFileTokens(const Context::ContentFile &file);
+    static int estimateFilesTokens(const QList<Context::ContentFile> &files);
+    static bool isImageFilePath(const QString &filePath);
+    static int estimateImageAttachmentTokens(const QString &filePath);
+};
+
+} // namespace QodeAssist::Context

sources/context/Utils.hpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2025 Povilas Kanapickas <povilas@radix.lt>
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
+#pragma once
+
+#include <QJsonObject>
+
+namespace QodeAssist::Context {
+
+inline QString extractFilePathFromRequest(const QJsonObject &request)
+{
+    QJsonObject params = request["params"].toObject();
+    QJsonObject doc = params["doc"].toObject();
+    QString uri = doc["uri"].toString();
+    return QUrl(uri).toLocalFile();
+}
+
+} // namespace QodeAssist::Context