rename files, implement config page and various new features

CMakeLists.txt

@@ -18,7 +18,7 @@ include(ECMAddAppIcon)
 include(ECMInstallIcons)
 include(ECMDeprecationSettings)
 
-find_package(Qt5Widgets CONFIG REQUIRED)
+find_package(Qt5 REQUIRED COMPONENTS WebSockets)
 find_package(KF5
     REQUIRED COMPONENTS
         CoreAddons
@@ -26,12 +26,15 @@ find_package(KF5
         TextEditor
 )
 
-kcoreaddons_add_plugin(${PROJECT_NAME} INSTALL_NAMESPACE "kf5/ktexteditor")
+kcoreaddons_add_plugin(${PROJECT_NAME} INSTALL_NAMESPACE "ktexteditor")
-target_link_libraries(${PROJECT_NAME} PRIVATE KF5::TextEditor)
+target_include_directories(${PROJECT_NAME} PRIVATE)
+target_link_libraries(${PROJECT_NAME} PRIVATE KF5::TextEditor Qt5::WebSockets)
 target_sources(
   ${PROJECT_NAME}
   PRIVATE
     kateai.cpp
+    kateaiconfigpage.cpp
+    plugin.qrc
 )
 
 

kateai.cpp

@@ -0,0 +1,244 @@
+#include "kateai.h"
+
+#include <QShortcut>
+#include <KConfigGroup>
+#include <KPluginFactory>
+#include <KTextEditor/Document>
+#include <KTextEditor/View>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qjsonobject.h>
+#include <qnamespace.h>
+#include <QString>
+#include <KActionCollection>
+#include <KXMLGUIFactory>
+#include <QJsonObject>
+#include <QJsonDocument>
+#include <QRandomGenerator>
+#include <QTextCodec>
+#include <limits>
+#include <QMessageBox>
+#include <KLocalizedString>
+#include <KSharedConfig>
+
+#include "kateaiconfigpage.h"
+
+K_PLUGIN_FACTORY_WITH_JSON(KateAiPluginFactory, "kateai.json", registerPlugin<KateAiPlugin>();)
+
+KateAiPlugin::KateAiPlugin(QObject *parent, const QList<QVariant> &)
+    : KTextEditor::Plugin(parent), m_serverUrl(QStringLiteral("ws://localhost:8642"))
+{
+    connect(&m_webSocket, &QWebSocket::connected, this, &KateAiPlugin::onConnected);
+    readConfig();
+}
+
+void KateAiPlugin::onConnected()
+{
+    qDebug()<<__func__<<m_webSocket.isValid();
+}
+
+KateAiPlugin::~KateAiPlugin() = default;
+
+void KateAiPlugin::reconnect()
+{
+    m_webSocket.close();
+    m_webSocket.open(m_serverUrl);
+}
+
+QObject *KateAiPlugin::createView(KTextEditor::MainWindow *mainWindow)
+{
+    auto view = new KateAiPluginView(this, mainWindow, &m_webSocket);
+    connect(view, &KateAiPluginView::reconnect, this, &KateAiPlugin::reconnect);
+    return view;
+}
+
+KTextEditor::ConfigPage *KateAiPlugin::configPage(int number, QWidget *parent)
+{
+    if (number != 0)
+        return nullptr;
+
+    return new KateAiConfigPage(parent, this);
+}
+
+void KateAiPlugin::readConfig()
+{
+    KConfigGroup config(KSharedConfig::openConfig(), "Ai");
+    m_serverUrl = QUrl(config.readEntry("Url", "ws://localhost:8642"));
+    reconnect();
+}
+
+KateAiPluginView::KateAiPluginView(KateAiPlugin *plugin, KTextEditor::MainWindow *mainwindow, QPointer<QWebSocket> webSocket, bool instruct)
+    : QObject(plugin)
+    , m_mainWindow(mainwindow)
+    , m_webSocket(webSocket)
+    , m_useInstruct(instruct)
+{
+    KXMLGUIClient::setComponentName(QStringLiteral("kateaiplugin"), QStringLiteral("Git Blame"));
+    setXMLFile(QStringLiteral("ui.rc"));
+    QAction *generateAction = actionCollection()->addAction(QStringLiteral("ai_generate"));
+    generateAction->setText(QStringLiteral("Generate text using AI"));
+    actionCollection()->setDefaultShortcut(generateAction, QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_A));
+    m_mainWindow->guiFactory()->addClient(this);
+
+    connect(generateAction, &QAction::triggered, this, &KateAiPluginView::generate);
+    connect(m_webSocket, &QWebSocket::textMessageReceived, this, &KateAiPluginView::socketMessage);
+}
+
+QPointer<KTextEditor::Document> KateAiPluginView::activeDocument() const
+{
+    KTextEditor::View *view = m_mainWindow->activeView();
+    if(view && view->document())
+        return view->document();
+    return nullptr;
+}
+
+KTextEditor::Cursor KateAiPluginView::getCurrentCursor() const
+{
+    KTextEditor::View *view = m_mainWindow->activeView();
+    if(view)
+        return view->cursorPosition();
+    return KTextEditor::Cursor();
+}
+
+void KateAiPluginView::socketMessage(const QString& message)
+{
+    QJsonDocument jsonDocument = QJsonDocument::fromJson(message.toUtf8());
+    QJsonValue idVal = jsonDocument[QStringLiteral("request_id")];
+    if(!idVal.isDouble())
+    {
+        qDebug()<<"Got invalid response on socket";
+        return;
+    }
+    int id = idVal.toInt();
+
+    QHash<int, Request>::iterator it = m_requests.find(id);
+    if(it != m_requests.end())
+    {
+        QJsonValue responseValue = jsonDocument[QStringLiteral("response")];
+        if(!responseValue.isString())
+        {
+            qDebug()<<"Got invalid response on socket";
+            return;
+        }
+        if(it.value().document)
+           it.value().document->insertText(it.value().cursor, responseValue.toString());
+        m_requests.erase(it);
+    }
+}
+
+QStringList getIncludePaths(const QString& text)
+{
+    QStringList lines = text.split(U'\n');
+    QStringList paths;
+
+    for(const QString& line : lines)
+    {
+        if(line.trimmed().startsWith(QStringLiteral("#include")))
+        {
+            int start = line.indexOf(U'<');
+            int end;
+            if(start != -1)
+            {
+                end = line.indexOf(U'>', start+1);
+                if(end == -1)
+                    continue;
+            }
+            else
+            {
+                start = line.indexOf(U'"');
+                if(start == -1)
+                    continue;
+
+                end = line.indexOf(U'"', start+1);
+                if(end == -1)
+                    continue;
+            }
+            paths.push_back(line.mid(start+1, (end-(start+1))).trimmed());
+        }
+    }
+    return paths;
+}
+
+QString KateAiPluginView::assembleContext(QPointer<KTextEditor::Document> document, const KTextEditor::Cursor& cursor)
+{
+    QString mime = document->mimeType();
+    QString context;
+    QString baseText;
+
+    if(!m_useInstruct)
+        baseText = document->text(KTextEditor::Range(KTextEditor::Cursor(0, 0), cursor));
+    else
+        baseText = document->text();
+    if(mime ==  QStringLiteral("text/x-c++src") || mime ==  QStringLiteral("text/x-csrc"))
+    {
+        QFileInfo documentFileInfo(document->url().path());
+        QString directory = documentFileInfo.absolutePath();
+        QStringList paths = getIncludePaths(baseText);
+        qDebug()<<__func__<<"Directory:"<<directory<<"Paths:"<<paths;
+
+        for(QString& path : paths)
+        {
+            path = directory + QDir::separator() + path;
+            qDebug()<<path;
+            QFile file(path);
+            if(!file.isOpen())
+                continue;
+            QByteArray fileData = file.readAll();
+            QString fileText = QString::fromUtf8(fileData);
+            context.append(fileText);
+        }
+    }
+
+    context.append(baseText);
+
+    return context;
+}
+
+void KateAiPluginView::generate()
+{
+    qDebug()<<activeDocument()->mimeType();
+    if(m_webSocket && m_webSocket->isValid())
+    {
+        KTextEditor::Cursor cursor = getCurrentCursor();
+        QPointer<KTextEditor::Document> document = activeDocument();
+        QString text = assembleContext(document, cursor);
+        int id = QRandomGenerator::global()->bounded(0, std::numeric_limits<int>::max());
+
+        QJsonObject json;
+        json[QStringLiteral("action")] = QStringLiteral("infer");
+        json[QStringLiteral("request_id")] = id;
+        json[QStringLiteral("text")] = text;
+        json[QStringLiteral("max_new_tokens")] = 50;
+        json[QStringLiteral("stream")] = false;
+
+        QJsonDocument jsonDocument(json);
+        QString requestText = QString::fromUtf8(jsonDocument.toJson(QJsonDocument::JsonFormat::Compact));
+        qDebug()<<__func__<<' '<<requestText;
+        m_webSocket->sendTextMessage(requestText);
+        m_requests.insert(id, {cursor, document});
+    }
+    else
+    {
+        QMessageBox box;
+        box.setText(i18n("The AI server is not connected."));
+        box.setInformativeText(i18n("would you like to try and reconnect?"));
+        box.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+        box.setDefaultButton(QMessageBox::Yes);
+        int ret = box.exec();
+        if(ret == QMessageBox::Yes)
+            reconnect();
+    }
+}
+
+KateAiPluginView::~KateAiPluginView()
+{
+    m_mainWindow->guiFactory()->removeClient(this);
+}
+
+void KateAiPluginView::setInstruct(bool instruct)
+{
+    m_useInstruct = instruct;
+}
+
+#include "kateai.moc"
+#include "moc_kateai.cpp"

