mikasa-cli 1.0.1

package/src/config/agent.config.js

@@ -0,0 +1,166 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { generateObject } from 'ai';
+import { z } from 'zod';
+
+/**
+ * Zod schema for structured application generation
+ */
+const ApplicationSchema = z.object({
+    folderName: z.string().describe('Kebab-case folder name for the application'),
+    description: z.string().describe('Brief description of what was created'),
+    files: z.array(
+        z.object({
+            path: z.string().describe('Relative file path (e.g., src/App.jsx)'),
+            content: z.string().describe('Complete file content'),
+        })
+    ).describe('All files needed for the application'),
+    setupCommands: z.array(z.string()).describe('Bash commands to setup and run (e.g., npm install, npm run dev)'),
+});
+
+/**
+ * Console logging helpers
+ */
+function printSystem(message) {
+    console.log(message);
+}
+
+/**
+ * Display file tree structure
+ */
+function displayFileTree(files, folderName) {
+    printSystem(chalk.cyan('\n📂 Project Structure:'));
+    printSystem(chalk.white(`${folderName}/`));
+
+    const filesByDir = {};
+    files.forEach(file => {
+        const parts = file.path.split('/');
+        const dir = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+
+        if (!filesByDir[dir]) {
+            filesByDir[dir] = [];
+        }
+        filesByDir[dir].push(parts[parts.length - 1]);
+    });
+
+    Object.keys(filesByDir).sort().forEach(dir => {
+        if (dir) {
+            printSystem(chalk.white(`├── ${dir}/`));
+            filesByDir[dir].forEach(file => {
+                printSystem(chalk.white(`│   └── ${file}`));
+            });
+        } else {
+            filesByDir[dir].forEach(file => {
+                printSystem(chalk.white(`├── ${file}`));
+            });
+        }
+    });
+}
+
+/**
+ * Create application files
+ */
+async function createApplicationFiles(baseDir, folderName, files) {
+    const appDir = path.join(baseDir, folderName);
+
+    await fs.mkdir(appDir, { recursive: true });
+    printSystem(chalk.cyan(`\n📁 Created directory: ${folderName}/`));
+
+    for (const file of files) {
+        const filePath = path.join(appDir, file.path);
+        const fileDir = path.dirname(filePath);
+
+        await fs.mkdir(fileDir, { recursive: true });
+        await fs.writeFile(filePath, file.content, 'utf8');
+        printSystem(chalk.green(`  ✓ ${file.path}`));
+    }
+
+    return appDir;
+}
+
+/**
+ * Generate application using structured output
+ */
+export async function generateApplication(description, aiService, cwd = process.cwd()) {
+    try {
+        printSystem(chalk.cyan('\n🤖 Agent Mode: Generating your application...\n'));
+        printSystem(chalk.gray(`Request: ${description}\n`));
+
+        printSystem(chalk.magenta('🤖 Generating structured output...\n'));
+
+
+        const result = await generateObject({
+            model: aiService.model,
+            schema: ApplicationSchema,
+            prompt: `Create a complete, production-ready application for: ${description}
+
+CRITICAL REQUIREMENTS:
+1. Generate ALL files needed for the application to run
+2. Include package.json with ALL dependencies and correct versions (if needed)
+3. Include README.md with setup instructions
+4. Include configuration files (.gitignore, etc.) if needed
+5. Write clean, well-commented, production-ready code
+6. Include error handling and input validation
+7. Use modern JavaScript/TypeScript best practices
+8. Make sure all imports and paths are correct
+9. NO PLACEHOLDERS - everything must be complete and working
+10. For simple HTML/CSS/JS projects, you can skip package.json if not needed
+
+Provide:
+- A meaningful kebab-case folder name
+- All necessary files with complete content
+- Setup commands (for example: cd folder, npm install, npm run dev OR just open index.html)
+- Make it visually appealing and functional`,
+        });
+
+        const application = result.object;
+
+        printSystem(chalk.green(`\n✅ Generated: ${application.folderName}\n`));
+        printSystem(chalk.gray(`Description: ${application.description}\n`));
+
+        if (!application.files || application.files.length === 0) {
+            throw new Error('No files were generated');
+        }
+
+        printSystem(chalk.green(`Files: ${application.files.length}\n`));
+
+        // Display file tree
+        displayFileTree(application.files, application.folderName);
+
+        // Create application directory and files
+        printSystem(chalk.cyan('\n📝 Creating files...\n'));
+        const appDir = await createApplicationFiles(cwd, application.folderName, application.files);
+
+        // Display results
+        printSystem(chalk.green.bold(`\n✨ Application created successfully!\n`));
+        printSystem(chalk.cyan(`📁 Location: ${chalk.bold(appDir)}\n`));
+
+        // Display setup commands
+        if (application.setupCommands && application.setupCommands.length > 0) {
+            printSystem(chalk.cyan('📋 Next Steps:\n'));
+            printSystem(chalk.white('```bash'));
+            application.setupCommands.forEach(cmd => {
+                printSystem(chalk.white(cmd));
+            });
+            printSystem(chalk.white('```\n'));
+        } else {
+            printSystem(chalk.yellow('ℹ️  No setup commands provided\n'));
+        }
+
+        return {
+            folderName: application.folderName,
+            appDir,
+            files: application.files.map(f => f.path),
+            commands: application.setupCommands || [],
+            success: true,
+        };
+
+    } catch (err) {
+        printSystem(chalk.red(`\n❌ Error generating application: ${err.message}\n`));
+        if (err.stack) {
+            printSystem(chalk.dim(err.stack + '\n'));
+        }
+        throw err;
+    }
+}

