mirror of
https://github.com/Palm1r/QodeAssist.git
synced 2026-05-30 02:49:12 -04:00
1638 lines
49 KiB
C++
1638 lines
49 KiB
C++
// Copyright (C) 2024-2026 Petr Mironychev
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
#include "ChatRootView.hpp"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <LLMQore/ToolsManager.hpp>
|
|
#include <QClipboard>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
#include <QDesktopServices>
|
|
#include <QDir>
|
|
#include <QFile>
|
|
#include <QFileDialog>
|
|
#include <QFileInfo>
|
|
#include <QMessageBox>
|
|
#include <QTextStream>
|
|
|
|
#include <coreplugin/editormanager/editormanager.h>
|
|
#include <coreplugin/icore.h>
|
|
#include <projectexplorer/project.h>
|
|
#include <projectexplorer/projectexplorer.h>
|
|
#include <projectexplorer/projectmanager.h>
|
|
#include <texteditor/texteditor.h>
|
|
#include <utils/theme/theme.h>
|
|
#include <utils/utilsicons.h>
|
|
|
|
#include "AgentRoleController.hpp"
|
|
#include "ChatAssistantSettings.hpp"
|
|
#include "ChatCompressor.hpp"
|
|
#include "ChatSerializer.hpp"
|
|
#include "ConfigurationManager.hpp"
|
|
#include "GeneralSettings.hpp"
|
|
#include "SettingsConstants.hpp"
|
|
#include "Logger.hpp"
|
|
#include "ProjectSettings.hpp"
|
|
#include "ProvidersManager.hpp"
|
|
#include "context/ChangesManager.h"
|
|
#include "context/ContextManager.hpp"
|
|
#include "context/TokenUtils.hpp"
|
|
#include "pluginllmcore/RulesLoader.hpp"
|
|
|
|
namespace QodeAssist::Chat {
|
|
|
|
ChatRootView::ChatRootView(QQuickItem *parent)
|
|
: QQuickItem(parent)
|
|
, m_chatModel(new ChatModel(this))
|
|
, m_promptProvider(PluginLLMCore::PromptTemplateManager::instance())
|
|
, m_clientInterface(new ClientInterface(m_chatModel, &m_promptProvider, this))
|
|
, m_fileManager(new ChatFileManager(this))
|
|
, m_isRequestInProgress(false)
|
|
, m_chatCompressor(new ChatCompressor(this))
|
|
, m_agentRoleController(new AgentRoleController(this))
|
|
{
|
|
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(&settings.caProvider, &Utils::BaseAspect::changed, this, [this]() {
|
|
auto &settings = Settings::generalSettings();
|
|
m_currentConfiguration
|
|
= QString("%1 - %2").arg(settings.caProvider.value(), settings.caModel.value());
|
|
emit currentConfigurationChanged();
|
|
});
|
|
|
|
connect(&settings.caModel, &Utils::BaseAspect::changed, this, [this]() {
|
|
auto &settings = Settings::generalSettings();
|
|
m_currentConfiguration
|
|
= QString("%1 - %2").arg(settings.caProvider.value(), settings.caModel.value());
|
|
emit currentConfigurationChanged();
|
|
});
|
|
|
|
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{});
|
|
m_currentMessageRequestId.clear();
|
|
updateCurrentMessageEditsStats();
|
|
});
|
|
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);
|
|
connect(this, &ChatRootView::useToolsChanged, this, &ChatRootView::updateInputTokensCount);
|
|
connect(
|
|
&Settings::chatAssistantSettings().enableChatTools,
|
|
&Utils::BaseAspect::changed,
|
|
this,
|
|
&ChatRootView::updateInputTokensCount);
|
|
|
|
rewireToolsChangedConnection();
|
|
connect(
|
|
&Settings::generalSettings().caProvider,
|
|
&Utils::BaseAspect::changed,
|
|
this,
|
|
[this]() {
|
|
rewireToolsChangedConnection();
|
|
updateInputTokensCount();
|
|
});
|
|
connect(
|
|
m_agentRoleController,
|
|
&AgentRoleController::availableRolesChanged,
|
|
this,
|
|
&ChatRootView::availableAgentRolesChanged);
|
|
connect(
|
|
m_agentRoleController,
|
|
&AgentRoleController::currentRoleChanged,
|
|
this,
|
|
&ChatRootView::currentAgentRoleChanged);
|
|
connect(
|
|
m_agentRoleController,
|
|
&AgentRoleController::baseSystemPromptChanged,
|
|
this,
|
|
&ChatRootView::baseSystemPromptChanged);
|
|
|
|
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();
|
|
});
|
|
|
|
connect(m_clientInterface, &ClientInterface::requestStarted, this, [this](const QString &requestId) {
|
|
if (!m_currentMessageRequestId.isEmpty()) {
|
|
LOG_MESSAGE(
|
|
QString("Clearing previous message requestId: %1").arg(m_currentMessageRequestId));
|
|
}
|
|
|
|
m_currentMessageRequestId = requestId;
|
|
LOG_MESSAGE(QString("New message request started: %1").arg(requestId));
|
|
updateCurrentMessageEditsStats();
|
|
});
|
|
|
|
connect(
|
|
m_clientInterface,
|
|
&ClientInterface::messageUsageReceived,
|
|
this,
|
|
[this](int promptTokens, int /*completionTokens*/, int /*cached*/, int /*reasoning*/) {
|
|
if (promptTokens <= 0 || m_lastSentEstimate <= 0)
|
|
return;
|
|
|
|
const double rawFactor
|
|
= static_cast<double>(promptTokens) / static_cast<double>(m_lastSentEstimate);
|
|
const double clamped = std::clamp(rawFactor, 0.5, 3.0);
|
|
m_calibrationFactor = 0.5 * m_calibrationFactor + 0.5 * clamped;
|
|
|
|
LOG_MESSAGE(QString("Token calibration: server=%1 estimated=%2 ratio=%3 ema=%4")
|
|
.arg(promptTokens)
|
|
.arg(m_lastSentEstimate)
|
|
.arg(rawFactor, 0, 'f', 3)
|
|
.arg(m_calibrationFactor, 0, 'f', 3));
|
|
|
|
updateInputTokensCount();
|
|
});
|
|
|
|
connect(
|
|
&Context::ChangesManager::instance(),
|
|
&Context::ChangesManager::fileEditAdded,
|
|
this,
|
|
[this](const QString &) { updateCurrentMessageEditsStats(); });
|
|
|
|
connect(
|
|
&Context::ChangesManager::instance(),
|
|
&Context::ChangesManager::fileEditApplied,
|
|
this,
|
|
[this](const QString &) { updateCurrentMessageEditsStats(); });
|
|
|
|
connect(
|
|
&Context::ChangesManager::instance(),
|
|
&Context::ChangesManager::fileEditRejected,
|
|
this,
|
|
[this](const QString &) { updateCurrentMessageEditsStats(); });
|
|
|
|
connect(
|
|
&Context::ChangesManager::instance(),
|
|
&Context::ChangesManager::fileEditUndone,
|
|
this,
|
|
[this](const QString &) { updateCurrentMessageEditsStats(); });
|
|
|
|
connect(
|
|
&Context::ChangesManager::instance(),
|
|
&Context::ChangesManager::fileEditArchived,
|
|
this,
|
|
[this](const QString &) { updateCurrentMessageEditsStats(); });
|
|
|
|
updateInputTokensCount();
|
|
refreshRules();
|
|
loadAvailableConfigurations();
|
|
|
|
connect(
|
|
ProjectExplorer::ProjectManager::instance(),
|
|
&ProjectExplorer::ProjectManager::startupProjectChanged,
|
|
this,
|
|
&ChatRootView::refreshRules);
|
|
|
|
connect(
|
|
ProjectExplorer::ProjectManager::instance(),
|
|
&ProjectExplorer::ProjectManager::projectAdded,
|
|
this,
|
|
&ChatRootView::openFilesChanged);
|
|
|
|
connect(
|
|
ProjectExplorer::ProjectManager::instance(),
|
|
&ProjectExplorer::ProjectManager::projectRemoved,
|
|
this,
|
|
&ChatRootView::openFilesChanged);
|
|
|
|
connect(
|
|
&Settings::chatAssistantSettings().enableChatTools,
|
|
&Utils::BaseAspect::changed,
|
|
this,
|
|
&ChatRootView::useToolsChanged);
|
|
|
|
connect(
|
|
&Settings::chatAssistantSettings().enableThinkingMode,
|
|
&Utils::BaseAspect::changed,
|
|
this,
|
|
&ChatRootView::useThinkingChanged);
|
|
|
|
connect(
|
|
&Settings::generalSettings().caProvider,
|
|
&Utils::BaseAspect::changed,
|
|
this,
|
|
&ChatRootView::isThinkingSupportChanged);
|
|
|
|
connect(m_fileManager, &ChatFileManager::fileOperationFailed, this, [this](const QString &error) {
|
|
m_lastErrorMessage = error;
|
|
emit lastErrorMessageChanged();
|
|
});
|
|
|
|
connect(m_chatCompressor, &ChatCompressor::compressionStarted, this, [this]() {
|
|
emit isCompressingChanged();
|
|
});
|
|
|
|
connect(m_chatCompressor, &ChatCompressor::compressionCompleted, this, [this](const QString &compressedChatPath) {
|
|
emit isCompressingChanged();
|
|
m_lastInfoMessage = tr("Chat compressed successfully!");
|
|
emit lastInfoMessageChanged();
|
|
emit compressionCompleted(compressedChatPath);
|
|
|
|
loadHistory(compressedChatPath);
|
|
|
|
if (m_pendingSend.active) {
|
|
PendingSend p = m_pendingSend;
|
|
m_pendingSend = {};
|
|
dispatchSend(p.message, p.attachments, p.linkedFiles, p.useTools, p.useThinking);
|
|
}
|
|
});
|
|
|
|
connect(m_chatCompressor, &ChatCompressor::compressionFailed, this, [this](const QString &error) {
|
|
emit isCompressingChanged();
|
|
m_lastErrorMessage = error;
|
|
emit lastErrorMessageChanged();
|
|
emit compressionFailed(error);
|
|
|
|
if (m_pendingSend.active) {
|
|
PendingSend p = m_pendingSend;
|
|
m_pendingSend = {};
|
|
dispatchSend(p.message, p.attachments, p.linkedFiles, p.useTools, p.useThinking);
|
|
}
|
|
});
|
|
}
|
|
|
|
ChatModel *ChatRootView::chatModel() const
|
|
{
|
|
return m_chatModel;
|
|
}
|
|
|
|
void ChatRootView::sendMessage(const QString &message)
|
|
{
|
|
const QStringList attachments = m_attachmentFiles;
|
|
const QStringList linkedFiles = m_linkedFiles;
|
|
const bool tools = useTools();
|
|
const bool thinking = useThinking();
|
|
|
|
if (deferSendForAutoCompress(message, attachments, linkedFiles, tools, thinking))
|
|
return;
|
|
|
|
dispatchSend(message, attachments, linkedFiles, tools, thinking);
|
|
}
|
|
|
|
bool ChatRootView::deferSendForAutoCompress(
|
|
const QString &message,
|
|
const QStringList &attachments,
|
|
const QStringList &linkedFiles,
|
|
bool useToolsArg,
|
|
bool useThinkingArg)
|
|
{
|
|
auto &settings = Settings::chatAssistantSettings();
|
|
if (!settings.autoCompress())
|
|
return false;
|
|
|
|
const int threshold = settings.autoCompressThreshold();
|
|
if (m_inputTokensCount < threshold)
|
|
return false;
|
|
|
|
if (m_recentFilePath.isEmpty()) {
|
|
QString filePath = getAutosaveFilePath(message, attachments);
|
|
if (filePath.isEmpty())
|
|
return false;
|
|
setRecentFilePath(filePath);
|
|
LOG_MESSAGE(QString("Set chat file path for new chat (auto-compress): %1").arg(filePath));
|
|
}
|
|
|
|
if (m_chatCompressor->isCompressing() || m_pendingSend.active)
|
|
return false;
|
|
|
|
LOG_MESSAGE(QString("Auto-compress preempt: estimated next=%1 ≥ threshold=%2; deferring send")
|
|
.arg(m_inputTokensCount)
|
|
.arg(threshold));
|
|
|
|
m_pendingSend = {message, attachments, linkedFiles, useToolsArg, useThinkingArg, true};
|
|
compressCurrentChat();
|
|
return true;
|
|
}
|
|
|
|
void ChatRootView::dispatchSend(
|
|
const QString &message,
|
|
const QStringList &attachments,
|
|
const QStringList &linkedFiles,
|
|
bool useToolsArg,
|
|
bool useThinkingArg)
|
|
{
|
|
if (m_recentFilePath.isEmpty()) {
|
|
QString filePath = getAutosaveFilePath(message, attachments);
|
|
if (!filePath.isEmpty()) {
|
|
setRecentFilePath(filePath);
|
|
LOG_MESSAGE(QString("Set chat file path for new chat: %1").arg(filePath));
|
|
}
|
|
}
|
|
|
|
m_lastSentEstimate = m_calibrationFactor > 0.0
|
|
? static_cast<int>(m_inputTokensCount / m_calibrationFactor)
|
|
: m_inputTokensCount;
|
|
|
|
m_clientInterface->sendMessage(message, attachments, linkedFiles, useToolsArg, useThinkingArg);
|
|
|
|
m_fileManager->clearIntermediateStorage();
|
|
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()) {
|
|
return;
|
|
}
|
|
|
|
m_attachmentFiles.clear();
|
|
emit attachmentFilesChanged();
|
|
m_fileManager->clearIntermediateStorage();
|
|
}
|
|
|
|
void ChatRootView::clearLinkedFiles()
|
|
{
|
|
if (m_linkedFiles.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
m_linkedFiles.clear();
|
|
emit linkedFilesChanged();
|
|
}
|
|
|
|
void ChatRootView::clearMessages()
|
|
{
|
|
m_clientInterface->clearMessages();
|
|
clearLinkedFiles();
|
|
}
|
|
|
|
QString ChatRootView::getChatsHistoryDir() const
|
|
{
|
|
QString path;
|
|
|
|
if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
|
|
Settings::ProjectSettings projectSettings(project);
|
|
path = projectSettings.chatHistoryPath().toFSPathString();
|
|
} else {
|
|
QDir baseDir(Core::ICore::userResourcePath().toFSPathString());
|
|
path = baseDir.filePath("qodeassist/chat_history");
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
if (!m_pendingSend.active)
|
|
m_fileManager->clearIntermediateStorage();
|
|
m_attachmentFiles.clear();
|
|
m_linkedFiles.clear();
|
|
emit attachmentFilesChanged();
|
|
emit linkedFilesChanged();
|
|
|
|
m_currentMessageRequestId.clear();
|
|
updateInputTokensCount();
|
|
updateCurrentMessageEditsStats();
|
|
}
|
|
|
|
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
|
|
{
|
|
QString shortMessage;
|
|
|
|
if (m_chatModel->rowCount() > 0) {
|
|
QString firstMessage
|
|
= m_chatModel->data(m_chatModel->index(0), ChatModel::Content).toString();
|
|
shortMessage = firstMessage.split('\n').first().simplified().left(30);
|
|
|
|
if (shortMessage.isEmpty()) {
|
|
QVariantList images
|
|
= m_chatModel->data(m_chatModel->index(0), ChatModel::Images).toList();
|
|
if (!images.isEmpty()) {
|
|
shortMessage = "image_chat";
|
|
}
|
|
}
|
|
}
|
|
|
|
return generateChatFileName(shortMessage, getChatsHistoryDir());
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
QString ChatRootView::getAutosaveFilePath(
|
|
const QString &firstMessage, const QStringList &attachments) const
|
|
{
|
|
if (!m_recentFilePath.isEmpty()) {
|
|
return m_recentFilePath;
|
|
}
|
|
|
|
QString dir = getChatsHistoryDir();
|
|
if (dir.isEmpty()) {
|
|
return QString();
|
|
}
|
|
|
|
QString shortMessage = firstMessage.split('\n').first().simplified().left(30);
|
|
|
|
if (shortMessage.isEmpty() && hasImageAttachments(attachments)) {
|
|
shortMessage = "image_chat";
|
|
}
|
|
|
|
QString fileName = generateChatFileName(shortMessage, dir);
|
|
return QDir(dir).filePath(fileName + ".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) {
|
|
addFilesToAttachList(dialog.selectedFiles());
|
|
}
|
|
}
|
|
|
|
void ChatRootView::addFilesToAttachList(const QStringList &filePaths)
|
|
{
|
|
if (filePaths.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
const QStringList processedPaths = m_fileManager->processDroppedFiles(filePaths);
|
|
|
|
bool filesAdded = false;
|
|
for (const QString &filePath : processedPaths) {
|
|
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()) {
|
|
return;
|
|
}
|
|
|
|
const QString removedFile = m_attachmentFiles.at(index);
|
|
m_attachmentFiles.removeAt(index);
|
|
emit attachmentFilesChanged();
|
|
|
|
LOG_MESSAGE(QString("Removed attachment file: %1").arg(removedFile));
|
|
}
|
|
|
|
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) {
|
|
addFilesToLinkList(dialog.selectedFiles());
|
|
}
|
|
}
|
|
|
|
void ChatRootView::addFilesToLinkList(const QStringList &filePaths)
|
|
{
|
|
if (filePaths.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
bool filesAdded = false;
|
|
QStringList imageFiles;
|
|
|
|
for (const QString &filePath : filePaths) {
|
|
if (isImageFile(filePath)) {
|
|
imageFiles.append(filePath);
|
|
continue;
|
|
}
|
|
|
|
if (!m_linkedFiles.contains(filePath)) {
|
|
m_linkedFiles.append(filePath);
|
|
filesAdded = true;
|
|
}
|
|
}
|
|
|
|
if (!imageFiles.isEmpty()) {
|
|
addFilesToAttachList(imageFiles);
|
|
m_lastInfoMessage
|
|
= tr("Images automatically moved to Attach zone (%n file(s))", "", imageFiles.size());
|
|
emit lastInfoMessageChanged();
|
|
}
|
|
|
|
if (filesAdded) {
|
|
emit linkedFilesChanged();
|
|
}
|
|
}
|
|
|
|
void ChatRootView::removeFileFromLinkList(int index)
|
|
{
|
|
if (index < 0 || index >= m_linkedFiles.size()) {
|
|
return;
|
|
}
|
|
|
|
const QString removedFile = m_linkedFiles.at(index);
|
|
m_linkedFiles.removeAt(index);
|
|
emit linkedFilesChanged();
|
|
|
|
LOG_MESSAGE(QString("Removed linked file: %1").arg(removedFile));
|
|
}
|
|
|
|
void ChatRootView::showAddImageDialog()
|
|
{
|
|
QFileDialog dialog(nullptr, tr("Select Images to Attach"));
|
|
dialog.setFileMode(QFileDialog::ExistingFiles);
|
|
dialog.setNameFilter(tr("Images (*.png *.jpg *.jpeg *.gif *.bmp *.webp)"));
|
|
|
|
if (auto project = ProjectExplorer::ProjectManager::startupProject()) {
|
|
dialog.setDirectory(project->projectDirectory().toFSPathString());
|
|
}
|
|
|
|
if (dialog.exec() == QDialog::Accepted) {
|
|
addFilesToAttachList(dialog.selectedFiles());
|
|
}
|
|
}
|
|
|
|
QStringList ChatRootView::convertUrlsToLocalPaths(const QVariantList &urls) const
|
|
{
|
|
QStringList localPaths;
|
|
for (const QVariant &urlVariant : urls) {
|
|
QUrl url(urlVariant.toString());
|
|
if (url.isLocalFile()) {
|
|
QString localPath = url.toLocalFile();
|
|
if (!localPath.isEmpty()) {
|
|
localPaths.append(localPath);
|
|
}
|
|
}
|
|
}
|
|
return localPaths;
|
|
}
|
|
|
|
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 {
|
|
QDir baseDir(Core::ICore::userResourcePath().toFSPathString());
|
|
path = baseDir.filePath("qodeassist/chat_history");
|
|
}
|
|
|
|
QDir dir(path);
|
|
if (!dir.exists()) {
|
|
dir.mkpath(".");
|
|
}
|
|
|
|
QUrl url = QUrl::fromLocalFile(dir.absolutePath());
|
|
QDesktopServices::openUrl(url);
|
|
}
|
|
|
|
void ChatRootView::openRulesFolder()
|
|
{
|
|
auto project = ProjectExplorer::ProjectManager::startupProject();
|
|
if (!project) {
|
|
return;
|
|
}
|
|
|
|
QString projectPath = project->projectDirectory().toFSPathString();
|
|
QString rulesPath = QDir(projectPath).filePath(".qodeassist/rules");
|
|
|
|
QDir dir(rulesPath);
|
|
if (!dir.exists()) {
|
|
dir.mkpath(".");
|
|
}
|
|
|
|
QUrl url = QUrl::fromLocalFile(dir.absolutePath());
|
|
QDesktopServices::openUrl(url);
|
|
}
|
|
|
|
void ChatRootView::openSettings()
|
|
{
|
|
QMetaObject::invokeMethod(
|
|
this,
|
|
[]() { Settings::showSettings(Constants::QODE_ASSIST_CHAT_ASSISTANT_SETTINGS_PAGE_ID); },
|
|
Qt::QueuedConnection);
|
|
}
|
|
|
|
void ChatRootView::openFileInEditor(const QString &filePath)
|
|
{
|
|
if (filePath.isEmpty())
|
|
return;
|
|
Core::EditorManager::openEditor(Utils::FilePath::fromString(filePath));
|
|
}
|
|
|
|
void ChatRootView::rewireToolsChangedConnection()
|
|
{
|
|
if (m_toolsChangedConn)
|
|
QObject::disconnect(m_toolsChangedConn);
|
|
m_toolsChangedConn = {};
|
|
|
|
const auto providerName = Settings::generalSettings().caProvider();
|
|
auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
|
|
if (!provider)
|
|
return;
|
|
auto *tm = provider->toolsManager();
|
|
if (!tm)
|
|
return;
|
|
|
|
m_toolsChangedConn = connect(
|
|
tm,
|
|
&::LLMQore::ToolRegistry::toolsChanged,
|
|
this,
|
|
&ChatRootView::updateInputTokensCount);
|
|
}
|
|
|
|
void ChatRootView::updateInputTokensCount()
|
|
{
|
|
int inputTokens = m_messageTokensCount;
|
|
auto &settings = Settings::chatAssistantSettings();
|
|
|
|
if (settings.useSystemPrompt()) {
|
|
inputTokens += Context::TokenUtils::estimateTokens(settings.systemPrompt());
|
|
}
|
|
|
|
const auto splitImageEstimate = [](const QStringList &paths, QStringList &textPaths) {
|
|
int imageTokens = 0;
|
|
for (const QString &p : paths) {
|
|
if (Context::TokenUtils::isImageFilePath(p))
|
|
imageTokens += Context::TokenUtils::estimateImageAttachmentTokens(p);
|
|
else
|
|
textPaths.append(p);
|
|
}
|
|
return imageTokens;
|
|
};
|
|
|
|
if (!m_attachmentFiles.isEmpty()) {
|
|
QStringList textPaths;
|
|
inputTokens += splitImageEstimate(m_attachmentFiles, textPaths);
|
|
if (!textPaths.isEmpty()) {
|
|
auto attachFiles = m_clientInterface->contextManager()->getContentFiles(textPaths);
|
|
inputTokens += Context::TokenUtils::estimateFilesTokens(attachFiles);
|
|
}
|
|
}
|
|
|
|
if (!m_linkedFiles.isEmpty()) {
|
|
QStringList textPaths;
|
|
inputTokens += splitImageEstimate(m_linkedFiles, textPaths);
|
|
if (!textPaths.isEmpty()) {
|
|
auto linkFiles = m_clientInterface->contextManager()->getContentFiles(textPaths);
|
|
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
|
|
}
|
|
|
|
if (useTools()) {
|
|
const auto providerName = Settings::generalSettings().caProvider();
|
|
if (auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(
|
|
providerName)) {
|
|
if (auto *tm = provider->toolsManager()) {
|
|
const QJsonArray toolDefs = tm->getToolsDefinitions();
|
|
if (!toolDefs.isEmpty()) {
|
|
const QByteArray serialized
|
|
= QJsonDocument(toolDefs).toJson(QJsonDocument::Compact);
|
|
inputTokens += static_cast<int>(serialized.size() / 4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_inputTokensCount = static_cast<int>(inputTokens * m_calibrationFactor);
|
|
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);
|
|
}
|
|
|
|
emit openFilesChanged();
|
|
}
|
|
|
|
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);
|
|
emit openFilesChanged();
|
|
}
|
|
}
|
|
|
|
QString ChatRootView::chatFileName() const
|
|
{
|
|
return QFileInfo(m_recentFilePath).baseName();
|
|
}
|
|
|
|
QString ChatRootView::chatFilePath() const
|
|
{
|
|
return m_recentFilePath;
|
|
}
|
|
|
|
void ChatRootView::setRecentFilePath(const QString &filePath)
|
|
{
|
|
if (m_recentFilePath != filePath) {
|
|
m_recentFilePath = filePath;
|
|
m_clientInterface->setChatFilePath(filePath);
|
|
m_fileManager->setChatFilePath(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;
|
|
}
|
|
|
|
QVariantList ChatRootView::activeRules() const
|
|
{
|
|
return m_activeRules;
|
|
}
|
|
|
|
int ChatRootView::activeRulesCount() const
|
|
{
|
|
return m_activeRules.size();
|
|
}
|
|
|
|
QString ChatRootView::getRuleContent(int index)
|
|
{
|
|
if (index < 0 || index >= m_activeRules.size())
|
|
return QString();
|
|
|
|
return PluginLLMCore::RulesLoader::loadRuleFileContent(
|
|
m_activeRules[index].toMap()["filePath"].toString());
|
|
}
|
|
|
|
void ChatRootView::refreshRules()
|
|
{
|
|
m_activeRules.clear();
|
|
|
|
auto project = PluginLLMCore::RulesLoader::getActiveProject();
|
|
if (!project) {
|
|
emit activeRulesChanged();
|
|
emit activeRulesCountChanged();
|
|
return;
|
|
}
|
|
|
|
auto ruleFiles
|
|
= PluginLLMCore::RulesLoader::getRuleFilesForProject(project, PluginLLMCore::RulesContext::Chat);
|
|
|
|
for (const auto &ruleFile : ruleFiles) {
|
|
QVariantMap ruleMap;
|
|
ruleMap["filePath"] = ruleFile.filePath;
|
|
ruleMap["fileName"] = ruleFile.fileName;
|
|
ruleMap["category"] = ruleFile.category;
|
|
m_activeRules.append(ruleMap);
|
|
}
|
|
|
|
emit activeRulesChanged();
|
|
emit activeRulesCountChanged();
|
|
}
|
|
|
|
bool ChatRootView::useTools() const
|
|
{
|
|
return Settings::chatAssistantSettings().enableChatTools();
|
|
}
|
|
|
|
void ChatRootView::setUseTools(bool enabled)
|
|
{
|
|
Settings::chatAssistantSettings().enableChatTools.setValue(enabled);
|
|
Settings::chatAssistantSettings().writeSettings();
|
|
}
|
|
|
|
bool ChatRootView::useThinking() const
|
|
{
|
|
return Settings::chatAssistantSettings().enableThinkingMode();
|
|
}
|
|
|
|
void ChatRootView::setUseThinking(bool enabled)
|
|
{
|
|
Settings::chatAssistantSettings().enableThinkingMode.setValue(enabled);
|
|
Settings::chatAssistantSettings().writeSettings();
|
|
}
|
|
|
|
void ChatRootView::applyFileEdit(const QString &editId)
|
|
{
|
|
LOG_MESSAGE(QString("Applying file edit: %1").arg(editId));
|
|
if (Context::ChangesManager::instance().applyFileEdit(editId)) {
|
|
m_lastInfoMessage = QString("File edit applied successfully");
|
|
emit lastInfoMessageChanged();
|
|
|
|
updateFileEditStatus(editId, "applied");
|
|
} else {
|
|
auto edit = Context::ChangesManager::instance().getFileEdit(editId);
|
|
m_lastErrorMessage = edit.statusMessage.isEmpty()
|
|
? QString("Failed to apply file edit")
|
|
: QString("Failed to apply file edit: %1").arg(edit.statusMessage);
|
|
emit lastErrorMessageChanged();
|
|
}
|
|
}
|
|
|
|
void ChatRootView::rejectFileEdit(const QString &editId)
|
|
{
|
|
LOG_MESSAGE(QString("Rejecting file edit: %1").arg(editId));
|
|
if (Context::ChangesManager::instance().rejectFileEdit(editId)) {
|
|
m_lastInfoMessage = QString("File edit rejected");
|
|
emit lastInfoMessageChanged();
|
|
|
|
updateFileEditStatus(editId, "rejected");
|
|
} else {
|
|
auto edit = Context::ChangesManager::instance().getFileEdit(editId);
|
|
m_lastErrorMessage = edit.statusMessage.isEmpty()
|
|
? QString("Failed to reject file edit")
|
|
: QString("Failed to reject file edit: %1").arg(edit.statusMessage);
|
|
emit lastErrorMessageChanged();
|
|
}
|
|
}
|
|
|
|
void ChatRootView::undoFileEdit(const QString &editId)
|
|
{
|
|
LOG_MESSAGE(QString("Undoing file edit: %1").arg(editId));
|
|
if (Context::ChangesManager::instance().undoFileEdit(editId)) {
|
|
m_lastInfoMessage = QString("File edit undone successfully");
|
|
emit lastInfoMessageChanged();
|
|
|
|
updateFileEditStatus(editId, "rejected");
|
|
} else {
|
|
auto edit = Context::ChangesManager::instance().getFileEdit(editId);
|
|
m_lastErrorMessage = edit.statusMessage.isEmpty()
|
|
? QString("Failed to undo file edit")
|
|
: QString("Failed to undo file edit: %1").arg(edit.statusMessage);
|
|
emit lastErrorMessageChanged();
|
|
}
|
|
}
|
|
|
|
void ChatRootView::openFileEditInEditor(const QString &editId)
|
|
{
|
|
LOG_MESSAGE(QString("Opening file edit in editor: %1").arg(editId));
|
|
|
|
auto edit = Context::ChangesManager::instance().getFileEdit(editId);
|
|
if (edit.editId.isEmpty()) {
|
|
m_lastErrorMessage = QString("File edit not found: %1").arg(editId);
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
Utils::FilePath filePath = Utils::FilePath::fromString(edit.filePath);
|
|
|
|
Core::IEditor *editor = Core::EditorManager::openEditor(filePath);
|
|
if (!editor) {
|
|
m_lastErrorMessage = QString("Failed to open file in editor: %1").arg(edit.filePath);
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
auto *textEditor = qobject_cast<TextEditor::BaseTextEditor *>(editor);
|
|
if (textEditor && textEditor->editorWidget()) {
|
|
QTextDocument *doc = textEditor->editorWidget()->document();
|
|
if (doc) {
|
|
QString currentContent = doc->toPlainText();
|
|
int position = -1;
|
|
|
|
if (edit.status == Context::ChangesManager::Applied && !edit.newContent.isEmpty()) {
|
|
position = currentContent.indexOf(edit.newContent);
|
|
} else if (!edit.oldContent.isEmpty()) {
|
|
position = currentContent.indexOf(edit.oldContent);
|
|
}
|
|
|
|
if (position >= 0) {
|
|
QTextCursor cursor(doc);
|
|
cursor.setPosition(position);
|
|
textEditor->editorWidget()->setTextCursor(cursor);
|
|
textEditor->editorWidget()->centerCursor();
|
|
}
|
|
}
|
|
}
|
|
|
|
LOG_MESSAGE(QString("Opened file in editor: %1").arg(edit.filePath));
|
|
}
|
|
|
|
void ChatRootView::updateFileEditStatus(const QString &editId, const QString &status)
|
|
{
|
|
auto messages = m_chatModel->getChatHistory();
|
|
for (int i = 0; i < messages.size(); ++i) {
|
|
if (messages[i].role == Chat::ChatModel::FileEdit && messages[i].id == editId) {
|
|
QString content = messages[i].content;
|
|
|
|
const QString marker = "QODEASSIST_FILE_EDIT:";
|
|
int markerPos = content.indexOf(marker);
|
|
|
|
QString jsonStr = content;
|
|
if (markerPos >= 0) {
|
|
jsonStr = content.mid(markerPos + marker.length());
|
|
}
|
|
|
|
QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8());
|
|
if (doc.isObject()) {
|
|
QJsonObject obj = doc.object();
|
|
obj["status"] = status;
|
|
|
|
auto edit = Context::ChangesManager::instance().getFileEdit(editId);
|
|
if (!edit.statusMessage.isEmpty()) {
|
|
obj["status_message"] = edit.statusMessage;
|
|
}
|
|
|
|
QString updatedContent = marker
|
|
+ QString::fromUtf8(
|
|
QJsonDocument(obj).toJson(QJsonDocument::Compact));
|
|
m_chatModel->updateMessageContent(editId, updatedContent);
|
|
LOG_MESSAGE(QString("Updated file edit status to: %1").arg(status));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
updateCurrentMessageEditsStats();
|
|
}
|
|
|
|
void ChatRootView::applyAllFileEditsForCurrentMessage()
|
|
{
|
|
if (m_currentMessageRequestId.isEmpty()) {
|
|
m_lastErrorMessage = QString("No active message with file edits");
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
LOG_MESSAGE(QString("Applying all file edits for message: %1").arg(m_currentMessageRequestId));
|
|
|
|
QString errorMsg;
|
|
bool success = Context::ChangesManager::instance()
|
|
.reapplyAllEditsForRequest(m_currentMessageRequestId, &errorMsg);
|
|
|
|
if (success) {
|
|
m_lastInfoMessage = QString("All file edits applied successfully");
|
|
emit lastInfoMessageChanged();
|
|
|
|
auto edits = Context::ChangesManager::instance().getEditsForRequest(
|
|
m_currentMessageRequestId);
|
|
for (const auto &edit : edits) {
|
|
if (edit.status == Context::ChangesManager::Applied) {
|
|
updateFileEditStatus(edit.editId, "applied");
|
|
}
|
|
}
|
|
} else {
|
|
m_lastErrorMessage = errorMsg.isEmpty()
|
|
? QString("Failed to apply some file edits")
|
|
: QString("Failed to apply some file edits:\n%1").arg(errorMsg);
|
|
emit lastErrorMessageChanged();
|
|
|
|
auto edits = Context::ChangesManager::instance().getEditsForRequest(
|
|
m_currentMessageRequestId);
|
|
for (const auto &edit : edits) {
|
|
if (edit.status == Context::ChangesManager::Applied) {
|
|
updateFileEditStatus(edit.editId, "applied");
|
|
}
|
|
}
|
|
}
|
|
|
|
updateCurrentMessageEditsStats();
|
|
}
|
|
|
|
void ChatRootView::undoAllFileEditsForCurrentMessage()
|
|
{
|
|
if (m_currentMessageRequestId.isEmpty()) {
|
|
m_lastErrorMessage = QString("No active message with file edits");
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
LOG_MESSAGE(QString("Undoing all file edits for message: %1").arg(m_currentMessageRequestId));
|
|
|
|
QString errorMsg;
|
|
bool success = Context::ChangesManager::instance()
|
|
.undoAllEditsForRequest(m_currentMessageRequestId, &errorMsg);
|
|
|
|
if (success) {
|
|
m_lastInfoMessage = QString("All file edits undone successfully");
|
|
emit lastInfoMessageChanged();
|
|
|
|
auto edits = Context::ChangesManager::instance().getEditsForRequest(
|
|
m_currentMessageRequestId);
|
|
for (const auto &edit : edits) {
|
|
if (edit.status == Context::ChangesManager::Rejected) {
|
|
updateFileEditStatus(edit.editId, "rejected");
|
|
}
|
|
}
|
|
} else {
|
|
m_lastErrorMessage = errorMsg.isEmpty()
|
|
? QString("Failed to undo some file edits")
|
|
: QString("Failed to undo some file edits:\n%1").arg(errorMsg);
|
|
emit lastErrorMessageChanged();
|
|
|
|
auto edits = Context::ChangesManager::instance().getEditsForRequest(
|
|
m_currentMessageRequestId);
|
|
for (const auto &edit : edits) {
|
|
if (edit.status == Context::ChangesManager::Rejected) {
|
|
updateFileEditStatus(edit.editId, "rejected");
|
|
}
|
|
}
|
|
}
|
|
|
|
updateCurrentMessageEditsStats();
|
|
}
|
|
|
|
void ChatRootView::updateCurrentMessageEditsStats()
|
|
{
|
|
if (m_currentMessageRequestId.isEmpty()) {
|
|
if (m_currentMessageTotalEdits != 0 || m_currentMessageAppliedEdits != 0
|
|
|| m_currentMessagePendingEdits != 0 || m_currentMessageRejectedEdits != 0) {
|
|
m_currentMessageTotalEdits = 0;
|
|
m_currentMessageAppliedEdits = 0;
|
|
m_currentMessagePendingEdits = 0;
|
|
m_currentMessageRejectedEdits = 0;
|
|
emit currentMessageEditsStatsChanged();
|
|
}
|
|
return;
|
|
}
|
|
|
|
auto edits = Context::ChangesManager::instance().getEditsForRequest(m_currentMessageRequestId);
|
|
|
|
int total = edits.size();
|
|
int applied = 0;
|
|
int pending = 0;
|
|
int rejected = 0;
|
|
|
|
for (const auto &edit : edits) {
|
|
switch (edit.status) {
|
|
case Context::ChangesManager::Applied:
|
|
applied++;
|
|
break;
|
|
case Context::ChangesManager::Pending:
|
|
pending++;
|
|
break;
|
|
case Context::ChangesManager::Rejected:
|
|
rejected++;
|
|
break;
|
|
case Context::ChangesManager::Archived:
|
|
total--;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool changed = false;
|
|
if (m_currentMessageTotalEdits != total) {
|
|
m_currentMessageTotalEdits = total;
|
|
changed = true;
|
|
}
|
|
if (m_currentMessageAppliedEdits != applied) {
|
|
m_currentMessageAppliedEdits = applied;
|
|
changed = true;
|
|
}
|
|
if (m_currentMessagePendingEdits != pending) {
|
|
m_currentMessagePendingEdits = pending;
|
|
changed = true;
|
|
}
|
|
if (m_currentMessageRejectedEdits != rejected) {
|
|
m_currentMessageRejectedEdits = rejected;
|
|
changed = true;
|
|
}
|
|
|
|
if (changed) {
|
|
LOG_MESSAGE(
|
|
QString("Updated message edits stats: total=%1, applied=%2, pending=%3, rejected=%4")
|
|
.arg(total)
|
|
.arg(applied)
|
|
.arg(pending)
|
|
.arg(rejected));
|
|
emit currentMessageEditsStatsChanged();
|
|
}
|
|
}
|
|
|
|
int ChatRootView::currentMessageTotalEdits() const
|
|
{
|
|
return m_currentMessageTotalEdits;
|
|
}
|
|
|
|
int ChatRootView::currentMessageAppliedEdits() const
|
|
{
|
|
return m_currentMessageAppliedEdits;
|
|
}
|
|
|
|
int ChatRootView::currentMessagePendingEdits() const
|
|
{
|
|
return m_currentMessagePendingEdits;
|
|
}
|
|
|
|
int ChatRootView::currentMessageRejectedEdits() const
|
|
{
|
|
return m_currentMessageRejectedEdits;
|
|
}
|
|
|
|
QString ChatRootView::lastInfoMessage() const
|
|
{
|
|
return m_lastInfoMessage;
|
|
}
|
|
|
|
bool ChatRootView::isThinkingSupport() const
|
|
{
|
|
auto providerName = Settings::generalSettings().caProvider();
|
|
auto provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
|
|
|
|
return provider && provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Thinking);
|
|
}
|
|
|
|
QString ChatRootView::generateChatFileName(const QString &shortMessage, const QString &dir) const
|
|
{
|
|
static const QRegularExpression saitizeSymbols = QRegularExpression("[\\/:*?\"<>|\\s]");
|
|
static const QRegularExpression underSymbols = QRegularExpression("_+");
|
|
|
|
QStringList parts;
|
|
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 fullPath = QDir(dir).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(dir).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;
|
|
}
|
|
|
|
bool ChatRootView::hasImageAttachments(const QStringList &attachments) const
|
|
{
|
|
for (const QString &filePath : attachments) {
|
|
if (isImageFile(filePath)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ChatRootView::isImageFile(const QString &filePath) const
|
|
{
|
|
static const QSet<QString> imageExtensions = {"png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"};
|
|
|
|
QFileInfo fileInfo(filePath);
|
|
return imageExtensions.contains(fileInfo.suffix().toLower());
|
|
}
|
|
|
|
void ChatRootView::loadAvailableConfigurations()
|
|
{
|
|
auto &manager = Settings::ConfigurationManager::instance();
|
|
manager.loadConfigurations(Settings::ConfigurationType::Chat);
|
|
|
|
QVector<Settings::AIConfiguration> configs = manager.configurations(
|
|
Settings::ConfigurationType::Chat);
|
|
|
|
m_availableConfigurations.clear();
|
|
m_availableConfigurations.append(QObject::tr("Current Settings"));
|
|
|
|
for (const Settings::AIConfiguration &config : configs) {
|
|
m_availableConfigurations.append(config.name);
|
|
}
|
|
|
|
auto &settings = Settings::generalSettings();
|
|
QString currentProvider = settings.caProvider.value();
|
|
QString currentModel = settings.caModel.value();
|
|
m_currentConfiguration = QString("%1 - %2").arg(currentProvider, currentModel);
|
|
|
|
emit availableConfigurationsChanged();
|
|
emit currentConfigurationChanged();
|
|
}
|
|
|
|
void ChatRootView::applyConfiguration(const QString &configName)
|
|
{
|
|
if (configName == QObject::tr("Current Settings")) {
|
|
return;
|
|
}
|
|
|
|
auto &manager = Settings::ConfigurationManager::instance();
|
|
QVector<Settings::AIConfiguration> configs = manager.configurations(
|
|
Settings::ConfigurationType::Chat);
|
|
|
|
for (const Settings::AIConfiguration &config : configs) {
|
|
if (config.name == configName) {
|
|
auto &settings = Settings::generalSettings();
|
|
|
|
settings.caProvider.setValue(config.provider);
|
|
settings.caModel.setValue(config.model);
|
|
settings.caTemplate.setValue(config.templateName);
|
|
settings.caUrl.setValue(config.url);
|
|
settings.caCustomEndpoint.setValue(config.customEndpoint);
|
|
|
|
settings.writeSettings();
|
|
|
|
m_currentConfiguration = QString("%1 - %2").arg(config.provider, config.model);
|
|
emit currentConfigurationChanged();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
QStringList ChatRootView::availableConfigurations() const
|
|
{
|
|
return m_availableConfigurations;
|
|
}
|
|
|
|
QString ChatRootView::currentConfiguration() const
|
|
{
|
|
return m_currentConfiguration;
|
|
}
|
|
|
|
void ChatRootView::loadAvailableAgentRoles()
|
|
{
|
|
m_agentRoleController->loadAvailableRoles();
|
|
}
|
|
|
|
void ChatRootView::applyAgentRole(const QString &roleName)
|
|
{
|
|
m_agentRoleController->applyRole(roleName);
|
|
}
|
|
|
|
QStringList ChatRootView::availableAgentRoles() const
|
|
{
|
|
return m_agentRoleController->availableRoles();
|
|
}
|
|
|
|
QString ChatRootView::currentAgentRole() const
|
|
{
|
|
return m_agentRoleController->currentRole();
|
|
}
|
|
|
|
QString ChatRootView::baseSystemPrompt() const
|
|
{
|
|
return m_agentRoleController->baseSystemPrompt();
|
|
}
|
|
|
|
QString ChatRootView::currentAgentRoleDescription() const
|
|
{
|
|
return m_agentRoleController->currentRoleDescription();
|
|
}
|
|
|
|
QString ChatRootView::currentAgentRoleSystemPrompt() const
|
|
{
|
|
return m_agentRoleController->currentRoleSystemPrompt();
|
|
}
|
|
|
|
void ChatRootView::openAgentRolesSettings()
|
|
{
|
|
m_agentRoleController->openSettings();
|
|
}
|
|
|
|
void ChatRootView::compressCurrentChat()
|
|
{
|
|
if (m_chatCompressor->isCompressing()) {
|
|
m_lastErrorMessage = tr("Compression is already in progress");
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
if (m_recentFilePath.isEmpty()) {
|
|
m_lastErrorMessage = tr("No chat file to compress. Please save the chat first.");
|
|
emit lastErrorMessageChanged();
|
|
return;
|
|
}
|
|
|
|
autosave();
|
|
|
|
m_chatCompressor->startCompression(m_recentFilePath, m_chatModel);
|
|
}
|
|
|
|
void ChatRootView::cancelCompression()
|
|
{
|
|
m_chatCompressor->cancelCompression();
|
|
}
|
|
|
|
bool ChatRootView::isCompressing() const
|
|
{
|
|
return m_chatCompressor->isCompressing();
|
|
}
|
|
|
|
} // namespace QodeAssist::Chat
|