kateai.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <ktexteditor/cursor.h>
+#include <unordered_map>
+
+#include <KTextEditor/MainWindow>
+#include <KTextEditor/Plugin>
+#include <KXMLGUIClient>
+
+#include <QList>
+#include <QAction>
+#include <QWebSocket>
+#include <QPointer>
+#include <QtCore>
+
+class KateAiPlugin : public KTextEditor::Plugin
+{
+    Q_OBJECT
+private:
+    QWebSocket m_webSocket;
+    QUrl m_serverUrl;
+
+private:
+    void onConnected();
+
+    int configPages() const override
+    {
+        return 1;
+    }
+
+    KTextEditor::ConfigPage *configPage(int number = 0, QWidget *parent = nullptr) override;
+
+public:
+    explicit KateAiPlugin(QObject *parent = nullptr, const QList<QVariant> & = QList<QVariant>());
+    ~KateAiPlugin() override;
+
+    QObject *createView(KTextEditor::MainWindow *mainWindow) override;
+
+    void readConfig();
+    void reconnect();
+    Q_SIGNAL void instructChanged();
+};
+
+class KateAiPluginView : public QObject, public KXMLGUIClient
+{
+    Q_OBJECT
+private:
+    struct Request
+    {
+        KTextEditor::Cursor cursor;
+        QPointer<KTextEditor::Document> document;
+    };
+
+    KTextEditor::MainWindow *m_mainWindow;
+    QPointer<QWebSocket> m_webSocket;
+    QHash<int, Request> m_requests;
+    bool m_useInstruct = false;
+
+
+private:
+    void generate();
+    void socketMessage(const QString& message);
+    QStringList getIncludePaths(const QString& text);
+    QString assembleContext(QPointer<KTextEditor::Document> document, const KTextEditor::Cursor& cursor);
+
+    QPointer<KTextEditor::Document> activeDocument() const;
+    KTextEditor::Cursor getCurrentCursor() const;
+
+
+public:
+    KateAiPluginView(KateAiPlugin *plugin, KTextEditor::MainWindow *mainwindow, QPointer<QWebSocket> webSocket, bool instruct = false);
+    ~KateAiPluginView() override;
+    void setInstruct(bool instruct);
+
+    Q_SIGNAL void reconnect();
+};