package/src/config/google.config.js

@@ -0,0 +1,8 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+export const config = {
+    googleApiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+    model: process.env.MIKASA_MODEL || "gemini-2.5-flash",
+}

package/src/config/tool.config.js

@@ -0,0 +1,112 @@
+import { google } from '@ai-sdk/google';
+import chalk from 'chalk';
+
+/**
+ * Available Google Generative AI tools configuration
+ * Note: Tools are instantiated lazily to avoid initialization errors
+ */
+export const availableTools = [
+    {
+        id: 'google_search',
+        name: 'Google Search',
+        description: 'Access the latest information using Google search. Useful for current events, news, and real-time information.',
+        getTool: () => google.tools.googleSearch({}),
+        enabled: false,
+    },
+    {
+        id: 'code_execution',
+        name: 'Code Execution',
+        description: 'Generate and execute Python code to perform calculations, solve problems, or provide accurate information.',
+        getTool: () => google.tools.codeExecution({}),
+        enabled: false,
+    },
+    {
+        id: 'url_context',
+        name: 'URL Context',
+        description: 'Provide specific URLs that you want the model to analyze directly from the prompt. Supports up to 20 URLs per request.',
+        getTool: () => google.tools.urlContext({}),
+        enabled: false,
+    },
+];
+
+/**
+ * Get enabled tools as a tools object for AI SDK
+ */
+export function getEnabledTools() {
+    const tools = {};
+
+    try {
+        for (const toolConfig of availableTools) {
+            if (toolConfig.enabled) {
+                // Instantiate the tool when needed
+                tools[toolConfig.id] = toolConfig.getTool();
+            }
+        }
+
+        // Debug logging
+        if (Object.keys(tools).length > 0) {
+            console.log(chalk.gray(`[DEBUG] Enabled tools: ${Object.keys(tools).join(', ')}`));
+        } else {
+            console.log(chalk.yellow('[DEBUG] No tools enabled'));
+        }
+
+        return Object.keys(tools).length > 0 ? tools : undefined;
+    } catch (error) {
+        console.error(chalk.red('[ERROR] Failed to initialize tools:'), error.message);
+        console.error(chalk.yellow('Make sure you have @ai-sdk/google version 2.0+ installed'));
+        console.error(chalk.yellow('Run: npm install @ai-sdk/google@latest'));
+        return undefined;
+    }
+}
+
+/**
+ * Toggle a tool's enabled state
+ */
+export function toggleTool(toolId) {
+    const tool = availableTools.find(t => t.id === toolId);
+    if (tool) {
+        tool.enabled = !tool.enabled;
+        console.log(chalk.gray(`[DEBUG] Tool ${toolId} toggled to ${tool.enabled}`));
+        return tool.enabled;
+    }
+    console.log(chalk.red(`[DEBUG] Tool ${toolId} not found`));
+    return false;
+}
+
+/**
+ * Enable specific tools
+ */
+export function enableTools(toolIds) {
+    console.log(chalk.gray('[DEBUG] enableTools called with:'), toolIds);
+
+    availableTools.forEach(tool => {
+        const wasEnabled = tool.enabled;
+        tool.enabled = toolIds.includes(tool.id);
+
+        if (tool.enabled !== wasEnabled) {
+            console.log(chalk.gray(`[DEBUG] ${tool.id}: ${wasEnabled} → ${tool.enabled}`));
+        }
+    });
+
+    const enabledCount = availableTools.filter(t => t.enabled).length;
+    console.log(chalk.gray(`[DEBUG] Total tools enabled: ${enabledCount}/${availableTools.length}`));
+}
+
+/**
+ * Get all enabled tool names
+ */
+export function getEnabledToolNames() {
+    const names = availableTools.filter(t => t.enabled).map(t => t.name);
+    console.log(chalk.gray('[DEBUG] getEnabledToolNames returning:'), names);
+    return names;
+}
+
+/**
+ * Reset all tools (disable all)
+ */
+export function resetTools() {
+    availableTools.forEach(tool => {
+        tool.enabled = false;
+    });
+    console.log(chalk.gray('[DEBUG] All tools have been reset (disabled)'));
+}

