@bharatpanigrahi/onw-cli 1.0.1

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@bharatpanigrahi/onw-cli",
+  "version": "1.0.1",
+  "description": "A CLI tool for Claude AI",
+  "main": "src/index.js",
+  "files": [
+    "src/"
+  ],
+  "bin": {
+    "claude": "./src/cli/main.js"
+  },
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "claude",
+    "ai",
+    "cli"
+  ],
+  "author": "bharatpanigrahi",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@ai-sdk/google": "^3.0.53",
+    "@clack/prompts": "^1.1.0",
+    "ai": "^6.0.141",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "open": "^11.0.0",
+    "yocto-spinner": "^1.1.0",
+    "zod": "^4.3.6"
+  }
+}

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

@@ -0,0 +1,102 @@
+import { google } from "@ai-sdk/google";
+import { generateObject, streamText, tool } from "ai";
+import { config } from "../../config/google.config.js";
+import chalk from "chalk";
+
+export class AIService {
+  constructor() {
+    if (!config.googleApiKey) {
+      throw new Error("GOOGLE_GENERATIVE_AI_API_KEY us not set in env");
+    }
+
+    this.model = google(config.model, {
+      apiKey: config.googleApiKey,
+    });
+  }
+
+  async sendMessage(message, onChunk, tools = undefined, onToolCall = null) {
+    try {
+      const streamConfig = {
+        model: this.model,
+        messages: message,
+      };
+
+      if (tools && Object.keys(tools).length > 0) {
+        streamConfig.tools = tools;
+        streamConfig.maxSteps = 5; // Allow Up to 5 tool call 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.toolCalls && step.toolCalls.length > 0) {
+            for (const toolCall of step.toolCalls) {
+              toolCalls.push(toolCall);
+              if (onToolCall) {
+                onToolCall(toolCall);
+              }
+            }
+          }
+
+          if (step.toolResults && step.toolResults.length > 0) {
+            toolResults.push(...step.toolResults);
+          }
+        }
+      }
+
+      return {
+        content: fullResponse,
+        finishResponse: fullResult.finishReason,
+        usage: fullResult.usage,
+        toolCalls,
+        toolResults,
+        steps: fullResult.steps,
+      };
+    } catch (error) {
+      console.error(chalk.red("AI Service Error: ", error?.message));
+      throw error;
+    }
+  }
+
+  async getMessage(message, tools = undefined) {
+    let fullResponse = "";
+    const result = await this.sendMessage(message, (chunk) => {
+      fullResponse += chunk;
+    });
+
+    return result.content;
+  }
+
+  async generatedStructure(schema, prompt) {
+    try {
+      const result = await generateObject({
+        model: this.model,
+        schema,
+        prompt,
+      });
+
+      return result.object;
+    } catch (error) {
+      console.error(
+        chalk.red("AI Structured Generation Error: ", error?.message),
+      );
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,209 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import yoctoSpinner from "yocto-spinner";
+import { text, isCancel, cancel, intro, outro, confirm } from "@clack/prompts";
+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 { generateApplication } from "../../config/agent.config.js";
+import { saveMessage } from "./chat-with-ai.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 '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;
+}
+
+async function initConversation(userId, conversationId = null) {
+  const spinner = yoctoSpinner({ text: "Loading conversation..." }).start();
+  const conversation = await chatService.getOrCreateConversations(
+    userId,
+    conversationId,
+    "agent",
+  );
+  spinner.success("Conversation loaded");
+  const conversationInfo = boxen(
+    `${chalk.bold("Conversation ID:")} ${conversation.id}\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 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("You: "),
+      placeholder: "Type your message here...",
+      validate: (value) => {
+        if (!value || value.trim().length === 0) {
+          return "Message cannot be empty";
+        }
+        if (value.trim().length < 10) {
+          return "Please provide a more detailed description (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);
+
+    await saveMessage(conversation.id, "user", userInput);
+
+    try {
+      const result = await generateApplication(
+        userInput,
+        aiService,
+        process.cwd(),
+      );
+
+      if (result && result.success) {
+        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("Claude AI - Agent Mode\n\n") +
+          chalk.gray("Autonomous Application Generator"),
+        {
+          padding: 1,
+          borderStyle: "double",
+          borderColor: "magenta",
+        },
+      ),
+    );
+
+    const user = await getUserFromToken();
+    const shouldContinue = await confirm({
+      message: chalk.yellow(
+        "The agent will create files and folders in the current directory. Do you want to 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) {}
+}

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

@@ -0,0 +1,325 @@
+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 "../../service/chat.service.js";
+import { getStoredToken } from "../../lib/token.js";
+import prisma from "../../lib/db.js";
+import {
+  avaiableTools,
+  enableTools,
+  getEnabledToolNames,
+  getEnabledTools,
+  resetTools,
+} from "../../config/tool.config.js";
+import {
+  displayMessages,
+  saveMessage,
+  updateConversationTitle,
+} from "./chat-with-ai.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;
+}
+
+async function selectTools() {
+  const toolOptions = avaiableTools.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);
+  }
+
+  enableTools(selectedTools);
+
+  if (selectedTools.length === 0) {
+    console.log(
+      chalk.yellow("\n⚠️ No tools selected. AI will work without tools.\n"),
+    );
+  } else {
+    const toolsBox = boxen(
+      chalk.green(
+        `Enabled tools:\n${selectedTools
+          .map((id) => {
+            const tool = avaiableTools.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 getAIResponse(conversationId) {
+  const spinner = yoctoSpinner({
+    text: "Claude is thinking...",
+    color: "cyan",
+  }).start();
+  const dbMessages = await chatService.getMessages(conversationId);
+  const aiMessages = await chatService.formatMessagesForAI(dbMessages);
+
+  const tools = getEnabledTools();
+
+  let fullResponse = "";
+  let isFirstChunk = true;
+  const toolCallIsDetected = [];
+
+  try {
+    const result = await aiService.sendMessage(
+      aiMessages,
+      (chunk) => {
+        if (isFirstChunk) {
+          spinner.stop();
+          console.log("\n");
+          const header = chalk.green.bold("🤖 Claude:");
+          console.log(header);
+          console.log(chalk.gray("-".repeat(60)));
+        }
+
+        fullResponse += chunk;
+      },
+      tools,
+      (toolCall) => {
+        toolCallIsDetected.push(toolCall);
+      },
+    );
+
+    if (toolCallIsDetected.length > 0) {
+      console.log("\n");
+      const toolCallBox = boxen(
+        toolCallIsDetected
+          .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);
+    }
+
+    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();
+  }
+}
+
+async function initCnnversation(userId, conversationId = null, mode = "tool") {
+  const spinner = yoctoSpinner({ text: "Loading conversation..." }).start();
+
+  const conversation = await chatService.getOrCreateConversations(
+    userId,
+    conversationId,
+    mode,
+  );
+  spinner.success("Conversation loaded");
+
+  const enabledToolNames = getEnabledToolNames();
+  const toolsDisplay =
+    enabledToolNames.length > 0
+      ? `\n${chalk.gray("Active Tools:")} ${enabledToolNames.join(", ")}`
+      : `\n${chalk.gray("No tools enabled.")}`;
+
+  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);
+
+  if (conversation?.messages?.length > 0) {
+    console.log(chalk.yellow("📜 Previous messages:\n"));
+    displayMessages(conversation.messages);
+  }
+
+  return conversation;
+}
+
+async function chatLoop(conversation) {
+  const enabledToolNames = getEnabledToolNames();
+  const helpBox = boxen(
+    `${chalk.gray("- Type your message and press Enter")}\n${chalk.gray("- AI 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 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);
+  }
+}
+
+export async function startToolChat(conversationId = null) {
+  try {
+    intro(
+      boxen(chalk.bold.cyan("Claude AI - Tool Calling Mode"), {
+        padding: 1,
+        borderStyle: "double",
+        borderColor: "cyan",
+      }),
+    );
+
+    const user = await getUserFromToken();
+    await selectTools();
+
+    const conversation = await initCnnversation(
+      user.id,
+      conversationId,
+      "tool",
+    );
+    await chatLoop(conversation);
+    resetTools();
+
+    outro(chalk.green.bold("Thanks for using tools. Goodbye!"));
+  } 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);
+  }
+}