mikasa-cli 1.0.1

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

@@ -0,0 +1,219 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { text, isCancel, cancel, intro, outro, confirm } from "@clack/prompts";
+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";
+import { generateApplication } from "../../config/agent.config.js";
+
+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 user = await prisma.user.findFirst({
+        where: {
+            sessions: {
+                some: { token: token.access_token },
+            },
+        },
+    });
+
+    if (!user) {
+        throw new Error("User not found. Please login again.");
+    }
+
+    console.log(chalk.green(`\n✓ Welcome back, ${user.name}!\n`));
+    return user;
+}
+
+async function initConversation(userId, conversationId = null) {
+    const conversation = await chatService.getOrCreateConversation(
+        userId,
+        conversationId,
+        "agent"
+    );
+
+    const conversationInfo = boxen(
+        `${chalk.bold("Conversation")}: ${conversation.title}\n` +
+        `${chalk.gray("ID:")} ${conversation.id}\n` +
+        `${chalk.gray("Mode:")} ${chalk.magenta("Agent (Code Generator)")}\n` +
+        `${chalk.cyan("Working Directory:")} ${process.cwd()}`,
+        {
+            padding: 1,
+            margin: { top: 1, bottom: 1 },
+            borderStyle: "round",
+            borderColor: "magenta",
+            title: "🤖 Agent Mode",
+            titleAlignment: "center",
+        }
+    );
+
+    console.log(conversationInfo);
+
+    return conversation;
+}
+
+async function saveMessage(conversationId, role, content) {
+    return await chatService.addMessage(conversationId, role, content);
+}
+
+async function agentLoop(conversation) {
+    const helpBox = boxen(
+        `${chalk.cyan.bold("What can the agent do?")}\n\n` +
+        `${chalk.gray('• Generate complete applications from descriptions')}\n` +
+        `${chalk.gray('• Create all necessary files and folders')}\n` +
+        `${chalk.gray('• Include setup instructions and commands')}\n` +
+        `${chalk.gray('• Generate production-ready code')}\n\n` +
+        `${chalk.yellow.bold("Examples:")}\n` +
+        `${chalk.white('• "Build a todo app with React and Tailwind"')}\n` +
+        `${chalk.white('• "Create a REST API with Express and MongoDB"')}\n` +
+        `${chalk.white('• "Make a weather app using OpenWeatherMap API"')}\n\n` +
+        `${chalk.gray('Type "exit" to end the session')}`,
+        {
+            padding: 1,
+            margin: { bottom: 1 },
+            borderStyle: "round",
+            borderColor: "cyan",
+            title: "💡 Agent Instructions",
+        }
+    );
+
+    console.log(helpBox);
+
+    while (true) {
+        const userInput = await text({
+            message: chalk.magenta("🤖 What would you like to build?"),
+            placeholder: "Describe your application...",
+            validate(value) {
+                if (!value || value.trim().length === 0) {
+                    return "Description cannot be empty";
+                }
+                if (value.trim().length < 10) {
+                    return "Please provide more details (at least 10 characters)";
+                }
+            },
+        });
+
+        if (isCancel(userInput)) {
+            console.log(chalk.yellow("\n👋 Agent session cancelled\n"));
+            process.exit(0);
+        }
+
+        if (userInput.toLowerCase() === "exit") {
+            console.log(chalk.yellow("\n👋 Agent session ended\n"));
+            break;
+        }
+
+        const userBox = boxen(chalk.white(userInput), {
+            padding: 1,
+            margin: { top: 1, bottom: 1 },
+            borderStyle: "round",
+            borderColor: "blue",
+            title: "👤 Your Request",
+            titleAlignment: "left",
+        });
+        console.log(userBox);
+
+        // Save user message
+        await saveMessage(conversation.id, "user", userInput);
+
+        try {
+            // Generate application using structured output
+            const result = await generateApplication(
+                userInput,
+                aiService,
+                process.cwd()
+            );
+
+            if (result && result.success) {
+                // Save successful generation details
+                const responseMessage = `Generated application: ${result.folderName}\n` +
+                    `Files created: ${result.files.length}\n` +
+                    `Location: ${result.appDir}\n\n` +
+                    `Setup commands:\n${result.commands.join('\n')}`;
+
+                await saveMessage(conversation.id, "assistant", responseMessage);
+
+                // Ask if user wants to generate another app
+                const continuePrompt = await confirm({
+                    message: chalk.cyan("Would you like to generate another application?"),
+                    initialValue: false,
+                });
+
+                if (isCancel(continuePrompt) || !continuePrompt) {
+                    console.log(chalk.yellow("\n👋 Great! Check your new application.\n"));
+                    break;
+                }
+
+            } else {
+                throw new Error("Generation returned no result");
+            }
+
+        } catch (error) {
+            console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+
+            await saveMessage(conversation.id, "assistant", `Error: ${error.message}`);
+
+            const retry = await confirm({
+                message: chalk.cyan("Would you like to try again?"),
+                initialValue: true,
+            });
+
+            if (isCancel(retry) || !retry) {
+                break;
+            }
+        }
+    }
+}
+
+export async function startAgentChat(conversationId = null) {
+    try {
+        intro(
+            boxen(
+                chalk.bold.magenta("🤖 Mikasa AI - Agent Mode\n\n") +
+                chalk.gray("Autonomous Application Generator"),
+                {
+                    padding: 1,
+                    borderStyle: "double",
+                    borderColor: "magenta",
+                }
+            )
+        );
+
+        const user = await getUserFromToken();
+
+        // Warning about file system access
+        const shouldContinue = await confirm({
+            message: chalk.yellow("⚠️  The agent will create files and folders in the current directory. Continue?"),
+            initialValue: true,
+        });
+
+        if (isCancel(shouldContinue) || !shouldContinue) {
+            cancel(chalk.yellow("Agent mode cancelled"));
+            process.exit(0);
+        }
+
+        const conversation = await initConversation(user.id, conversationId);
+        await agentLoop(conversation);
+
+        outro(chalk.green.bold("\n✨ Thanks for using Agent Mode!"));
+
+    } 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/chat/chat-with-ai-tool.js

@@ -0,0 +1,377 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { text, isCancel, cancel, intro, outro, multiselect } 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";
+import {
+    availableTools,
+    getEnabledTools,
+    enableTools,
+    getEnabledToolNames,
+    resetTools
+} from "../../config/tool.config.js";
+
+// Configure marked for terminal
+marked.use(
+    markedTerminal({
+        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,
+    })
+);
+
+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, ${user.name}!`);
+    return user;
+}
+
+async function selectTools() {
+    const toolOptions = availableTools.map(tool => ({
+        value: tool.id,
+        label: tool.name,
+        hint: tool.description,
+    }));
+
+    const selectedTools = await multiselect({
+        message: chalk.cyan("Select tools to enable (Space to select, Enter to confirm):"),
+        options: toolOptions,
+        required: false,
+    });
+
+    if (isCancel(selectedTools)) {
+        cancel(chalk.yellow("Tool selection cancelled"));
+        process.exit(0);
+    }
+
+    // Enable selected tools
+    enableTools(selectedTools);
+
+    if (selectedTools.length === 0) {
+        console.log(chalk.yellow("\n⚠️  No tools selected. Mikasa will work without tools.\n"));
+    } else {
+        const toolsBox = boxen(
+            chalk.green(`✅ Enabled tools:\n${selectedTools.map(id => {
+                const tool = availableTools.find(t => t.id === id);
+                return `  • ${tool.name}`;
+            }).join('\n')}`),
+            {
+                padding: 1,
+                margin: { top: 1, bottom: 1 },
+                borderStyle: "round",
+                borderColor: "green",
+                title: "🛠️  Active Tools",
+                titleAlignment: "center",
+            }
+        );
+        console.log(toolsBox);
+    }
+
+    return selectedTools.length > 0;
+}
+
+async function initConversation(userId, conversationId = null, mode = "tool") {
+    const spinner = yoctoSpinner({ text: "Loading conversation..." }).start();
+
+    const conversation = await chatService.getOrCreateConversation(
+        userId,
+        conversationId,
+        mode
+    );
+
+    spinner.success("Conversation loaded");
+
+    // Get enabled tool names for display
+    const enabledToolNames = getEnabledToolNames();
+    const toolsDisplay = enabledToolNames.length > 0
+        ? `\n${chalk.gray("Active Tools:")} ${enabledToolNames.join(", ")}`
+        : `\n${chalk.gray("No tools enabled")}`;
+
+    // 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)}${toolsDisplay}`,
+        {
+            padding: 1,
+            margin: { top: 1, bottom: 1 },
+            borderStyle: "round",
+            borderColor: "cyan",
+            title: "💬 Tool Calling 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 if (msg.role === "assistant") {
+            const renderedContent = marked.parse(msg.content);
+            const assistantBox = boxen(renderedContent.trim(), {
+                padding: 1,
+                margin: { left: 2, bottom: 1 },
+                borderStyle: "round",
+                borderColor: "green",
+                title: "🤖 Assistant (with tools)",
+                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);
+
+    const tools = getEnabledTools();
+
+    let fullResponse = "";
+    let isFirstChunk = true;
+    const toolCallsDetected = [];
+
+    try {
+        // IMPORTANT: Pass tools in the streamText config
+        const result = await aiService.sendMessage(
+            aiMessages,
+            (chunk) => {
+                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;
+            },
+            tools,
+            (toolCall) => {
+                toolCallsDetected.push(toolCall);
+            }
+        );
+
+        // Display tool calls if any
+        if (toolCallsDetected.length > 0) {
+            console.log("\n");
+            const toolCallBox = boxen(
+                toolCallsDetected.map(tc =>
+                    `${chalk.cyan("🔧 Tool:")} ${tc.toolName}\n${chalk.gray("Args:")} ${JSON.stringify(tc.args, null, 2)}`
+                ).join("\n\n"),
+                {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: "round",
+                    borderColor: "cyan",
+                    title: "🛠️  Tool Calls",
+                }
+            );
+            console.log(toolCallBox);
+        }
+
+        // Display tool results if any
+        if (result.toolResults && result.toolResults.length > 0) {
+            const toolResultBox = boxen(
+                result.toolResults.map(tr =>
+                    `${chalk.green("✅ Tool:")} ${tr.toolName}\n${chalk.gray("Result:")} ${JSON.stringify(tr.result, null, 2).slice(0, 200)}...`
+                ).join("\n\n"),
+                {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: "round",
+                    borderColor: "green",
+                    title: "📊 Tool Results",
+                }
+            );
+            console.log(toolResultBox);
+        }
+
+        // Render 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 Mikasa 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 enabledToolNames = getEnabledToolNames();
+    const helpBox = boxen(
+        `${chalk.gray('• Type your message and press Enter')}\n${chalk.gray('• Mikasa has access to:')} ${enabledToolNames.length > 0 ? enabledToolNames.join(", ") : "No tools"}\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";
+                }
+            },
+        });
+
+        if (isCancel(userInput)) {
+            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);
+            process.exit(0);
+        }
+
+        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;
+        }
+
+        const userBox = boxen(chalk.white(userInput), {
+            padding: 1,
+            margin: { left: 2, top: 1, bottom: 1 },
+            borderStyle: "round",
+            borderColor: "blue",
+            title: "👤 You",
+            titleAlignment: "left",
+        });
+        console.log(userBox);
+
+        await saveMessage(conversation.id, "user", userInput);
+        const messages = await chatService.getMessages(conversation.id);
+        const aiResponse = await getAIResponse(conversation.id);
+        await saveMessage(conversation.id, "assistant", aiResponse);
+        await updateConversationTitle(conversation.id, userInput, messages.length);
+    }
+}
+
+export async function startToolChat(conversationId = null) {
+    try {
+        intro(
+            boxen(chalk.bold.cyan("🛠️  Mikasa AI - Tool Calling Mode"), {
+                padding: 1,
+                borderStyle: "double",
+                borderColor: "cyan",
+            })
+        );
+
+        const user = await getUserFromToken();
+
+        // Select tools
+        await selectTools();
+
+        const conversation = await initConversation(user.id, conversationId, "tool");
+        await chatLoop(conversation);
+
+        // Reset tools on exit
+        resetTools();
+
+        outro(chalk.green("✨ Thanks for using tools!"));
+    } catch (error) {
+        const errorBox = boxen(chalk.red(`❌ Error: ${error.message}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "red",
+        });
+        console.log(errorBox);
+        resetTools();
+        process.exit(1);
+    }
+}