package/src/index.js

@@ -0,0 +1,119 @@
+// import express from 'express';
+// import dotenv from 'dotenv';
+// import { fromNodeHeaders, toNodeHandler } from "better-auth/node";
+// import cors from 'cors';
+// import { auth } from './lib/auth.js';
+
+// dotenv.config();
+
+// const app = express();
+// app.use(cors({
+//     origin: 'http://localhost:3000',
+//     methods: ['GET', 'POST', 'PUT', 'DELETE'],
+//     credentials: true,
+// }));
+
+
+// app.all("/api/auth/*spllat", toNodeHandler(auth));
+// app.use(express.json());
+// const PORT = process.env.PORT || 5000;
+
+// app.get('/api/me', async (req, res) => {
+//     const session = await auth.getSession({
+//         headers: fromNodeHeaders(req.headers),
+//     });
+// });
+
+// // app.get("/", (req, res) => {
+// //     res.redirect("http://localhost:3000/");
+// // });
+
+
+// app.listen(PORT, () => {
+//     console.log(`Server is running on http://localhost:${PORT}`);
+// });
+
+
+
+
+import express from "express";
+import dotenv from "dotenv";
+import cors from "cors";
+import { fromNodeHeaders, toNodeHandler } from "better-auth/node";
+import { auth } from "./lib/auth.js";
+
+dotenv.config();
+
+const app = express();
+
+app.use(cors({
+    origin: "https://mikasa-cli-xwcm.vercel.app",
+    credentials: true,
+}));
+
+app.use(express.json());
+
+// ✅ REGEX ROUTE (WORKS WITH path-to-regexp v8)
+app.all(/^\/api\/auth\/.*$/, toNodeHandler(auth));
+
+// app.get("/api/me", async (req, res) => {
+//     const session = await auth.getSession({
+//         headers: fromNodeHeaders(req.headers),
+//     });
+//     res.json(session);
+// });
+
+// Fixed: This endpoint now properly handles Bearer token authentication
+app.get("/api/me", async (req, res) => {
+    try {
+        const session = await auth.api.getSession({
+            headers: fromNodeHeaders(req.headers),
+        });
+
+        if (!session) {
+            return res.status(401).json({ error: "No active session" });
+        }
+
+        return res.json(session);
+    } catch (error) {
+        console.error("Session error:", error);
+        return res.status(500).json({ error: "Failed to get session", details: error.message });
+    }
+});
+
+
+// You can remove this endpoint if you're using the Bearer token approach above
+app.get("/api/me/:access_token", async (req, res) => {
+    const { access_token } = req.params;
+    console.log(access_token);
+
+    try {
+        const session = await auth.api.getSession({
+            headers: {
+                authorization: `Bearer ${access_token}`
+            }
+        });
+
+        if (!session) {
+            return res.status(401).json({ error: "Invalid token" });
+        }
+
+        return res.json(session);
+    } catch (error) {
+        console.error("Token validation error:", error);
+        return res.status(401).json({ error: "Unauthorized", details: error.message });
+    }
+});
+
+
+app.get("/device", (req, res) => {
+    const { user_code } = req.query;
+    res.redirect(`https://mikasa-cli-xwcm.vercel.app/device?user_code=${user_code}`);
+});
+
+const PORT = process.env.PORT || 5000;
+
+app.listen(PORT, () => {
+    console.log(`Server running on http://localhost:${PORT}`);
+});
+

