refactor: Add model output settings instead smartprocessing setting (#220)

CodeHandler.cpp

@@ -99,6 +99,19 @@ const QVector<LanguageProperties> &getKnownLanguages()
     return knownLanguages;
 }
 
+bool CodeHandler::hasCodeBlocks(const QString &text)
+{
+    QStringList lines = text.split('\n');
+
+    for (const QString &line : lines) {
+        if (line.trimmed().startsWith("```")) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 static QHash<QString, QString> buildLanguageToCommentPrefixMap()
 {
     QHash<QString, QString> result;

CodeHandler.hpp

@@ -40,6 +40,11 @@ public:
      */
     static QString detectLanguageFromExtension(const QString &extension);
 
+    /**
+     * Detects if text contains code blocks, or returns false if this was not possible
+     */
+    static bool hasCodeBlocks(const QString &text);
+
 private:
     static QString getCommentPrefix(const QString &language);
 

LLMClientInterface.cpp

@@ -347,11 +347,21 @@ void LLMClientInterface::sendCompletionToClient(
 
     LOG_MESSAGE(QString("Completions before filter: \n%1").arg(completion));
 
-    QString processedCompletion
+    QString outputHandler = m_completeSettings.modelOutputHandler.stringValue();
-        = promptTemplate->type() == LLMCore::TemplateType::Chat
+    QString processedCompletion;
-                  && m_completeSettings.smartProcessInstuctText()
+
-              ? CodeHandler::processText(completion, Context::extractFilePathFromRequest(request))
+    if (outputHandler == "Raw text") {
+        processedCompletion = completion;
+    } else if (outputHandler == "Force processing") {
+        processedCompletion = CodeHandler::processText(completion,
+                                                       Context::extractFilePathFromRequest(request));
+    } else { // "Auto"
+        processedCompletion = CodeHandler::hasCodeBlocks(completion)
+                                  ? CodeHandler::processText(completion,
+                                                             Context::extractFilePathFromRequest(
+                                                                 request))
                                   : completion;
+    }
 
     completionItem[LanguageServerProtocol::textKey] = processedCompletion;
     QJsonObject range;

settings/CodeCompletionSettings.cpp

@@ -55,9 +55,19 @@ CodeCompletionSettings::CodeCompletionSettings()
     stream.setDefaultValue(true);
     stream.setLabelText(Tr::tr("Enable stream option"));
 
-    smartProcessInstuctText.setSettingsKey(Constants::CC_SMART_PROCESS_INSTRUCT_TEXT);
+    modelOutputHandler.setLabelText(Tr::tr("Text output proccessing mode:"));
-    smartProcessInstuctText.setDefaultValue(true);
+    modelOutputHandler.setSettingsKey(Constants::CC_MODEL_OUTPUT_HANDLER);
-    smartProcessInstuctText.setLabelText(Tr::tr("Enable smart process text from instruct model"));
+    modelOutputHandler.setDisplayStyle(Utils::SelectionAspect::DisplayStyle::ComboBox);
+    modelOutputHandler.addOption("Auto");
+    modelOutputHandler.addOption("Force processing");
+    modelOutputHandler.addOption("Raw text");
+    modelOutputHandler.setDefaultValue("Auto");
+    modelOutputHandler.setToolTip(
+        Tr::tr("Auto: Automatically detects codeblock and applies processing when found, other "
+               "text as comments\n"
+               "Force Processing: Always processes text with codeblock formatting and other text "
+               "as comments\n"
+               "Raw Text: Shows unprocessed text without any formatting"));
 
     startSuggestionTimer.setSettingsKey(Constants::СС_START_SUGGESTION_TIMER);
     startSuggestionTimer.setLabelText(Tr::tr("with delay(ms)"));
@@ -287,17 +297,14 @@ CodeCompletionSettings::CodeCompletionSettings()
                 }},
             Row{useProjectChangesCache, maxChangesCacheSize, Stretch{1}}};
 
-        return Column{
+        return Column{Row{Stretch{1}, resetToDefaults},
-            Row{Stretch{1}, resetToDefaults},
                       Space{8},
-            Group{
+                      Group{title(TrConstants::AUTO_COMPLETION_SETTINGS),
-                title(TrConstants::AUTO_COMPLETION_SETTINGS),
+                            Column{autoCompletion,
-                Column{
-                    autoCompletion,
                                    Space{8},
                                    multiLineCompletion,
                                    stream,
-                    smartProcessInstuctText,
+                                   Row{modelOutputHandler, Stretch{1}},
                                    Row{autoCompletionCharThreshold,
                                        autoCompletionTypingInterval,
                                        startSuggestionTimer,
@@ -305,18 +312,17 @@ CodeCompletionSettings::CodeCompletionSettings()
                                    showProgressWidget,
                                    useOpenFilesContext}},
                       Space{8},
-            Group{
+                      Group{title(Tr::tr("General Parameters")),
-                title(Tr::tr("General Parameters")),
                             Column{
                                 Row{genGrid, Stretch{1}},
                             }},
                       Space{8},
-            Group{title(Tr::tr("Advanced Parameters")), Column{Row{advancedGrid, Stretch{1}}}},
+                      Group{title(Tr::tr("Advanced Parameters")),
+                            Column{Row{advancedGrid, Stretch{1}}}},
                       Space{8},
                       Group{title(Tr::tr("Context Settings")), contextItem},
                       Space{8},
-            Group{
+                      Group{title(Tr::tr("Quick Refactor Settings")),
-                title(Tr::tr("Quick Refactor Settings")),
                             Column{useOpenFilesInQuickRefactor, quickRefactorSystemPrompt}},
                       Space{8},
                       Group{title(Tr::tr("Ollama Settings")), Column{Row{ollamaGrid, Stretch{1}}}},
@@ -360,7 +366,6 @@ void CodeCompletionSettings::resetSettingsToDefaults()
         resetAspect(autoCompletion);
         resetAspect(multiLineCompletion);
         resetAspect(stream);
-        resetAspect(smartProcessInstuctText);
         resetAspect(temperature);
         resetAspect(maxTokens);
         resetAspect(useTopP);
@@ -389,6 +394,7 @@ void CodeCompletionSettings::resetSettingsToDefaults()
         resetAspect(useOpenFilesContext);
         resetAspect(useOpenFilesInQuickRefactor);
         resetAspect(quickRefactorSystemPrompt);
+        resetAspect(modelOutputHandler);
     }
 }
 

settings/CodeCompletionSettings.hpp

@@ -36,7 +36,7 @@ public:
     Utils::BoolAspect autoCompletion{this};
     Utils::BoolAspect multiLineCompletion{this};
     Utils::BoolAspect stream{this};
-    Utils::BoolAspect smartProcessInstuctText{this};
+    Utils::SelectionAspect modelOutputHandler{this};
 
     Utils::IntegerAspect startSuggestionTimer{this};
     Utils::IntegerAspect autoCompletionCharThreshold{this};

settings/SettingsConstants.hpp

@@ -76,7 +76,7 @@ const char СС_AUTO_COMPLETION_TYPING_INTERVAL[] = "QodeAssist.autoCompletionTy
 const char MAX_FILE_THRESHOLD[] = "QodeAssist.maxFileThreshold";
 const char CC_MULTILINE_COMPLETION[] = "QodeAssist.ccMultilineCompletion";
 const char CC_STREAM[] = "QodeAssist.ccStream";
-const char CC_SMART_PROCESS_INSTRUCT_TEXT[] = "QodeAssist.ccSmartProcessInstructText";
+const char CC_MODEL_OUTPUT_HANDLER[] = "QodeAssist.ccModelOutputHandler";
 const char CUSTOM_JSON_TEMPLATE[] = "QodeAssist.customJsonTemplate";
 const char CA_TOKENS_THRESHOLD[] = "QodeAssist.caTokensThreshold";
 const char CA_LINK_OPEN_FILES[] = "QodeAssist.caLinkOpenFiles";

test/LLMClientInterfaceTests.cpp

@@ -278,7 +278,7 @@ if __name__ == "__main__":
         "/path/to/file.py",
         "text/python");
 
-    m_completeSettings.smartProcessInstuctText.setValue(true);
+    m_completeSettings.modelOutputHandler.setValue(0);
 
     m_requestHandler->setFakeCompletion(
         "Here's the code: ```cpp\nint main() {\n    return 0;\n}\n```");