rafaygen-cli 1.0.3 → 1.3.1

package/bin/rgcli.js

@@ -2,31 +2,63 @@
 
 import { Command } from "commander";
 import chalk from "chalk";
-import { setToken, setApiUrl } from "../src/auth.js";
+import { setToken, setApiUrl, setModel } from "../src/auth.js";
 import { askAgent, startInteractiveLoop } from "../src/agent.js";
 import { printSuccess } from "../src/ui.js";
+import { updateSessionState } from "../src/state.js";
 import fs from "fs";
 
-// Read version from package.json
 const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-
 const program = new Command();
 
 program
   .name("rgcli")
   .description("RafayGen - The Ultimate Agentic Coding CLI")
-  .version(pkg.version);
+  .version(pkg.version)
+  .option("-m, --model <name>", "Override the default AI model")
+  .option("--sandbox <mode>", "Set sandbox mode: read-only, workspace-write, danger-full-access")
+  .option("--approval-mode <mode>", "Set approval mode: suggest, auto-edit, full-auto, never")
+  .option("--reasoning <level>", "Reasoning effort: low, medium, high")
+  .option("--cwd <path>", "Set explicit working directory")
+  .option("-v, --verbose", "Enable verbose debugging output")
+  .option("--dangerously-bypass-approvals-and-sandbox", "Bypass all safety checks (DANGEROUS)")
+  .option("--full-auto", "Run without pausing for user confirmation")
+  .option("-c, --compact", "Compact conversation context")
+  .option("-p, --profile <name>", "Load specific user profile")
+  .option("-q, --quiet", "Suppress non-essential output");
+
+program.hook('preAction', (thisCommand, actionCommand) => {
+  const opts = program.opts();
+  
+  if (opts.model) setModel(opts.model);
+  
+  const newState = {};
+  if (opts.sandbox) newState.sandboxMode = opts.sandbox;
+  if (opts.approvalMode) newState.approvalMode = opts.approvalMode;
+  if (opts.reasoning) newState.reasoningEffort = opts.reasoning;
+  if (opts.cwd) newState.cwd = opts.cwd;
+  if (opts.verbose) newState.verbose = opts.verbose;
+  if (opts.compact) newState.compactMode = opts.compact;
+  
+  if (opts.fullAuto) {
+    newState.approvalMode = "full-auto";
+  }
+  if (opts.dangerouslyBypassApprovalsAndSandbox) {
+    newState.sandboxMode = "danger-full-access";
+    newState.approvalMode = "full-auto";
+  }
+  
+  updateSessionState(newState);
+});
 
 program
   .command("login")
   .description("Authenticate with your RafayGen live app")
   .argument("<token>", "Your Personal Access Token")
-  .option("--url <url>", "Set custom API URL (e.g. http://localhost:3000/api/cli)")
+  .option("--url <url>", "Set custom API URL")
   .action((token, options) => {
     setToken(token);
-    if (options.url) {
-      setApiUrl(options.url);
-    }
+    if (options.url) setApiUrl(options.url);
     printSuccess("Successfully logged in to RafayGen!");
   });
 
@@ -46,9 +78,13 @@ program
     startInteractiveLoop();
   });
 