kateai.json

@@ -0,0 +1,9 @@
+{
+    "KPlugin": {
+        "Description": "Adds the ability for kate to complete text using a llm",
+        "Name": "Kate AI",
+        "ServiceTypes": [
+            "KTextEditor/Plugin"
+        ]
+    }
+}

kateaiconfigpage.cpp

@@ -0,0 +1,65 @@
+#include "kateaiconfigpage.h"
+
+#include <KConfigGroup>
+#include <KLocalizedString>
+#include <KSharedConfig>
+
+#include <QVBoxLayout>
+#include <QLabel>
+#include <qlabel.h>
+
+KateAiConfigPage::KateAiConfigPage(QWidget *parent, KateAiPlugin *plugin)
+    : KTextEditor::ConfigPage(parent)
+    , m_plugin(plugin)
+{
+    QVBoxLayout* layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+
+    QHBoxLayout* lineLayout = new QHBoxLayout(this);
+    QLabel* lineEditLabel = new QLabel(i18n("Url for the WebSockets ExLlama Ai server:"), this);
+    lineEditLabel->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
+    lineLayout->addWidget(lineEditLabel);
+    lineLayout->addWidget(&lineUrl);
+    layout->addLayout(lineLayout);
+
+    btnCompletion.setText(i18n("Use the Ai to generate a completion"));
+    btnInstruct.setText(i18n("Use the Ai to insert a response to a instruction"));
+    layout->addWidget(&btnCompletion);
+    layout->addWidget(&btnInstruct);
+    layout->addStretch();
+
+    reset();
+}
+
+QString KateAiConfigPage::name() const
+{
+    return i18n("Ai");
+}
+
+QString KateAiConfigPage::fullName() const
+{
+    return i18n("Ai Settings");
+}
+
+QIcon KateAiConfigPage::icon() const
+{
+    return QIcon::fromTheme(QStringLiteral("text-x-generic"));
+}
+
+void KateAiConfigPage::apply()
+{
+    KConfigGroup config(KSharedConfig::openConfig(), "Ai");
+    config.writeEntry("Url", lineUrl.text());
+    config.writeEntry("Instruct", btnInstruct.isChecked());
+
+    config.sync();
+    m_plugin->readConfig();
+}
+
+void KateAiConfigPage::reset()
+{
+    KConfigGroup config(KSharedConfig::openConfig(), "Ai");
+    lineUrl.setText(config.readEntry("Url", "ws://localhost:8642"));
+    btnInstruct.setChecked(config.readEntry("Instruct", false));
+    btnCompletion.setChecked(!btnInstruct.isChecked());
+}

