pulse-cli-divakar 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,157 @@
+import { cancel, confirm, intro, isCancel, outro, select } 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, program } 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 dotenv from "dotenv";
+
+import { prisma } from "../../../lib/db.js";
+import { clearStoredToken, getStoredToken, isTokenExpired, requireAuth, storeToken } from "../../../lib/token.js";
+import { pollForToken } from "../utils/polling.js";
+
+dotenv.config();
+
+
+// To store in local computer using below 4 variables
+
+
+export const URL = process.env.BACK_END ||  "https://pulse-4t51.onrender.com";
+const CLIENT_ID = process.env.GITHUB_CLIENT_ID || "Ov23lijaPrTkzWootiuZ"
+// create a .better-auth folder in home directry not actual folder create just a link like  C:\Users\YourUser\.better-auth
+export const CONFIG_DIR = path.join(os.homedir(), ".better-auth");
+// save to token.json
+export const TOKEN_FILE = path.join(CONFIG_DIR, "token.json");
+
+export async function loginAction() {
+  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."));
+
+  const existingToken = getStoredToken();
+  const expired = isTokenExpired();
+
+  if (existingToken && !expired) {
+    const shouldReAuth = await confirm({
+      message: "You are already loggedIn. Do You want to login Again?",
+      initialValue: false,
+    });
+    // User choose No OR Cancel the command
+    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,
+      verification_uri_complete,
+      expires_in,
+      interval,
+    } = data;
+
+    console.log(chalk.cyan("Device authorization is 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.")
+        );
+      }
+
+      outro(chalk.green("Login successfull!"))
+
+      console.log(chalk.gray(`\n Token Saved to: ${TOKEN_FILE}`))
+      console.log(chalk.gray("You can now use Pulse Commands without logging-in again.\n "))
+
+    }
+     
+  } catch (error) {
+    spinner.stop();
+    console.error(chalk.red("\nLogin failed:"), error.message);
+    process.exit(1);
+  }
+}
+
+
+export const login = new Command("login")
+  .description("Login to Better-Auth")
+  .option("--server-url <url>", "The Better Auth server URL", URL)
+  .option("--client-id <id>", "The OAuth client ID", CLIENT_ID)
+  .action(loginAction)
+
+
+

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

@@ -0,0 +1,42 @@
+import { confirm, intro, isCancel, outro } from "@clack/prompts";
+import { clearStoredToken, getStoredToken } from "../../../lib/token.js";
+import chalk from "chalk";
+import { Command } from "commander";
+import dotenv from "dotenv";
+
+
+
+dotenv.config();
+
+export async function logoutAction() {
+  intro(chalk.bold("👋Logout"));
+
+  const token=await getStoredToken();
+  if(!token){
+    console.log(chalk.yellow("You're not logged in.Please LogIn First"))
+    process.exit(0);
+  }
+  const shouldLogout=await confirm({
+    message:"Are you sure , do you want to logout?",
+    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("❌ Could not clear token file."))
+  }
+}
+
+
+
+export const logout = new Command("logout")
+  .description("Logout and Clear stored credentials")
+  .action(logoutAction)

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

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { prisma } from "../../../lib/db.js";
+import { requireAuth } from "../../../lib/token.js";
+import { Command } from "commander";
+import { URL } from "./login.js";
+
+export async function whoamiAction() {
+  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 whoami = new Command("whoami")
+  .description("Show current authenticated user")
+  .option("--server-url <url>", "The Better Auth server URL", URL)
+  .action(whoamiAction)

package/src/cli/commands/utils/polling.js

@@ -0,0 +1,77 @@
+import { logger } from "better-auth";
+import chalk from "chalk";
+import yoctoSpinner from "yocto-spinner";
+
+
+export async function pollForToken(
+      authClient,
+      deviceCode,
+      clientId,
+      initialIntervalue,
+    ) {
+      let pollingInterval = initialIntervalue;
+      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 acess 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(`Network error: ${error.message}`);
+            process.exit(1);
+          }
+
+          setTimeout(poll, pollingInterval * 1000);
+        };
+        
+      setTimeout(poll , pollingInterval * 1000);
+      });
+}

package/src/cli/main.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import dotenv from "dotenv"
+import chalk from "chalk" //to add colours 
+import figlet from "figlet" //to add banners 
+
+import {Command} from "commander" //to create a command
+import { login} from "./commands/auth/login.js"
+import { logout } from "./commands/auth/logout.js"
+import { whoami } from "./commands/auth/whoami.js"
+import { wakeUp } from "./commands/ai/wakeup.js"
+
+
+dotenv.config()
+
+async function main() {
+    
+    console.log(
+        chalk.greenBright(
+            figlet.textSync("Pulse CLI",{
+                font:"Standard",
+                horizontalLayout:"default"
+            })
+        )
+    )
+    console.log(chalk.magenta("A Cli Based AI application.\n"))
+
+    const program=new Command("pulse")
+    program.version("0.0.1")
+    .description("Pulse is a Cli based application")
+    .addCommand(login)
+    .addCommand(logout)
+    .addCommand(whoami)
+    .addCommand(wakeUp)
+    
+
+    program.action(()=>{
+        program.help();
+    })
+    await program.parseAsync(process.argv);
+}
+
+main().catch((error)=>{
+    console.log(chalk.red("Error running Pulse Cli:"),error);
+    process.exit(1);
+})

package/src/config/agent-config.js

@@ -0,0 +1,170 @@
+import { promises as fs } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateText, Output } from "ai";
+import { z } from "zod";
+
+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)",
+    ),
+});
+
+function printSystem(message) {
+  console.log(message);
+}
+
+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}`));
+        });
+      }
+    });
+}
+
+
+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;
+}
+
+
+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 generateText({
+      model: aiService.model,
+      output: Output.object({
+        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.output;
+
+    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`));
+
+    displayFileTree(application.files, application.folderName);
+
+    printSystem(chalk.cyan(`\n📝 Creating files...\n`));
+
+    const appDir = await createApplicationFiles(
+      cwd,
+      application.folderName,
+      application.files,
+    );
+
+    printSystem(chalk.green.bold(`\n✨ Application created successfully!\n`));
+    printSystem(chalk.cyan(`📁 Location: ${chalk.bold(appDir)}\n`));
+
+    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.ORBITAL_MODEL || "gemini-2.5-flash"
+
+}

package/src/config/tool.config.js

@@ -0,0 +1,99 @@
+import {google} from "@ai-sdk/google"
+import chalk from "chalk"
+
+
+export const availableTools=[
+    {
+        id:"google_search",
+        name:"Google Search",
+        description:"Acess the latest information using Google Search.Usefull 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,
+    },
+
+]
+
+
+
+export function getEnabledTools(){
+    const tools={}
+
+    try {
+        for(const toolConfig of availableTools){
+            if(toolConfig.enabled){
+                tools[toolConfig.id]=toolConfig.getTool()
+            }
+        }
+
+         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;
+    }
+}
+
+
+export function togggleTool(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;
+}
+
+
+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}`));
+}
+
+export function getEnabledToolNames() {
+  const names = availableTools.filter(t => t.enabled).map(t => t.name);
+  console.log(chalk.gray('[DEBUG] getEnabledToolNames returning:'), names);
+  return names;
+}
+
+export function resetTools() {
+  availableTools.forEach(tool => {
+    tool.enabled = false;
+  });
+  console.log(chalk.gray('[DEBUG] All tools have been reset (disabled)'));
+}