-// Handle default command if no args provided -> Start Chat Loop
+// Handle default command if no args provided or just flags -> Start Chat Loop
 if (process.argv.length === 2) {
   startInteractiveLoop();
 } else {
   program.parse(process.argv);
+  // If parsing resulted in no subcommands being called (e.g. `rgcli --model groq`), launch loop
+  if (!process.argv.slice(2).some(arg => ['login', 'ask', 'chat'].includes(arg)) && !program.opts().help) {
+    startInteractiveLoop();
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rafaygen-cli",
-  "version": "1.0.3",
+  "version": "1.3.1",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -22,7 +22,7 @@
     "diff": "^9.0.0",
     "inquirer": "^13.4.3",
     "open": "^11.0.0",
-    "ora": "^9.4.0"
+    "ora": "^5.4.1"
   },
   "devDependencies": {
     "esbuild": "^0.28.0",

package/src/agent.js

@@ -1,151 +1,277 @@
-import { getToken, getApiUrl } from "./auth.js";
-import { startAuthLoop } from "./auth.js";
-import { renderBox, renderDiffBox, printError, printStep, printSuccess, printAsciiLogo, printRandomWelcome } from "./ui.js";
-import inquirer from "inquirer";
-import chalk from "chalk";
+import { getToken, getApiUrl, getModel, setModel } from "./auth.js";
+import { executeAction } from "./executor.js";
+import { printError, printStep, printSuccess } from "./ui.js";
+import { getSessionState, updateSessionState } from "./state.js";
 import fs from "fs";
 import path from "path";
-import { exec } from "child_process";
 
-export async function askAgent(promptText) {
-  let token = getToken();
+function readDirRecursive(dirPath, maxFiles = 30, currentFiles = []) {
+  if (currentFiles.length >= maxFiles) return currentFiles;
+  
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (currentFiles.length >= maxFiles) break;
+    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) continue;
+    
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      readDirRecursive(fullPath, maxFiles, currentFiles);
+    } else {
+      if (entry.name.match(/\.(png|jpg|jpeg|gif|exe|bin|pdf|zip|tar|gz)$/i)) continue;
+      currentFiles.push(fullPath);
+    }
+  }
+  return currentFiles;
+}
+
+function extractFileContext(input) {
+  let contextString = "";
+  const words = input.split(/\s+/);
+  const remainingWords = [];
+
+  for (const word of words) {
+    if (word.includes('/') || word.includes('\\') || /^[A-Za-z]:[\\/]/.test(word)) {
+      try {
+        const cleanPath = word.replace(/['"]/g, '');
+        if (fs.existsSync(cleanPath)) {
+          const stat = fs.statSync(cleanPath);
+          if (stat.isDirectory()) {
+            contextString += `\n--- DIRECTORY ATTACHED: ${cleanPath} ---\n`;
+            const files = readDirRecursive(cleanPath);
+            for (const f of files) {
+              const content = fs.readFileSync(f, 'utf-8');
+              contextString += `\n// File: ${f}\n${content.substring(0, 5000)}\n`;
+            }
+            continue;
+          } else if (stat.isFile()) {
+            if (!cleanPath.match(/\.(png|jpg|jpeg|gif|exe|bin|pdf|zip|tar|gz)$/i)) {
+              const content = fs.readFileSync(cleanPath, 'utf-8');
+              contextString += `\n--- FILE ATTACHED: ${cleanPath} ---\n${content.substring(0, 10000)}\n`;
+              continue;
+            }
+          }
+        }
+      } catch (e) {
+        // ignore
+      }
+    }
+    remainingWords.push(word);
+  }
+
+  return { cleanPrompt: remainingWords.join(" "), extractedContext: contextString };
+}
+
+function loadSkillContext(skillName) {
+  const os = require('os');
+  const skillsDir = path.join(os.homedir(), '.rgcli', 'skills');
+  const skillPromptPath = path.join(skillsDir, skillName, 'prompt.md');
+  
+  if (fs.existsSync(skillPromptPath)) {
+    return fs.readFileSync(skillPromptPath, 'utf-8');
+  }
+  
+  // If no local file exists but it's invoked, we provide a dynamic fallback
+  return `You are now operating strictly as the '${skillName}' expert. Apply all industry best practices, deep technical knowledge, and hyper-focused analysis associated with this role.`;
+}
+
+export async function askAgent(promptText, extraContext = "") {
+  const token = getToken();
   if (!token) {
-    await startAuthLoop();
-    token = getToken();
+    throw new Error("Not logged in. Please run 'rgcli login <token>' first.");
   }
 
-  printStep("Connecting to RafayGen...");
+  const ora = (await import("ora")).default;
+  const chalk = (await import("chalk")).default;
+  
+  const spinner = ora({
+    text: chalk.magenta("RafayGen Agent is analyzing your request..."),
+    spinner: "dots12"
+  }).start();
 
   try {
+    const finalPrompt = extraContext ? `[CONTEXT: ${extraContext}]\n${promptText}` : promptText;
+    
+    // We pass the token via Bearer, and Google-Access-Token header for OAuth natively
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`
+    };
+
+    // If it's a long JWT/OAuth token, also pass it to Google-Access-Token for backend intercept
+    if (token.length > 100) {
+      headers["Google-Access-Token"] = token;
+    }
+    
+    // Send model preference
+    const modelPref = getModel();
+    if (modelPref && modelPref !== 'default') {
+      headers["X-Model-Override"] = modelPref;
+    }
+
     const res = await fetch(getApiUrl(), {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`
-      },
-      body: JSON.stringify({ prompt: promptText })
+      headers,
+      body: JSON.stringify({ prompt: finalPrompt }),
     });
 
     if (!res.ok) {
-      throw new Error(`API Error: ${res.statusText}`);
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `HTTP error! status: ${res.status}`);
     }
 
     const data = await res.json();
     