kateaiconfigpage.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "kateai.h"
+#include <KTextEditor/ConfigPage>
+
+#include <QLineEdit>
+#include <QRadioButton>
+
+class KateAiConfigPage : public KTextEditor::ConfigPage
+{
+    Q_OBJECT
+private:
+    QLineEdit lineUrl;
+    QRadioButton btnCompletion;
+    QRadioButton btnInstruct;
+    KateAiPlugin* m_plugin;
+
+public:
+    explicit KateAiConfigPage(QWidget *parent = nullptr, KateAiPlugin *plugin = nullptr);
+    ~KateAiConfigPage() override
+    {
+    }
+
+    QString name() const override;
+    QString fullName() const override;
+    QIcon icon() const override;
+
+    void apply() override;
+    void reset() override;
+    void defaults() override
+    {
+    }
+};

plugin.qrc

@@ -0,0 +1,6 @@
+<!DOCTYPE RCC>
+<RCC version="1.0">
+    <qresource prefix="/kxmlgui5/kateaiplugin">
+        <file>ui.rc</file>
+    </qresource>
+</RCC>

ui.rc

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE gui SYSTEM "kpartgui.dtd">
+<gui name="kateaiplugin" library="kateaiplugin" version="3">
+    <MenuBar>
+        <Menu name="tools">
+            <text>&amp;Tools</text>
+            <Action name="ai_generate" group="tools_ai"/>
+        </Menu>
+    </MenuBar>
+</gui>