maverick-ai-cli 1.0.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "maverick-ai-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "maverick": "./src/cli/main.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node src/index.js",
+    "dev": "nodemon src/index.js"
+  },
+  "keywords": [],
+  "author": "CodeMaverick-143 AKA Arpit Sarang",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@ai-sdk/google": "^2.0.33",
+    "@clack/prompts": "^0.11.0",
+    "@prisma/client": "^6.19.0",
+    "ai": "^5.0.93",
+    "better-auth": "^1.3.34",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "figlet": "^1.9.4",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "nodemon": "^3.1.11",
+    "open": "^11.0.0",
+    "prisma": "^6.19.0",
+    "yocto-spinner": "^1.0.0",
+    "zod": "^4.1.12"
+  }
+}

package/prisma/migrations/20251116054155_start/migration.sql

@@ -0,0 +1,6 @@
+-- CreateTable
+CREATE TABLE "Test" (
+    "id" TEXT NOT NULL,
+
+    CONSTRAINT "Test_pkey" PRIMARY KEY ("id")
+);

package/prisma/migrations/20251116060620_authentication/migration.sql

@@ -0,0 +1,69 @@
+-- CreateTable
+CREATE TABLE "user" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "email" TEXT NOT NULL,
+    "emailVerified" BOOLEAN NOT NULL DEFAULT false,
+    "image" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "user_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "session" (
+    "id" TEXT NOT NULL,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "token" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "ipAddress" TEXT,
+    "userAgent" TEXT,
+    "userId" TEXT NOT NULL,
+
+    CONSTRAINT "session_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "account" (
+    "id" TEXT NOT NULL,
+    "accountId" TEXT NOT NULL,
+    "providerId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "accessToken" TEXT,
+    "refreshToken" TEXT,
+    "idToken" TEXT,
+    "accessTokenExpiresAt" TIMESTAMP(3),
+    "refreshTokenExpiresAt" TIMESTAMP(3),
+    "scope" TEXT,
+    "password" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "account_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "verification" (
+    "id" TEXT NOT NULL,
+    "identifier" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "verification_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "user_email_key" ON "user"("email");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "session_token_key" ON "session"("token");
+
+-- AddForeignKey
+ALTER TABLE "session" ADD CONSTRAINT "session_userId_fkey" FOREIGN KEY ("userId") REFERENCES "user"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "account" ADD CONSTRAINT "account_userId_fkey" FOREIGN KEY ("userId") REFERENCES "user"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20251116104449_device_flow/migration.sql

@@ -0,0 +1,15 @@
+-- CreateTable
+CREATE TABLE "deviceCode" (
+    "id" TEXT NOT NULL,
+    "deviceCode" TEXT NOT NULL,
+    "userCode" TEXT NOT NULL,
+    "userId" TEXT,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "status" TEXT NOT NULL,
+    "lastPolledAt" TIMESTAMP(3),
+    "pollingInterval" INTEGER,
+    "clientId" TEXT,
+    "scope" TEXT,
+
+    CONSTRAINT "deviceCode_pkey" PRIMARY KEY ("id")
+);

package/prisma/migrations/20251117173518_migraton_ai_conversation/migration.sql