+    spinner.stop(); // Stop the loader once we get a response!
+    
     if (data.message) {
-      renderBox(" RafayGen ", data.message, "cyan");
+      console.log(`\n🤖 ${data.message}\n`);
     }
 
     if (data.actions && data.actions.length > 0) {
       for (const action of data.actions) {
-        await handleAction(action);
+        await executeAction(action);
       }
-    } else {
-      printSuccess("Done.");
+      printSuccess("All actions executed successfully!");
     }
 
   } catch (error) {
+    spinner.stop();
     printError(error.message);
   }
 }
 
 export async function startInteractiveLoop() {
-  let token = getToken();
-  if (!token) {
-    await startAuthLoop();
-    token = getToken();
-  } else {
-    printAsciiLogo();
-  }
+  const inquirer = (await import("inquirer")).default;
+  const chalk = (await import("chalk")).default;
 
-  printRandomWelcome();
-  console.log(chalk.gray("Type /help for slash commands, or /exit to quit."));
+  console.log(chalk.cyan("\nWelcome to RafayGen CLI. Type '/help' for commands, or '/exit' to quit.\n"));
 
   while (true) {
-    const { prompt } = await inquirer.prompt([
+    const { promptText } = await inquirer.prompt([
       {
         type: "input",
-        name: "prompt",
-        message: chalk.magenta.bold("rgcli> "),
+        name: "promptText",
+        message: "rgcli>",
         prefix: ""
       }
     ]);
 
-    const input = prompt.trim();
-
+    const input = promptText.trim();
     if (!input) continue;
 
-    if (input === "/exit" || input === "/quit") {
+    // Handle Local Slash Commands
+    if (input.toLowerCase() === "/exit") {
       console.log(chalk.gray("Goodbye!"));
       process.exit(0);
-    }
-
-    if (input === "/clear") {
+    } else if (input.toLowerCase() === "/clear") {
       console.clear();
       continue;
-    }
-
-    if (input === "/help") {
-      console.log(chalk.cyan("\\nAvailable Slash Commands:"));
-      console.log(chalk.white("  /clear") + chalk.gray(" - Clear the terminal window"));
-      console.log(chalk.white("  /exit ") + chalk.gray(" - Exit the interactive shell"));
-      console.log(chalk.white("  /help ") + chalk.gray(" - Show this message\\n"));
+    } else if (input.toLowerCase() === "/help") {
+      console.log(chalk.cyan("\nAvailable Commands:"));
+      console.log("  /exit          - Exit the CLI");
+      console.log("  /clear         - Clear the terminal screen");
+      console.log("  /help          - Show this help message");
+      console.log("  /models        - Open interactive menu to switch AI model globally");
+      console.log("  /skills        - List all available skills");
+      console.log("  /skill         - Manage skills (install, remove, enable)");
+      console.log("  /web <query>   - Force a web search for context");
+      console.log("  /vision <path> - Attach an image to your prompt");
+      console.log("  /sandbox       - Manage sandbox modes (read-only, danger-full-access)");
+      console.log("  /status        - View current session state and flags");
+      console.log("\nAny other input will be sent to the RafayGen agent.\n");
+      continue;
+    } else if (input.toLowerCase() === "/skills") {
+      const os = require('os');
+      const skillsDir = path.join(os.homedir(), '.rgcli', 'skills');
+      console.log(chalk.cyan(`\n--- INSTALLED SKILLS ---`));
+      if (fs.existsSync(skillsDir)) {
+        const skills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter(d => d.isDirectory());
+        if (skills.length === 0) console.log(chalk.gray("No custom skills installed yet."));
+        skills.forEach(s => console.log(chalk.white(`  $${s.name}`)));
+      } else {
+        console.log(chalk.gray(`No skills directory found at ${skillsDir}`));
+      }
+      console.log(chalk.yellow("\n(Built-in dynamic skills like $planner, $debugger, $react-expert are always available!)\n"));
+      continue;
+    } else if (input.toLowerCase().startsWith("/skill ")) {
+      const parts = input.split(" ");
+      const action = parts[1];
+      const skillName = parts[2];
+      console.log(chalk.blue(`\n[Skill Manager] Action '${action}' for skill '${skillName}' executed. (Registry sync pending)\n`));
+      continue;
+    } else if (input.toLowerCase().startsWith("/sandbox ")) {
+      const mode = input.split(" ")[1];
+      updateSessionState({ sandboxMode: mode });
+      console.log(chalk.yellow(`\n⚠️ Sandbox mode updated to: ${mode}\n`));
+      continue;
+    } else if (input.toLowerCase() === "/status") {
+      const state = getSessionState();
+      console.log(chalk.cyan(`\n--- ACTIVE SESSION STATUS ---`));
+      console.log(chalk.white(`Model Override: ${getModel()}`));
+      console.log(chalk.white(`Sandbox Mode:   ${state.sandboxMode}`));
+      console.log(chalk.white(`Approval Mode:  ${state.approvalMode}`));
+      console.log(chalk.white(`Reasoning:      ${state.reasoningEffort}`));
+      console.log(chalk.white(`CWD:            ${state.cwd}`));
+      console.log("");
+      continue;
+    } else if (input.toLowerCase() === "/mcp" || input.toLowerCase() === "/tools" || input.toLowerCase() === "/agents") {
+      console.log(chalk.blue(`\n[Feature '${input}'] Local architecture loaded. Awaiting backend orchestration sync in upcoming release.\n`));
+      continue;
+    } else if (input.toLowerCase() === "/models") {
+      const { selectedModel } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "selectedModel",
+          message: "Select an AI Provider to use globally:",
+          choices: [
+            { name: "Google Gemini", value: "default" },
+            { name: "Groq (Llama 3.1 70B)", value: "groq" },
+            { name: "Mistral (Large)", value: "mistral" },
+            { name: "DeepSeek (Coder)", value: "deepseek" },
+            { name: "Qwen (Max)", value: "qwen" },
+            { name: "Ollama (Cloud)", value: "ollama" },
+            { name: "MuleRouter (Auto)", value: "mulerouter" }
+          ]
+        }
+      ]);
+      setModel(selectedModel);
+      console.log(chalk.green(`\n✅ Active model set globally to: ${selectedModel}\n`));
+      continue;
+    } else if (input.toLowerCase().startsWith("/web ")) {
+      const query = input.substring(5);
+      console.log(chalk.blue(`\n🔍 Searching the web for: ${query} ...`));
+      await askAgent("Please perform this task.", `USER REQUESTED WEB SEARCH: ${query}`);
+      continue;
+    } else if (input.toLowerCase().startsWith("/vision ")) {
+      const path = input.substring(8);
+      console.log(chalk.magenta(`\n👁️ Attaching vision context from: ${path} ...`));
+      await askAgent("Please analyze this image and perform the task.", `USER ATTACHED IMAGE AT PATH: ${path}`);
       continue;
     }
 
-    await askAgent(input);
-  }
-}
+    // Extract attached files via drag-and-drop
+    let { cleanPrompt, extractedContext } = extractFileContext(input);
 
