@bharatpanigrahi/onw-cli 1.0.1

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

@@ -0,0 +1,242 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { text, isCancel, cancel, intro, outro, box } from "@clack/prompts";
+import yoctoSpinner from "yocto-spinner";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { ChatService } from "../../service/chat.service.js";
+import { AIService } from "../ai/google-service.js";
+import { getStoredToken } from "../../lib/token.js";
+import prisma from "../../lib/db.js";
+
+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 'claude 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;
+}
+
+export 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",
+        titleAlignment: "left",
+        title: "👤 User",
+      });
+      console.log(userBox);
+    } else {
+      // render markdown content for AI messages
+      const renderedContent = marked.parse(msg.content);
+      const assistantBox = boxen(renderedContent.trim(), {
+        padding: 1,
+        margin: { left: 2, bottom: 1 },
+        borderStyle: "round",
+        borderColor: "green",
+        titleAlignment: "left",
+        title: "🤖 Claude",
+      });
+      console.log(assistantBox);
+    }
+  });
+}
+
+export async function saveMessage(conversationId, role, content) {
+  return await chatService.addMessage(conversationId, role, content);
+}
+
+export async function getAiResponse(conversationId) {
+  const spinner = yoctoSpinner({
+    text: "Claude is thinking...",
+    color: "cyan",
+  }).start();
+  const dbMessages = await chatService.getMessages(conversationId);
+  const aiMessages = await chatService.formatMessagesForAI(dbMessages);
+
+  let fullResponse = "";
+  let isFirstChunk = true;
+
+  try {
+    const result = await aiService.sendMessage(aiMessages, (chunk) => {
+      if (isFirstChunk) {
+        console.log("\n");
+        const header = chalk.green.bold("🤖 Claude:");
+        console.log(header);
+        console.log(chalk.gray("-".repeat(60)));
+        isFirstChunk = false;
+      }
+      fullResponse += chunk;
+    });
+    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;
+  } finally {
+    spinner.stop();
+  }
+}
+
+export 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 the conversation')}\n${chalk.gray("- Press Ctrl+C to quit at any time")}`,
+    {
+      padding: 1,
+      margin: { bottom: 1 },
+      borderStyle: "round",
+      borderColor: "gray",
+      dimBorder: true,
+    },
+  );
+  console.log(helpBox);
+
+  while (true) {
+    const userInput = await text({
+      message: chalk.blue("You: "),
+      placeholder: "Type your message here...",
+      validate: (value) => {
+        if (!value || value.trim().length === 0) {
+          return "Message cannot be empty";
+        }
+      },
+    });
+
+    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);
+    }
+
+    if (userInput.toLowerCase() === "exit") {
+      const exitBox = boxen(chalk.yellow("Chat session ended. Goodbye! 👋"), {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "yellow",
+      });
+      console.log(exitBox);
+      break;
+    }
+
+    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);
+  }
+}
+
+async function initConversation(userId, conversationId = null, mode = "chat") {
+  const spinner = yoctoSpinner({ text: "Loading conversation..." }).start();
+  const conversation = await chatService.getOrCreateConversations(
+    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?.messages?.length > 0) {
+    console.log(chalk.yellow("📜 Previous messages:\n"));
+    displayMessages(conversation.messages);
+  }
+  return conversation;
+}
+
+export async function startChat(mode = "chat", conversationId = null) {
+  try {
+    intro(
+      boxen(chalk.bold.cyan("Claude 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! Type "claude wakeup" to start a new conversation.',
+      ),
+    );
+  } catch (error) {}
+}

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

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import yoctoSpinner from "yocto-spinner";
+import { select } from "@clack/prompts";
+import { getStoredToken } from "../../../lib/token.js";
+import prisma from "../../../lib/db.js";
+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(`Welcome 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)",
+      },
+    ],
+  });
+
+  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);

package/src/cli/commands/auth/login.js

@@ -0,0 +1,287 @@
+import { cancel, confirm, intro, isCancel, outro } from "@clack/prompts";
+import { logger } from "better-auth";
+import { createAuthClient } from "better-auth/client";
+import { deviceAuthorizationClient } from "better-auth/client/plugins";
+
+import chalk from "chalk";
+import { Command } from "commander";
+import fs from "node:fs/promises";
+import open from "open";
+import os from "os";
+import path from "path";
+import yoctoSpinner from "yocto-spinner";
+import * as z from "zod/v4";
+import prisma from "../../../lib/db.js";
+import dotenv from "dotenv";
+import {
+  clearStoredToken,
+  getStoredToken,
+  isTokenExpired,
+  requireAuth,
+  storeToken,
+} from "../../../lib/token.js";
+
+dotenv.config();
+
+const URL = process.env.BASE_URL;
+const CLIENT_ID = process.env.GITHUB_CLIENT_ID;
+export const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+export const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+export async function loginAction(opts) {
+  const options = z.object({
+    serverUrl: z.string().optional(),
+    clientId: z.string().optional(),
+  });
+
+  const serverUrl = options.serverUrl || URL;
+  const clientId = options.clientId || CLIENT_ID;
+
+  intro(chalk.bold("🔐 Auth CLI Login"));
+
+  // TODO: CHANGE THIS WITH TOKEN MANAGEMENT UTILS
+  const existingToken = await getStoredToken();
+  const expired = await isTokenExpired();
+
+  if (existingToken && !expired) {
+    const shouldReAuth = await confirm({
+      message: "You are already logged in. Do you want to log in again?",
+      initialValue: false,
+    });
+
+    if (isCancel(shouldReAuth) || !shouldReAuth) {
+      cancel("Login cancelled.");
+      process.exit(0);
+    }
+  }
+
+  const authClient = createAuthClient({
+    baseURL: serverUrl,
+    plugins: [deviceAuthorizationClient()],
+  });
+
+  const spinner = yoctoSpinner({ text: "Requesting device authorization..." });
+  spinner.start();
+
+  try {
+    const { data, error } = await authClient.device.code({
+      client_id: clientId,
+      scope: "openid profile email",
+    });
+    spinner.stop();
+
+    if (error || !data) {
+      logger.error(
+        `Failed to request device authorization: ${error?.error_description}`,
+      );
+      process.exit(1);
+    }
+
+    const {
+      device_code,
+      user_code,
+      verification_uri,
+      expires_in,
+      interval = 5,
+      verification_uri_complete,
+    } = data;
+
+    console.log(chalk.cyan("Device Authorization Required!"));
+    console.log(
+      `Please visit ${chalk.underline.blue(verification_uri || verification_uri_complete)}`,
+    );
+    console.log(`Enter Code: ${chalk.bold.green(user_code)}`);
+
+    const shouldOpen = await confirm({
+      message: "Open browser automatically",
+      initialValue: true,
+    });
+
+    if (!isCancel(shouldOpen) && shouldOpen) {
+      const urlToOpen = verification_uri_complete || verification_uri;
+      await open(urlToOpen);
+    }
+
+    console.log(
+      chalk.gray(
+        `Waiting for authorization... (expires in ${Math.floor(expires_in / 60)} minutes)...`,
+      ),
+    );
+
+    const token = await pollForToken(
+      authClient,
+      device_code,
+      clientId,
+      interval,
+    );
+
+    if (token) {
+      const saved = await storeToken(token);
+      if (!saved) {
+        console.log(
+          chalk.yellow("\n ⚠️ Warning: Could not save authentication token."),
+        );
+        console.log(chalk.yellow("You may need to login again on next use."));
+      }
+
+      // TODO: get the user Data
+
+      outro(chalk.green("Login successful!"));
+      console.log(chalk.gray(`\n Token saved to: ${TOKEN_FILE}`));
+      console.log(
+        chalk.gray("You can now use AI commands without loggin in again. \n"),
+      );
+    }
+  } catch (error) {
+    spinner.stop();
+    console.error(chalk.red("\nLogin failed: "), error?.message);
+    process.exit(1);
+  }
+}
+
+async function pollForToken(
+  authClient,
+  deviceCode,
+  clientId,
+  initialIntervalValue,
+) {
+  let pollingInterval = initialIntervalValue;
+  const spinner = yoctoSpinner({ text: "", color: "cyan" });
+
+  let dots = 0;
+
+  return new Promise((resolve, reject) => {
+    const poll = async () => {
+      dots = (dots + 1) % 4;
+      spinner.text = chalk.gray(
+        `Polling for authorization${".".repeat(dots)}${" ".repeat(3 - dots)}`,
+      );
+
+      if (!spinner.isSpinning) spinner.start();
+
+      try {
+        const { data, error } = await authClient.device.token({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientId,
+          fetchOptions: {
+            headers: {
+              "user-agent": `My CLI`,
+            },
+          },
+        });
+
+        if (data?.access_token) {
+          console.log(
+            chalk.bold.yellow(`Your access token: ${data.access_token}`),
+          );
+          spinner.stop();
+          resolve(data);
+          return;
+        } else if (error) {
+          switch (error.error) {
+            case "authorization_pending":
+              // Continue polling
+              break;
+            case "slow_down":
+              pollingInterval += 5;
+              break;
+            case "access_denied":
+              console.error("Access was denied by the user");
+              return;
+            case "expired_token":
+              console.error("The device code has expired. Please try again.");
+              return;
+            default:
+              spinner.stop();
+              logger.error(`Error: ${error.error_description}`);
+              process.exit(1);
+          }
+        }
+      } catch (error) {
+        spinner.stop();
+        logger.error(`Netowork Error: ${error.message}`);
+        process.exit(1);
+      }
+
+      setTimeout(poll, pollingInterval * 1000);
+    };
+
+    setTimeout(poll, pollingInterval * 1000);
+  });
+}
+
+export async function logoutAction() {
+  intro(chalk.bold("👋 Logout"));
+
+  const token = await getStoredToken();
+  if (!token) {
+    console.log(chalk.yellow("You are not logged in."));
+    process.exit(0);
+  }
+
+  const shouldLogout = await confirm({
+    message: "Are you sure you want to log out?",
+    initialValue: false,
+  });
+
+  if (isCancel(shouldLogout) || !shouldLogout) {
+    cancel("Logout cancelled.");
+    process.exit(0);
+  }
+
+  const cleared = await clearStoredToken();
+
+  if (cleared) {
+    outro(chalk.green("Successfully logged out!"));
+  } else {
+    console.log(
+      chalk.yellow("⚠️ Warning: Could not clear authentication token."),
+    );
+  }
+}
+
+export async function whoamiAction(opts) {
+  const token = await requireAuth();
+  if (!token.access_token) {
+    console.log("No access token found. Please login.");
+    process.exit(1);
+  }
+
+  const user = await prisma.user.findFirst({
+    where: {
+      sessions: {
+        some: {
+          token: token.access_token,
+        },
+      },
+    },
+    select: {
+      id: true,
+      name: true,
+      email: true,
+      image: true,
+    },
+  });
+
+  console.log(
+    chalk.bold.greenBright(
+      `\n👤 User: ${user.name} Email: ${user.email} ID: ${user.id}`,
+    ),
+  );
+}
+
+export const login = new Command("login")
+  .description("Login to your account")
+  .option("--server-url <url>", "URL of the authentication server")
+  .option("--client-id <id>", "Client ID for authentication")
+  .action(loginAction);
+
+export const logout = new Command("logout")
+  .description("Logout of your account")
+  .action(logoutAction);
+
+export const whoami = new Command("whoami")
+  .description("Display information about the current user")
+  .option("--server-url <url>", "URL of the authentication server")
+  .action(whoamiAction);

package/src/cli/main.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import dotenv from "dotenv";
+import chalk from "chalk";
+import figlet from "figlet";
+import { Command } from "commander";
+import { login, logout, whoami } from "./commands/auth/login.js";
+import { wakeUp } from "./commands/ai/wakeUp.js";
+
+dotenv.config();
+
+async function main() {
+  // Display banner
+  console.log(
+    chalk.cyan(
+      figlet.textSync("Claude CLI", {
+        horizontalLayout: "default",
+        font: "Standard",
+      }),
+    ),
+  );
+
+  console.log(chalk.gray("A CLI based AI Tool \n"));
+
+  const program = new Command("claude-cli");
+
+  program
+    .version("0.0.1")
+    .description("A CLI based AI Tool")
+    .addCommand(login)
+    .addCommand(logout)
+    .addCommand(whoami)
+    .addCommand(wakeUp);
+
+  program.action(() => {
+    program.help();
+  });
+
+  program.parse();
+}
+
+main().catch((error) => {
+  console.error(chalk.red("Error running Claude CLI:"), error);
+  process.exit(1);
+});