mikasa-cli 1.0.1

package/src/cli/chat/chat-with-ai.js

@@ -0,0 +1,275 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { text, isCancel, cancel, intro, outro } from "@clack/prompts";
+import yoctoSpinner from "yocto-spinner";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { AIService } from "../ai/google-service.js";
+import { ChatService } from "../../services/chat.services.js";
+// import ChatService from "../ai/google-service.js";
+import { getStoredToken } from "../commands/auth/login.js";
+import prisma from "../../lib/db.js";
+
+// Configure marked to use terminal renderer
+marked.use(
+    markedTerminal({
+        // Styling options for terminal output
+        code: chalk.cyan,
+        blockquote: chalk.gray.italic,
+        heading: chalk.green.bold,
+        firstHeading: chalk.magenta.underline.bold,
+        hr: chalk.reset,
+        listitem: chalk.reset,
+        list: chalk.reset,
+        paragraph: chalk.reset,
+        strong: chalk.bold,
+        em: chalk.italic,
+        codespan: chalk.yellow.bgBlack,
+        del: chalk.dim.gray.strikethrough,
+        link: chalk.blue.underline,
+        href: chalk.blue.underline,
+    })
+);
+
+// Initialize services
+const aiService = new AIService();
+const chatService = new ChatService();
+
+async function getUserFromToken() {
+    const token = await getStoredToken();
+
+    if (!token?.access_token) {
+        throw new Error("Not authenticated. Please run 'mikasa login' first.");
+    }
+
+    const spinner = yoctoSpinner({ text: "Authenticating..." }).start();
+
+    const user = await prisma.user.findFirst({
+        where: {
+            sessions: {
+                some: { token: token.access_token },
+            },
+        },
+    });
+
+    if (!user) {
+        spinner.error("User not found");
+        throw new Error("User not found. Please login again.");
+    }
+
+    spinner.success(`Welcome back bebe.., ${user.name}!`);
+    return user;
+}
+
+async function initConversation(userId, conversationId = null, mode = "chat") {
+    const spinner = yoctoSpinner({ text: "Loading conversation..." }).start();
+
+    const conversation = await chatService.getOrCreateConversation(
+        userId,
+        conversationId,
+        mode
+    );
+
+    spinner.success("Conversation loaded");
+
+    // Display conversation info in a box
+    const conversationInfo = boxen(
+        `${chalk.bold("Conversation")}: ${conversation.title}\n${chalk.gray("ID: " + conversation.id)}\n${chalk.gray("Mode: " + conversation.mode)}`,
+        {
+            padding: 1,
+            margin: { top: 1, bottom: 1 },
+            borderStyle: "round",
+            borderColor: "cyan",
+            title: "💬 Chat Session",
+            titleAlignment: "center",
+        }
+    );
+
+    console.log(conversationInfo);
+
+    // Display existing messages if any
+    if (conversation.messages?.length > 0) {
+        console.log(chalk.yellow("📜 Previous messages:\n"));
+        displayMessages(conversation.messages);
+    }
+
+    return conversation;
+}
+
+function displayMessages(messages) {
+    messages.forEach((msg) => {
+        if (msg.role === "user") {
+            const userBox = boxen(chalk.white(msg.content), {
+                padding: 1,
+                margin: { left: 2, bottom: 1 },
+                borderStyle: "round",
+                borderColor: "blue",
+                title: "👤 You",
+                titleAlignment: "left",
+            });
+            console.log(userBox);
+        } else {
+            // Render markdown for assistant messages
+            const renderedContent = marked.parse(msg.content);
+            const assistantBox = boxen(renderedContent.trim(), {
+                padding: 1,
+                margin: { left: 2, bottom: 1 },
+                borderStyle: "round",
+                borderColor: "green",
+                title: "🤖 Assistant",
+                titleAlignment: "left",
+            });
+            console.log(assistantBox);
+        }
+    });
+}
+
+async function saveMessage(conversationId, role, content) {
+    return await chatService.addMessage(conversationId, role, content);
+}
+
+async function getAIResponse(conversationId) {
+    const spinner = yoctoSpinner({
+        text: "Mikasa was thinking...",
+        color: "cyan"
+    }).start();
+
+    const dbMessages = await chatService.getMessages(conversationId);
+    const aiMessages = chatService.formatMessagesForAI(dbMessages);
+
+    let fullResponse = "";
+    let isFirstChunk = true;
+
+    try {
+        const result = await aiService.sendMessage(aiMessages, (chunk) => {
+            // Stop spinner on first chunk and show header
+            if (isFirstChunk) {
+                spinner.stop();
+                console.log("\n");
+                const header = chalk.green.bold("🤖 Assistant:");
+                console.log(header);
+                console.log(chalk.gray("─".repeat(60)));
+                isFirstChunk = false;
+            }
+            fullResponse += chunk;
+        });
+
+        // Now render the complete markdown response
+        console.log("\n");
+        const renderedMarkdown = marked.parse(fullResponse);
+        console.log(renderedMarkdown);
+        console.log(chalk.gray("─".repeat(60)));
+        console.log("\n");
+
+        return result.content;
+    } catch (error) {
+        spinner.error("Failed to get AI response");
+        throw error;
+    }
+}
+
+async function updateConversationTitle(conversationId, userInput, messageCount) {
+    if (messageCount === 1) {
+        const title = userInput.slice(0, 50) + (userInput.length > 50 ? "..." : "");
+        await chatService.updateTitle(conversationId, title);
+    }
+}
+
+async function chatLoop(conversation) {
+    const helpBox = boxen(
+        `${chalk.gray('• Type your message and press Enter')}\n${chalk.gray('• Markdown formatting is supported in responses')}\n${chalk.gray('• Type "exit" to end conversation')}\n${chalk.gray('• Press Ctrl+C to quit anytime')}`,
+        {
+            padding: 1,
+            margin: { bottom: 1 },
+            borderStyle: "round",
+            borderColor: "gray",
+            dimBorder: true,
+        }
+    );
+
+    console.log(helpBox);
+
+    while (true) {
+        const userInput = await text({
+            message: chalk.blue("💬 Your message"),
+            placeholder: "Type your message...",
+            validate(value) {
+                if (!value || value.trim().length === 0) {
+                    return "Message cannot be empty";
+                }
+            },
+        });
+
+        // Handle cancellation (Ctrl+C)
+        if (isCancel(userInput)) {
+            const exitBox = boxen(chalk.yellow("Chat session ended. Goodbye! 👋"), {
+                padding: 1,
+                margin: 1,
+                borderStyle: "round",
+                borderColor: "yellow",
+            });
+            console.log(exitBox);
+            process.exit(0);
+        }
+
+        // Handle exit command
+        if (userInput.toLowerCase() === "exit") {
+            const exitBox = boxen(chalk.yellow("The chat session has ended, and Eren was calling me 👩🏻‍🦰, so goodbye! 👋"), {
+                padding: 1,
+                margin: 1,
+                borderStyle: "round",
+                borderColor: "yellow",
+            });
+            console.log(exitBox);
+            break;
+        }
+
+
+
+
+        // Save user message
+        await saveMessage(conversation.id, "user", userInput);
+
+        // Get messages count before AI response
+        const messages = await chatService.getMessages(conversation.id);
+
+        // Get AI response with streaming and markdown rendering
+        const aiResponse = await getAIResponse(conversation.id);
+
+        // Save AI response
+        await saveMessage(conversation.id, "assistant", aiResponse);
+
+        // Update title if first exchange
+        await updateConversationTitle(conversation.id, userInput, messages.length);
+    }
+}
+
+// Main entry point
+export async function startChat(mode = "chat", conversationId = null) {
+    try {
+        // Display intro banner
+        intro(
+            boxen(chalk.bold.cyan("🚀 Mikasa AI Chat"), {
+                padding: 1,
+                borderStyle: "double",
+                borderColor: "cyan",
+            })
+        );
+
+        const user = await getUserFromToken();
+        const conversation = await initConversation(user.id, conversationId, mode);
+        await chatLoop(conversation);
+
+        // Display outro
+        outro(chalk.green("✨ Thanks for chatting and love you...!"));
+    } catch (error) {
+        const errorBox = boxen(chalk.red(`❌ Error: ${error.message}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "red",
+        });
+        console.log(errorBox);
+        process.exit(1);
+    }
+}

package/src/cli/commands/ai/wakeUp.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import yoctoSpinner from "yocto-spinner";
+import { getStoredToken } from "../auth/login.js";
+import prisma from "../../../lib/db.js";
+import { select } from "@clack/prompts";
+import { startChat } from "../../chat/chat-with-ai.js";
+import { startToolChat } from "../../chat/chat-with-ai-tool.js";
+import { startAgentChat } from "../../chat/chat-with-ai-agent.js";
+
+const wakeUpAction = async () => {
+    const token = await getStoredToken();
+
+    if (!token?.access_token) {
+        console.log(chalk.red("Not authenticated. Please login."));
+        return;
+    }
+
+    const spinner = yoctoSpinner({ text: "Fetching User Information..." });
+    spinner.start();
+
+    const user = await prisma.user.findFirst({
+        where: {
+            sessions: {
+                some: { token: token.access_token },
+            },
+        },
+        select: {
+            id: true,
+            name: true,
+            email: true,
+            image: true,
+        },
+    });
+
+    spinner.stop();
+
+    if (!user) {
+        console.log(chalk.red("User not found."));
+        return;
+    }
+
+    console.log(chalk.green(`\nWelcome back, ${user.name}!\n`));
+
+    const choice = await select({
+        message: "Select an option:",
+        options: [
+            {
+                value: "chat",
+                label: "Chat",
+                hint: "Simple chat with AI",
+            },
+            {
+                value: "tool",
+                label: "Tool Calling",
+                hint: "Chat with tools (Google Search, Code Execution)",
+            },
+            {
+                value: "agent",
+                label: "Agentic Mode",
+                hint: "Advanced AI agent (Coming soon new versions ...)",
+            },
+        ],
+    });
+
+    switch (choice) {
+        case "chat":
+            await startChat("chat");
+            break;
+        case "tool":
+            await startToolChat();
+            break;
+        case "agent":
+            await startAgentChat();
+            break;
+    }
+};
+
+export const wakeUp = new Command("wakeup")
+    .description("Wake up the AI")
+    .action(wakeUpAction);