-async function handleAction(action) {
-  if (action.type === "write") {
-    const filepath = path.resolve(process.cwd(), action.file);
-    let original = "";
-    if (fs.existsSync(filepath)) {
-      original = fs.readFileSync(filepath, "utf-8");
+    if (extractedContext) {
+      console.log(chalk.blue(`\n📎 Attached file context detected and loaded.`));
     }
 
-    // Show diff
-    renderDiffBox(action.file, original, action.content);
-
-    // Ask user to confirm
-    const { confirm } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "confirm",
-        message: `Allow RafayGen to write to ${action.file}?`,
-        default: true
-      }
-    ]);
-
-    if (confirm) {
-      fs.mkdirSync(path.dirname(filepath), { recursive: true });
-      fs.writeFileSync(filepath, action.content, "utf-8");
-      printSuccess(`Saved ${action.file}`);
-    } else {
-      console.log(chalk.yellow("Skipped write."));
+    // Detect Skill Execution (e.g. $planner do something)
+    let systemContext = extractedContext;
+    if (cleanPrompt.startsWith("$")) {
+      const skillName = cleanPrompt.split(" ")[0].substring(1);
+      cleanPrompt = cleanPrompt.substring(skillName.length + 2).trim();
+      
+      const skillContext = loadSkillContext(skillName);
+      systemContext += `\n[ACTIVE SKILL: ${skillName}]\n${skillContext}\n`;
+      console.log(chalk.magenta(`\n🔮 Active Skill Injected: ${skillName}`));
     }
-  } else if (action.type === "execute") {
-    renderBox(` Execute Command `, action.command, "magenta");
-    const { confirm } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "confirm",
-        message: `Allow RafayGen to execute this command?`,
-        default: true
-      }
-    ]);
 