package/src/lib/auth-client.js

@@ -0,0 +1,9 @@
+import { deviceAuthorizationClient } from "better-auth/client/plugins"
+import { createAuthClient } from "better-auth/client"
+
+export const authClient = createAuthClient({
+    baseURL: "https://mikasa-cli-2.onrender.com",
+    plugins: [
+        deviceAuthorizationClient(),
+    ],
+})

package/src/lib/auth.js

@@ -0,0 +1,52 @@
+import { betterAuth } from 'better-auth';
+import { prismaAdapter } from 'better-auth/adapters/prisma';
+import prisma from './db.js';
+import { deviceAuthorization } from "better-auth/plugins";
+
+export const auth = betterAuth({
+    database: prismaAdapter(prisma, {
+        provider: 'postgresql', // or 'postgresql', 'mysql', etc.
+    }),
+    basePath: '/api/auth',
+    trustedOrigins: ['https://mikasa-cli-xwcm.vercel.app'],
+    plugins: [
+        deviceAuthorization({
+            // verificationUri: "/device",
+            expiresIn: "30m", // default is 15 minutes
+            interval: "5s", // default is 5 seconds
+        }),
+    ],
+    socialProviders: {
+        github: {
+            clientId: process.env.GITHUB_CLIENT_ID || "Ov23lir2byjlHCgWLvEf",
+            clientSecret: process.env.GITHUB_CLIENT_SECRET || "1508f24efb3a1969480348b36b35302b6ad07952",
+        }
+    },
+    // logger: {
+    //     level: "debug"
+    // }
+});
+
+
+// import { betterAuth } from "better-auth";
+// import { prismaAdapter } from "better-auth/adapters/prisma";
+// import prisma from "./db.js";
+
+// export const auth = betterAuth({
+//     basePath: "/api/auth",
+//     origin: "http://localhost:30005",
+//     trustedOrigins: ["http://localhost:3000"],
+
+//     database: prismaAdapter(prisma, {
+//         provider: "postgresql",
+//     }),
+
+//     socialProviders: {
+//         github: {
+//             clientId: process.env.GITHUB_CLIENT_ID,
+//             clientSecret: process.env.GITHUB_CLIENT_SECRET,
+//         },
+//     },
+// });
+
+

package/src/lib/db.js

