pulse-cli-divakar 0.0.0-stage → 1.0.1

package/package.json

@@ -1,6 +1,55 @@
-{
-  "name": "pulse-cli-divakar",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "pulse-cli-divakar",
+  "version": "1.0.1",
+  "main": "src/index.js",
+  "bin": {
+    "pulse": "./src/cli/main.js"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon src/index.js",
+    "start": "node src/index.js",
+    "db:generate": "prisma generate",
+   "db:deploy": "prisma migrate deploy"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/google": "^4.0.104",
+    "@clack/prompts": "^1.8.1",
+    "@neondatabase/serverless": "^1.2.0",
+    "@prisma/adapter-neon": "^7.10.1",
+    "@prisma/client": "^7.10.1",
+    "ai": "^7.0.143",
+    "better-auth": "^1.7.10",
+    "boxen": "^9.0.0",
+    "chalk": "^6.0.1",
+    "commander": "^15.0.0",
+    "cors": "^2.8.6",
+    "dotenv": "^18.0.8",
+    "express": "^5.3.0",
+    "figlet": "^1.12.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "open": "^11.0.4",
+    "yocto-spinner": "^1.2.2",
+    "zod": "^4.6.7"
+  },
+  "keywords": [
+    "pulse",
+    "cli",
+    "ai",
+    "developer-tools"
+  ],
+  "description": "Pulse CLI — an AI-powered command-line application",
+  "devDependencies": {
+    "prisma": "^7.10.1"
+  },
+   "files": [
+    "src/cli",
+     "src/lib",
+     "src/config"
+  ]
+  
+}

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

@@ -0,0 +1,127 @@
+import {config} from "../../config/google.config.js"
+import {google} from "@ai-sdk/google"
+import {generateText, Output, streamText} from "ai"
+import chalk from "chalk" 
+
+
+export class AIService{
+    constructor(){
+        if(!config.googleApiKey){
+            throw new Error("Google_API_KEY is not present in env.")
+        }
+        this.model=google(config.model,{
+            apiKey:config.googleApiKey
+        })
+    }
+
+    // send message in chunk like sendMessage(messages,(chunk)=>{
+    // console.log(chunk})
+
+    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;
+
+                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){
+                    // callback()
+                    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)
+                    }
+                }
+            }
+
+            /**
+             * {
+                    textStream: AsyncIterable,  // Streaming text chunks
+                    text: Promise,              // Complete generated text
+                    finishReason: Promise,      // Generation kyu finish hui
+                    usage: Promise,             // Token usage information
+                    response: Promise,          // Response metadata
+                    request: { ... },           // Request information
+                    more properties...
+                    }
+             */
+            
+            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;
+        }
+    }
+
+    // Send message in a single go
+
+    async getMessage(messages,tools=undefined){
+        let fullResponse=""
+        const result=await this.sendMessage(messages,(chunk)=>{
+            fullResponse+=chunk;
+        },tools)
+        return result.content;
+    }
+
+
+    async generateStructured(schema,promt){
+        try {
+            const result=await generateText({
+                model:this.model,
+                output:Output.object({
+                    schema:schema
+                }),
+                prompt:promt
+            })
+            return result.object
+        } catch (error) {
+            console.log(chalk.red("AI Structured Generation Failed:"),error.message)
+            throw error;
+        }
+    }
+
+}
+
+

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

@@ -0,0 +1,57 @@
+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 { chatLoop, getUserFromToken, initConversation } from "./utils/chataiutils.js";
+
+
+marked.use(
+  markedTerminal({
+    // Styling options for terminal output
+    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,
+  })
+);
+
+
+
+export async function startChat(mode="chat",conversationId=null) {
+    try {
+        intro(
+            boxen(chalk.bold.cyan("Pulse AI Chat"),{
+                padding:1,
+                borderStyle:"double",
+                borderColor:"green"
+            })
+        )
+
+        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",
+        });
+        console.log(errorBox);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,206 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import {
+  text,
+  isCancel,
+  cancel,
+  intro,
+  outro,
+  box,
+  multiselect,
+  confirm,
+} 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 { getUserFromToken, saveMessage } from "./utils/chataiutils.js";
+import { generateApplication } from "../../config/agent-config.js";
+
+const aiService = new AIService();
+const chatService = new ChatService();
+
+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;
+}
+
+export async function startAgentChat(conversationId = null) {
+  try {
+    intro(
+      boxen(
+        chalk.bold.magenta("🤖 Pulse 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. 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);
+  }
+}
+
+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);
+
+    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);
+
+        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;
+      }
+    }
+  }
+}