@@ -0,0 +1,31 @@
+-- CreateTable
+CREATE TABLE "Conversation" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "title" TEXT,
+    "mode" TEXT NOT NULL DEFAULT 'chat',
+    "creadetAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Conversation_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Message" (
+    "id" TEXT NOT NULL,
+    "conversationId" TEXT NOT NULL,
+    "role" TEXT NOT NULL,
+    "content" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Message_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "Message_conversationId_idx" ON "Message"("conversationId");
+
+-- AddForeignKey
+ALTER TABLE "Conversation" ADD CONSTRAINT "Conversation_userId_fkey" FOREIGN KEY ("userId") REFERENCES "user"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Message" ADD CONSTRAINT "Message_conversationId_fkey" FOREIGN KEY ("conversationId") REFERENCES "Conversation"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

package/prisma/schema.prisma

@@ -0,0 +1,112 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model Test {
+  id String @id @default(cuid())
+}
+
+model User {
+  id            String         @id
+  name          String
+  email         String
+  emailVerified Boolean        @default(false)
+  image         String?
+  createdAt     DateTime       @default(now())
+  updatedAt     DateTime       @default(now()) @updatedAt
+  sessions      Session[]
+  accounts      Account[]
+  conversations Conversation[]
+
+  @@unique([email])
+  @@map("user")
+}
+
+model Session {
+  id        String   @id
+  expiresAt DateTime
+  token     String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  ipAddress String?
+  userAgent String?
+  userId    String
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([token])
+  @@map("session")
+}
+
+model Account {
+  id                    String    @id
+  accountId             String
+  providerId            String
+  userId                String
+  user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  accessToken           String?
+  refreshToken          String?
+  idToken               String?
+  accessTokenExpiresAt  DateTime?
+  refreshTokenExpiresAt DateTime?
+  scope                 String?
+  password              String?
+  createdAt             DateTime  @default(now())
+  updatedAt             DateTime  @updatedAt
+
+  @@map("account")
+}
+
+model Verification {
+  id         String   @id
+  identifier String
+  value      String
+  expiresAt  DateTime
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @default(now()) @updatedAt
+
+  @@map("verification")
+}
+
+model DeviceCode {
+  id              String    @id
+  deviceCode      String
+  userCode        String
+  userId          String?
+  expiresAt       DateTime
+  status          String
+  lastPolledAt    DateTime?
+  pollingInterval Int?
+  clientId        String?
+  scope           String?
+
+  @@map("deviceCode")
+}
+
+model Conversation {
+  id        String   @id @default(cuid())
+  userId    String
+  title     String?
+  mode      String   @default("chat")
+  creadetAt DateTime @default(now())
+  updatedAt DateTime @default(now()) @updatedAt
+
+  user     User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  messages Message[]
+}
+
+model Message {
+  id             String   @id @default(cuid())
+  conversationId String
+  role           String
+  content        String
+  createdAt      DateTime @default(now())
+
+  consversation Conversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+
+  @@index([conversationId])
+}

package/src/cli/ai/google-service.js

@@ -0,0 +1,99 @@
+import { google } from "@ai-sdk/google";
+import { convertToModelMessages, streamText } from "ai";
+import { config } from "../../config/google.config.js";
+import chalk from "chalk"
+
+
+export class AIService {
+    constructor() {
+        if (!config.googleApiKey) {
+            throw new Error("GOOGLE_API_KEY is not set in env")
+        }
+
+        this.model = google(config.model, {
+            apiKey: config.googleApiKey,
+        })
+    }
+
+
+
+    async sendMessage(messages, onChunk, tools = undefined, onToolCall = null) {
+        try {
+            const streamConfig = {
+                model: this.model,
+                messages: messages,
+            }
+
+            if (tools && Object.keys(tools).length > 0) {
+                streamConfig.tools = tools;
+                streamConfig.maxSteps = 5 // Allow up to 5 tool calls steps
+
+                console.log(chalk.gray(`[DEBUG] Tools enabled : ${Object.keys(tools).join(", ")}`))
+            }
+
+
+
+            const result = streamText(streamConfig);
+            let fullResponse = " "
+
+            for await (const chunk of result.textStream) {
+                fullResponse += chunk;
+                if (onChunk) {
+                    onChunk(chunk)
+                }
+            }
+
+            const fullResult = result;
+            const toolCalls = [];
+            const toolResults = []
+
+            if (fullResult.steps && Array.isArray(fullResult.steps)) {
+                for (const step of fullResult.steps) {
+                    if (step.toolCall && step.toolCall.lenght > 0) {
+                        for (const toolCall of step.toolCalls) {
+                            toolCalls.push(toolCall)
+
+                            if (onToolCall) {
+                                onToolCall(toolCall)
+                            }
+                        }
+                    }
+
+                    if (step.toolResult && step.toolResult.length > 0) {
+                        toolResults.push(toolResult)
+                    }
+                }
+            }
+
+
+            return {
+                content: fullResponse,
+                finishResponse: fullResult.finishResponse,
+                usage: fullResult.usage,
+                toolCalls,
+                toolResults,
+                steps: fullResult.steps
+            }
+
+        } catch (error) {
+
+            console.error(chalk.red("AI Service Error:"), error.message);
+            throw error;
+        }
+    }
+
+    async getMessage(messages, tools = undefined) {
+        let fullResponse = "";
+
+        const result = await this.sendMessage(messages, (chunk) => {
+            fullResponse += chunk
+        }, tools)
+
+        return result.content
+
+
+    }
+
+
+
+}

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

@@ -0,0 +1,293 @@
+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 "../../service/chat.service.js";
+import { getStoredToken } from "../../lib/token.js"
+import prisma from "../../lib/db.js";
+import { yo } from "zod/v4/locales";
+
+marked.use(
+    markedTerminal({
+        code: chalk.cyan,
+        blockquote: chalk.gray.italic,
+        heading: chalk.green.bold,        // all headings
+        firstHeading: chalk.green.bold.underline, // H1 specifically
+        hr: chalk.gray,                   // horizontal rules
+        listitem: chalk.white,            // bullet items
+        list: chalk.white,                // list container
+        paragraph: chalk.white,           // paragraphs
+        strong: chalk.bold,               // **bold**
+        em: chalk.italic,                 // *italic*
+        codespan: chalk.bgBlack.white,    // inline code
+        del: chalk.strikethrough,         // ~~strikethrough~~
+        link: chalk.blue,                 // markdown link text
+        href: chalk.underline.blue,       // link href (actual URL)
+    })
+);
+
+
+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 'maverick 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 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")
+
+    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)
+
+    if (conversation.message?.length > 0) {
+        console.log(chalk.yellow(" Previous messages: \n"));
+        displayMessages(conversation.messages);
+    }
+
+    return conversation
+}
+
+
+function displayMessages(messages) {
+    messages.forEach(message => {
+        if (message.role === "user") {
+            const userBox = boxen(chalk.white(message.content), {
+                padding: 1,
+                margin: { top: 1, bottom: 1, left: 2, right: 2 },
+                borderStyle: "round",
+                borderColor: "cyan",
+                title: "You",
+                titleAlignment: "left"
+            })
+            console.log(userBox)
+        } else {
+            const renderContent = marked.parse(message.content)
+            const assistantBox = boxen(chalk.white(renderContent.trim()), {
+                padding: 1,
+                margin: { top: 1, bottom: 1, left: 2, right: 2 },
+                borderStyle: "round",
+                borderColor: "cyan",
+                title: "Assistant",
+                titleAlignment: "right"
+            })
+            console.log(assistantBox)
+        }
+    });
+}
+
+
+async function saveMessage(conversationId, role, content) {
+    const message = await chatService.createMessage(conversationId, role, content)
+    return message
+}
+
+
+
+async function getAIResponse(conversationId) {
+    const spinner = yoctoSpinner({ text: "Thinking...", color: "yellow" }).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) => {
+            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
+        });
+
+
+        console.log("\n");
+        const renderedMarkedown = marked.parse(fullResponse)
+        console.log(renderedMarkedown)
+        console.log(chalk.gray("-".repeat(60)))
+        console.log("\n")
+
+        return result.content;
+
+    } catch (error) {
+        spinner.error("Error getting AI response:")
+        throw error
+    }
+}
+
+
+
+
+async function updateConversationTitle(conversationId, userInput, messageCount) {
+    if (messageCount === 1) {
+        const spinner = yoctoSpinner({ text: "Updating conversation title...." }).start();
+        const title = userInput.slice(0, 50) + (userInput.length > 50 ? "..." : "");
+        await chatService.updateConversationTitle(conversationId, title)
+        spinner.success("Conversation title updated")
+    }
+}
+
+
+const chatLoop = async (conversation) => {
+    try {
+
+        const helpBox = boxen(`${chalk.gray(' • Type your messgae and press enter')}\n${chalk.gray(' • Markdown formatting is supported in responses')}\n${chalk.gray('• Type "exit" to end the conversation')}\n${chalk.gray('• press Ctrl+C to exit')}`,
+            {
+                padding: 1,
+                margin: 1,
+                borderStyle: "round",
+                borderColor: "cyan",
+                title: "Help",
+                titleAlignment: "center",
+                dimBorder: true
+            })
+        console.log(helpBox)
+        while (true) {
+            const userInput = await text({
+                message: chalk.blue("Your Message...."),
+                placeholder: "Type your message here...",
+                validate(value) {
+                    if (value.trim() === "") return "Message cannot be empty"
+                }
+
+            })
+
+            if (isCancel(userInput)) {
+                const exitBox = boxen(chalk.yellow("Chat session ended. GoodBye! "), {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: "round",
+                    borderColor: "cyan",
+                    title: "GoodBye",
+                    titleAlignment: "center",
+                    dimBorder: true
+                })
+                console.log(exitBox)
+                process.exit(0)
+            }
+
+
+            if (userInput.trim().toLowerCase() === "exit") {
+                const exitBox = boxen(chalk.yellow("Chat session ended. GoodBye! "), {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: "round",
+                    borderColor: "cyan",
+                    title: "GoodBye",
+                    titleAlignment: "center",
+                    dimBorder: true
+                })
+                console.log(exitBox)
+                break
+            }
+
+            await saveMessage(conversation.id, "user", userInput)
+
+            const message = await chatService.getMessages(conversation.id)
+
+            const aiResponse = await getAIResponse(conversation.id)
+
+            await saveMessage(conversation.id, "assistant", aiResponse)
+
+            await updateConversationTitle(conversation.id, userInput, message.length)
+
+        }
+
+    } catch (error) {
+        const errorBox = boxen(chalk.red(`Error: ${error.message}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "red",
+            title: "Error",
+            titleAlignment: "center",
+            dimBorder: true
+        })
+        console.log(errorBox)
+        process.exit(1)
+    }
+}
+
+
+
+export async function startChat(mode = "chat", conversationId = null) {
+    try {
+        intro(
+            boxen(chalk.bold.cyan("Maverick AI Chat"), {
+                padding: 1,
+                borderStyle: "double",
+                borderColor: "cyan"
+            })
+        )
+
+        const user = await getUserFromToken()
+        const conversation = await initConversation(user.id, conversationId, mode);
+        await chatLoop(conversation)
+
+        outro(chalk.green('⚡️ Thanks For Chatting.....'))
+
+    } catch (error) {
+        const errorBox = boxen(chalk.red(`Error: ${error.message}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "red",
+        })
+
+    }
+}
+
+