@@ -0,0 +1,9 @@
+import { PrismaClient } from '@prisma/client';
+
+
+const globalForPrisma = global;
+const prisma = new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+
+export default prisma;

package/src/services/chat.services.js

@@ -0,0 +1,152 @@
+
+import { auth } from "../lib/auth.js";
+import prisma from "../lib/db.js";
+
+export class ChatService {
+    /**
+     * Create a new conversation
+     * @param {string} userId - User ID
+     * @param {string} mode - chat, tool, or agent
+     * @param {string} title - Optional conversation title
+     */
+    async createConversation(userId, mode = "chat", title = null) {
+
+        return await prisma.conversation.create({
+            data: {
+                userId,
+                mode,
+                title: title || `New ${mode} conversation`,
+            },
+        });
+    }
+
+    /**
+     * Get or create a conversation for user
+     * @param {string} userId - User ID
+     * @param {string} conversationId - Optional conversation ID
+     * @param {string} mode - chat, tool, or agent
+     */
+    async getOrCreateConversation(userId, conversationId = null, mode = "chat") {
+        if (conversationId) {
+            const conversation = await prisma.conversation.findFirst({
+                where: {
+                    id: conversationId,
+                    userId,
+                },
+                include: {
+                    messages: {
+                        orderBy: { createdAt: "asc" },
+                    },
+                },
+            });
+
+            if (conversation) return conversation;
+        }
+
+        // Create new conversation if not found or not provided
+        return await this.createConversation(userId, mode);
+    }
+
+    /**
+     * Add a message to conversation
+     * @param {string} conversationId - Conversation ID
+     * @param {string} role - user, assistant, system, tool
+     * @param {string|object} content - Message content
+     */
+    async addMessage(conversationId, role, content) {
+        // Convert content to JSON string if it's an object
+        const contentStr = typeof content === "string"
+            ? content
+            : JSON.stringify(content);
+
+        return await prisma.message.create({
+            data: {
+                conversationId,
+                role,
+                content: contentStr,
+            },
+        });
+    }
+
+    /**
+     * Get conversation messages
+     * @param {string} conversationId - Conversation ID
+     */
+    async getMessages(conversationId) {
+        const messages = await prisma.message.findMany({
+            where: { conversationId },
+            orderBy: { createdAt: "asc" },
+        });
+
+        // Parse JSON content back to objects if needed
+        return messages.map((msg) => ({
+            ...msg,
+            content: this.parseContent(msg.content),
+        }));
+    }
+
+    /**
+     * Get all conversations for a user
+     * @param {string} userId - User ID
+     */
+    async getUserConversations(userId) {
+        return await prisma.conversation.findMany({
+            where: { userId },
+            orderBy: { updatedAt: "desc" },
+            include: {
+                messages: {
+                    take: 1,
+                    orderBy: { createdAt: "desc" },
+                },
+            },
+        });
+    }
+
+    /**
+     * Delete a conversation
+     * @param {string} conversationId - Conversation ID
+     * @param {string} userId - User ID (for security)
+     */
+    async deleteConversation(conversationId, userId) {
+        return await prisma.conversation.deleteMany({
+            where: {
+                id: conversationId,
+                userId,
+            },
+        });
+    }
+
+    /**
+     * Update conversation title
+     * @param {string} conversationId - Conversation ID
+     * @param {string} title - New title
+     */
+    async updateTitle(conversationId, title) {
+        return await prisma.conversation.update({
+            where: { id: conversationId },
+            data: { title },
+        });
+    }
+
+    /**
+     * Helper to parse content (JSON or string)
+     */
+    parseContent(content) {
+        try {
+            return JSON.parse(content);
+        } catch {
+            return content;
+        }
+    }
+
+    /**
+     * Format messages for AI SDK
+     * @param {Array} messages - Database messages
+     */
+    formatMessagesForAI(messages) {
+        return messages.map((msg) => ({
+            role: msg.role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        }));
+    }
+}