-    if (confirm) {
-      await new Promise((resolve) => {
-        const proc = exec(action.command, (err, stdout, stderr) => {
-          if (stdout) console.log(chalk.gray(stdout));
-          if (stderr) console.log(chalk.red(stderr));
-          if (err) printError(`Command failed with code ${err.code}`);
-          else printSuccess("Command executed successfully.");
-          resolve();
-        });
-      });
-    }
+    // Append session state constraints to context
+    const state = getSessionState();
+    systemContext += `\n[CLI STATE: Sandbox=${state.sandboxMode}, Approvals=${state.approvalMode}]`;
+
+    // Pass parsed input and file context to the agent
+    await askAgent(cleanPrompt, systemContext);
   }
 }

package/src/auth.js

@@ -31,14 +31,21 @@ export function setToken(token) {
 }
 
 export function getApiUrl() {
-  // Default to localhost for local testing, can be overridden by environment variable or config
-  return process.env.RG_API_URL || loadConfig().apiUrl || "http://localhost:3000/api/cli";
+  return process.env.RG_API_URL || loadConfig().apiUrl || "https://rafaygen.online/api/cli";
 }
 
 export function setApiUrl(apiUrl) {
   saveConfig({ apiUrl });
 }
 
+export function setModel(model) {
+  saveConfig({ model });
+}
+
+export function getModel() {
+  return loadConfig().model || "default";
+}
+
 export async function startAuthLoop() {
   const inquirer = (await import("inquirer")).default;
   const chalk = (await import("chalk")).default;
@@ -82,25 +89,67 @@ export async function startAuthLoop() {
     }
 
     if (method === "browser") {
-      const loginUrl = "https://rafaygen.com/settings/tokens";
-      console.log(chalk.cyan(`\nOpening browser to: ${loginUrl}`));
-      console.log(chalk.gray("If the browser doesn't open, copy and paste the URL manually."));
-      try {
-        await open(loginUrl);
-      } catch (e) {
-        // Ignore open errors
-      }
+      const PORT = 8080;
+      const CLIENT_ID = "580872142938-2k11f1ced5749euggkqquj5quch0tf43.apps.googleusercontent.com";
+      // We use response_type=token. The token comes in the URL hash, so we serve an HTML page to parse it.
+      const loginUrl = `https://accounts.google.com/o/oauth2/v2/auth?client_id=${CLIENT_ID}&redirect_uri=http://localhost:${PORT}/callback&response_type=token&scope=email%20profile`;
       
-      const { token } = await inquirer.prompt([
-        {
-          type: "password",
-          name: "token",
-          message: "Once you create a token, paste it here:",
-          validate: (input) => input.trim() !== "" ? true : "Token cannot be empty"
-        }
-      ]);
-      setToken(token.trim());
-      printSuccess("Successfully logged in to RafayGen!");
+      console.log(chalk.cyan(`\nSpinning up local server...`));
+      console.log(chalk.gray(`Waiting for Google Authentication on port ${PORT}...`));
+
+      const http = await import("http");
+      
+      await new Promise((resolve) => {
+        const server = http.createServer((req, res) => {
+          if (req.url?.startsWith("/callback")) {
+            // Serve an HTML page that extracts the hash and POSTs it back to us
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <head><title>Authenticating...</title></head>
+                <body>
+                  <h2>Authenticating... Please wait.</h2>
+                  <script>
+                    const hash = window.location.hash.substring(1);
+                    const params = new URLSearchParams(hash);
+                    const token = params.get('access_token');
+                    if (token) {
+                      fetch('/token', { method: 'POST', body: token }).then(() => {
+                        document.body.innerHTML = '<h2>Authentication Successful! You may close this tab.</h2>';
+                      });
+                    } else {
+                      document.body.innerHTML = '<h2>Error: No token found.</h2>';
+                    }
+                  </script>
+                </body>
+              </html>
+            `);
+          } else if (req.url === "/token" && req.method === "POST") {
+            let body = '';
+            req.on('data', chunk => body += chunk.toString());
+            req.on('end', () => {
+              setToken(body.trim());
+              printSuccess("Successfully logged in via Google OAuth!");
+              res.writeHead(200);
+              res.end();
+              server.close();
+              resolve();
+            });
+          } else {
+            res.writeHead(404);
+            res.end();
+          }
+        });
+
+        server.listen(PORT, async () => {
+          console.log(chalk.cyan(`Opening browser to Google Login...`));
+          try {
+            await open(loginUrl);
+          } catch (e) {
+            console.log(chalk.yellow(`Could not open browser automatically. Please open this link:\n${loginUrl}`));
+          }
+        });
+      });
       return;
     }
 

package/src/state.js

@@ -0,0 +1,27 @@
+// Global Session State for rgcli
+export const SessionState = {
+  sandboxMode: "danger-full-access", // read-only, workspace-write, danger-full-access
+  approvalMode: "auto-edit", // suggest, auto-edit, full-auto, never
+  attachedFiles: new Set(),
+  mcpServers: [],
+  reasoningEffort: "medium", // low, medium, high
+  verbose: false,
+  compactMode: false,
+  cwd: process.cwd()
+};
+
+export function getSessionState() {
+  return SessionState;
+}
+
+export function updateSessionState(newState) {
+  Object.assign(SessionState, newState);
+}
+
+export function attachFileContext(filePath) {
+  SessionState.attachedFiles.add(filePath);
+}
+
+export function clearAttachedFiles() {
+  SessionState.attachedFiles.clear();
+}