Notes ai

backend/nodejs/controllers/ChatController.js

@@ -17,6 +17,7 @@ export default class ChatController extends BaseController {
             // Read prompt and mode from the POST body
             const prompt = req.body.prompt;
             const mode = req.body.mode || "default";
+            const destination = req.body.destination || "chat";
 
             if (!prompt) {
                 return res.status(400).json({ error: "Prompt is required" });
@@ -26,18 +27,23 @@ export default class ChatController extends BaseController {
             res.setHeader("Cache-Control", "no-cache");
             res.setHeader("Connection", "keep-alive");
 
-            const stream = await this.chatService.getChatResponse(prompt, mode);
-
-            stream.on("data", (chunk) => {
-                res.write(`data: ${chunk.toString()}\n\n`);
+            const responseOrStream = await this.chatService.getChatResponse(prompt, mode);
+            if (typeof responseOrStream === 'string') {
+                res.write(`data: ${JSON.stringify({ fullContent: responseOrStream })}\n\n`);
+                res.write("data: [DONE]\n\n");
+                return res.end();
+            }
+             responseOrStream.on("data", (chunk) => {
+                res.write(chunk.toString()+"\n");
             });
-
-            stream.on("end", () => {
+            responseOrStream.on("end", () => {
+                res.write("[DONE]\n");
                 res.end();
             });
         } catch (error) {
             console.error("Chat API Error:", error);
-            res.write("data: Error occurred while fetching response\n\n");
+            res.write(`data: {"fullContent":"ERROR: ${error.message}"}\n\n`);
+            res.write("data: [DONE]\n\n");
             res.end();
         }
     }

backend/nodejs/services/ChatService.js

@@ -4,10 +4,18 @@ import JSONStreamService from "./JSONStreamService.js";
 export default class ChatService {
     constructor() {
         this.conversationHistory = [];
+        this.quizInProgress = false;
+        this.currentQuestion = null;
+        this.correctAnswer = null;
+        this.lastAnsweredBy = null;
     }
 
     clearHistory() {
         this.conversationHistory = [];
+        this.quizInProgress = false;
+        this.currentQuestion = null;
+        this.correctAnswer = null;
+        this.lastAnsweredBy = null;
     }
 
     async getChatResponse(prompt, mode) {
@@ -16,68 +24,172 @@ export default class ChatService {
         }
 
         let formattedPrompt;
+        let isQuizAnswer = false;
+        let immediateLocalResponse = null;
+
         switch (mode) {
             case "steps":
+                this.clearHistory();
                 formattedPrompt = `Explain in a step by step format: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
             case "example":
+                this.clearHistory();
                 formattedPrompt = `Explain with a real world example: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
             case "flashcards":
+                this.clearHistory();
                 formattedPrompt = `Generate 10 questions and answers on this subject: ${prompt}`;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
                 break;
+            case "quizmaster":
+                this.clearHistory();
+                if (prompt.toLowerCase().includes("start quiz")){
+                    const topic = prompt.replace(/start quiz/i, "").trim();
+                    formattedPrompt = `Generate exactly one question, with its answer, strictly related to '${topic}' without introducing any unrelated details, 
+                        explanations, extra text, or deviations. Respond ONLY with this JSON structure:
+                        [
+                          {
+                            "Question": "[the generated question]",
+                            "Answer": "[the generated answer]"
+                          }
+                        ]
+                        DO NOT use multiple objects in the array. Combine Question and Answer in the same object. DO NOT add any other keys, explanations, or formatting.
+                        Failure to adhere to this format will result in an invalid response. Do not include additional text, formatting, alternative structures, 
+                        variables, markdown, escapes, line breaks, or placeholders`;
+                    this.quizInProgress = true;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                } else if (this.quizInProgress && prompt.toLowerCase().includes("next question")){
+                    const topic = prompt.replace(/next question/i, "").trim();
+                    formattedPrompt = `Generate exactly one more question, with its answer, strictly related to '${topic}' without introducing any unrelated details, 
+                        explanations, extra text, or deviations. Respond ONLY with this JSON structure:
+                        [
+                          {
+                            "Question": "[the generated question]",
+                            "Answer": "[the generated answer]"
+                          }
+                        ]
+                        DO NOT use multiple objects in the array. Combine Question and Answer in the same object. DO NOT add any other keys, explanations, or formatting.
+                        Failure to adhere to this format will result in an invalid response. Do not include additional text, formatting, alternative structures, 
+                        variables, markdown, escapes, line breaks, or placeholders`;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                }else if (this.quizInProgress && prompt.toLowerCase().includes("end quiz")){
+                    this.quizInProgress = false
+                    this.currentQuestion = null;
+                    this.correctAnswer = null;
+                    this.lastAnsweredBy = null;
+                    immediateLocalResponse = "The quiz has ended. Thanks for playing!";
+                } else if (this.quizInProgress && this.currentQuestion && this.correctAnswer){
+                    isQuizAnswer = true;
+                    immediateLocalResponse = this.validateQuizAnswer(prompt);
+                }else if (this.quizInProgress){
+                    immediateLocalResponse = `I'm in quiz mode right now. Type "start quiz [topic]" to start a new quiz, "next question" for another question, or "end quiz" to finish.`;
+                } else {
+                    formattedPrompt = prompt;
+                    this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                }
+                break
             default:
+                this.clearHistory();
                 formattedPrompt = prompt;
+                this.conversationHistory.push({ role: "user", content: formattedPrompt });
+                break
+        }
+        if(immediateLocalResponse !== null || isQuizAnswer) {
+            return immediateLocalResponse;
         }
-
-        // Add user input to conversation history
-        this.conversationHistory.push({ role: "user", content: formattedPrompt });
-
         try {
-            const response = await axios.post(
-                "https://ai.api.parsonlabs.com/v1/chat/completions",
-                {
-                    model: "deepseek-r1:1.5b",
-                    messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
-                    stream: true,
-                },
-                {
-                    headers: { "Content-Type": "application/json" },
-                    responseType: "stream",
-                }
-            );
+            if(mode==='quizmaster' && this.quizInProgress){
+                const res = await axios.post(
+                    "http://bappity.net:11434/v1/chat/completions",
+                    {
+                        model: "deepseek-r1:1.5b",
+                        messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
+                    },
+                    { headers: {"Content-Type": "application/json" } }
+                );
+                const fullText = res.data.choices?.[0]?.message?.content || "";
+                this.conversationHistory.push({ role:"assistant", content: fullText.trim() });
+                return fullText;
+            }else{
+                const response = await axios.post(
+                    "http://bappity.net:11434/v1/chat/completions",
+                    {
+                        model: "deepseek-r1:1.5b",
+                        messages: this.conversationHistory, // IMPORTANT! the entire history must be pushed here, not just one single message.
+                        stream: true,
+                    },
+                    {
+                        headers: { "Content-Type": "application/json" },
+                        responseType: "stream",
+                    }
+                );
 
-            // Pipe the response stream through the JSONStreamService
-            const jsonStreamService = new JSONStreamService();
-            response.data.pipe(jsonStreamService);
+                // Pipe the response stream through the JSONStreamService
+                const jsonStreamService = new JSONStreamService();
+                response.data.pipe(jsonStreamService);
 
             // Builds and stores the assistant message as it is being streamed in
-            let assistantMessage = "";
-            jsonStreamService.on("data", (data) => {
-                try {
-                    const textData = data.toString().trim();
-                    if (textData === "[DONE]") return; // Ignore the [DONE] marker
-                    const parsedData = JSON.parse(textData);
-                    if (parsedData.fullContent) {
-                        assistantMessage = parsedData.fullContent;
+                let assistantMessage = "";
+                let previousFullContent = "";
+
+                jsonStreamService.on("data", (data) => {
+                    try {
+                        const textData = data.toString().trim();
+                        if (textData === "[DONE]") return; // Ignore the [DONE] marker
+                        const parsedData = JSON.parse(textData);
+                        if (parsedData.fullContent) {
+                            const newFull = parsedData.fullContent;
+                            const diff = newFull.substring(previousFullContent.length);
+                            previousFullContent = newFull;
+                            assistantMessage = newFull;
+                        }
+                    } catch (e) {
+                        console.error("Error parsing streamed data:", e);
                     }
-                } catch (e) {
-                    console.error("Error parsing streamed data:", e);
-                }
-            });
+                });
 
-            // Stores the full assistant message in the conversation history array when stream ends
-            jsonStreamService.on("end", () => {
-                if (assistantMessage) {
-                    assistantMessage = assistantMessage.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-                    this.conversationHistory.push({ role: "assistant", content: assistantMessage });
-                }
-            });
+                // Stores the full assistant message in the conversation history array when stream ends
+                jsonStreamService.on("end", () => {
+                    if (assistantMessage) {
+                        const cleaned = assistantMessage.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+                        this.conversationHistory.push({ role: "assistant", content: cleaned });
+                    }
+                });
 
-            return jsonStreamService;
+                return jsonStreamService;
+            }
         } catch (error) {
             console.error("Chat API Error:", error);
             throw new Error("Error occurred while fetching response");
         }
     }
+    validateQuizAnswer(prompt){
+        let username = "";
+        let userAnswer = prompt;
+        const colonIndex = prompt.indexOf(':');
+        if (colonIndex > 0) {
+            username = prompt.substring(0, colonIndex).trim();
+            userAnswer = prompt.substring(colonIndex+1).trim();
+        }
+        if (this.isCorrectAnswer(userAnswer, this.correctAnswer)){
+            if(this.lastAnsweredBy){
+                return `That's correct, ${username}! But ${this.lastAnsweredby} already answered this question correctly. The answer is ${this.correctAnswer}. Type "next question" for another question.`;
+            }else{
+                this.lastAnsweredBy = username;
+                return `Correct, ${username} gets 1 exp!. The answer was ${this.correctAnswer}. Type "next question" for another question.`;
+            }
+        }else{
+            return `Sorry ${username}, that's not correct. Try again!`;
+        }
+    }
+    isCorrectAnswer(userAnswer, correctAnswer){
+        if (!userAnswer || !correctAnswer) return false
+
+        const normalUserAnswer = userAnswer.toLowerCase().trim();
+        const normalCorrectAnswer = correctAnswer.toLowerCase().trim();
+        if (normalUserAnswer.includes(normalCorrectAnswer) || normalCorrectAnswer.includes(normalUserAnswer)) return true;
+        return false
+    }
 }

backend/nodejs/services/JSONStreamService.js

@@ -102,4 +102,4 @@ export default class JSONStreamService extends Transform {
         }
         return null;
     }
-}
+}

frontend/nodejs/views/chat/partials/chatProcessing.ejs

@@ -1,24 +1,69 @@
 <script>
     // Process AI content, separating <think> tags from visible content
     function processAIContent(content) {
-        const thinkMatch = content.match(/<think>([\s\S]*?)(?:<\/think>|$)/);
-        if (!thinkMatch) {
-            return {
-                thoughts: "",
-                visible: content
-            };
+        console.log("[parser] Raw content:", content);
+        const thoughtMatches = content.match(/<think>[\s\S]*?<\/think>/g) || [];
+        const thoughts = thoughtMatches.map(match => match.replace(/<\/?think>/g, "").trim()).join("\n");
+        const strippedContent = content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+
+        let question = '';
+        let answer = '';
+
+        const isQuizMode = (window.chatMode === 'quizmaster');
+        if(isQuizMode){
+            try {
+                const jsonBlockMatch = strippedContent.match(/```json\s*([\s\S]*?)```/);
+                if (jsonBlockMatch && jsonBlockMatch[1]) {
+                    const jsonString = jsonBlockMatch[1].trim();
+                    const parsed = JSON.parse(jsonString);
+                    if (Array.isArray(parsed) && parsed.length > 0) {
+                        const first = parsed[0];
+                        question = first.Question?.toString().trim() || '';
+                        answer = first.Answer?.toString().trim() || '';
+                    }
+                } else {
+                    const start = strippedContent.indexOf('[');
+                    const end = strippedContent.lastIndexOf(']');
+                    if (start !== -1 && end !== -1) {
+                        const jsonString = strippedContent.substring(start, end + 1);
+                        const parsed = JSON.parse(jsonString);
+                        if (Array.isArray(parsed) && parsed.length > 0) {
+                            const first = parsed[0];
+                            question = first.Question?.toString().trim() || '';
+                            answer = first.Answer?.toString().trim() || '';
+                        }
+                    }
+                }
+            } catch (e) {
+                console.warn("Failed to parse JSON from AI:", e);
+            }
+            if (answer) {
+            window.quizCorrectAnswer = answer;
+            }
         }
-        const thoughtContent = thinkMatch[1];
-        let visibleContent = content.replace(/<think>[\s\S]*?(?:<\/think>|$)/, "");
-        return {
-            thoughts: thoughtContent,
-            visible: visibleContent
+        const visible = (isQuizMode && question)
+            ? `${question}\n\nYourName: YourAnswer`
+            : strippedContent;
+        return{
+            thoughts,
+            visible,
+            question,
+            answer
         };
+        console.log("[parser] Stripped content:", strippedContent);
+        console.log("[parser] Returning visible:", visible);
     }
 
+
     // Render the full AI response into the container
     function renderFullResponse(fullRawContent, container, isFinal = false) {
+        const $container = $(container);
+        if ($container.length ===0) {
+            console.error('Container not found for AI response.');
+            return;
+        }
         const processedContent = processAIContent(fullRawContent);
+        $container.empty();
         // Retrieve the current default from settings.
         const thoughtsDefault = $('input[name="thoughtsDefault"]:checked').val();
         if (typeof window.persistedThoughtsState === 'undefined') {
@@ -41,7 +86,7 @@
             innerDiv.className = 'markdown-content';
             innerDiv.innerHTML = processMathContent(processedContent.thoughts);
             detailsElement.appendChild(innerDiv);
-            container.appendChild(detailsElement);
+            container.append(detailsElement);
 
             detailsElement.addEventListener('toggle', function () {
                 window.persistedThoughtsState = detailsElement.open;
@@ -77,4 +122,4 @@
             return escapeMap[match];
         });
     }
-</script>
+</script>