quantrexa-ai 0.0.0-stage → 1.0.0

package/cli.js

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { exec } = require('child_process');
+
+const BACKEND_URL = "https://quantrexa-prime-backend.onrender.com";
+const CONFIG_DIR = path.join(os.homedir(), '.quantrexa');
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+
+const C = {
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  magenta: "\x1b[35m",
+  red: "\x1b[31m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  reset: "\x1b[0m"
+};
+
+function getSavedSession() {
+  try {
+    if (fs.existsSync(AUTH_FILE)) {
+      const data = JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8'));
+      if (data && data.token) return data;
+    }
+  } catch (e) {}
+  return null;
+}
+
+function saveSession(token, user) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify({ token, user, savedAt: Date.now() }, null, 2), 'utf8');
+}
+
+function clearSession() {
+  if (fs.existsSync(AUTH_FILE)) fs.unlinkSync(AUTH_FILE);
+}
+
+// 🛠️ Powerful Agent Tools (Local PC Execution)
+const AGENT_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read complete content of a file in the user's workspace.",
+      parameters: {
+        type: "object",
+        properties: { filepath: { type: "string" } },
+        required: ["filepath"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Write or create a complete source code or document file on the user's disk.",
+      parameters: {
+        type: "object",
+        properties: {
+          filepath: { type: "string" },
+          content: { type: "string" }
+        },
+        required: ["filepath", "content"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_directory",
+      description: "List files and subdirectories in the project.",
+      parameters: {
+        type: "object",
+        properties: { dirpath: { type: "string" } }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description: "Run a safe terminal shell command (e.g., git status, npm run build, dir, python test.py).",
+      parameters: {
+        type: "object",
+        properties: { command: { type: "string" } },
+        required: ["command"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search Google in real-time via Quantrexa cloud servers for documentation, error fixes, or live data.",
+      parameters: {
+        type: "object",
+        properties: { query: { type: "string" } },
+        required: ["query"]
+      }
+    }
+  }
+];
+
+async function executeLocalTool(name, args) {
+  try {
+    if (name === "read_file") {
+      const fullPath = path.resolve(process.cwd(), args.filepath);
+      if (!fs.existsSync(fullPath)) return `File '${args.filepath}' not found.`;
+      const data = fs.readFileSync(fullPath, 'utf8');
+      console.log(`${C.yellow}  ⚡ [Tool: Read File] ${args.filepath} (${data.length} chars)${C.reset}`);
+      return data.slice(0, 16000);
+    }
+
+    if (name === "write_file") {
+      const fullPath = path.resolve(process.cwd(), args.filepath);
+      const parent = path.dirname(fullPath);
+      if (!fs.existsSync(parent)) fs.mkdirSync(parent, { recursive: true });
+      fs.writeFileSync(fullPath, args.content, 'utf8');
+      console.log(`${C.green}  ⚡ [Tool: File Written] ${args.filepath} (${args.content.length} bytes)${C.reset}`);
+      return `File ${args.filepath} written successfully.`;
+    }
+
+    if (name === "list_directory") {
+      const target = path.resolve(process.cwd(), args.dirpath || '.');
+      const items = fs.readdirSync(target);
+      console.log(`${C.yellow}  ⚡ [Tool: Scan Directory] Found ${items.length} files${C.reset}`);
+      return JSON.stringify(items);
+    }
+
+    if (name === "run_command") {
+      console.log(`${C.magenta}  ⚡ [Tool: Running Shell] $ ${args.command}${C.reset}`);
+      return new Promise(resolve => {
+        exec(args.command, { timeout: 20000, cwd: process.cwd() }, (err, stdout, stderr) => {
+          if (err) return resolve(`Command Error: ${stderr || err.message}`);
+          resolve(stdout.slice(0, 8000) || "Command completed with no output.");
+        });
+      });
+    }
+
+    if (name === "web_search") {
+      console.log(`${C.cyan}  ⚡ [Tool: Web Search] "${args.query}"...${C.reset}`);
+      const r = await fetch(`${BACKEND_URL}/api/search?q=${encodeURIComponent(args.query)}`);
+      const d = await r.json();
+      if (d.organic_results?.length) {
+        return d.organic_results.slice(0, 4).map(res => `${res.title} (${res.link}): ${res.snippet}`).join('\n\n');
+      }
+      return "No results found.";
+    }
+  } catch (err) {
+    return `Tool error: ${err.message}`;
+  }
+  return "Unknown tool";
+}
+
+// 🔐 Mandatory Login Gate (Terminal OTP)
+function promptLogin(rl) {
+  return new Promise(resolve => {
+    console.log(`\n${C.bold}${C.yellow}====================================================${C.reset}`);
+    console.log(`${C.bold}  🔒 QUANTREXA PRIME AI — CLI LOGIN REQUIRED        ${C.reset}`);
+    console.log(`${C.yellow}====================================================${C.reset}`);
+    console.log(`${C.dim}Account verification is required to use this AI Agent.${C.reset}\n`);
+
+    rl.question(`${C.cyan}Enter your Quantrexa Email: ${C.reset}`, async (emailInput) => {
+      const email = emailInput.trim().toLowerCase();
+      if (!email || !email.includes('@')) {
+        console.log(`${C.red}Invalid email. Try again.${C.reset}\n`);
+        return resolve(promptLogin(rl));
+      }
+
+      console.log(`${C.dim}Sending 6-digit OTP code to ${email}...${C.reset}`);
+
+      try {
+        const sendRes = await fetch(`${BACKEND_URL}/api/send-otp`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ email })
+        });
+        const sendData = await sendRes.json();
+
+        if (!sendRes.ok || !sendData.success) {
+          console.log(`${C.red}Failed: ${sendData.error || 'Server error'}${C.reset}\n`);
+          return resolve(false);
+        }
+
+        console.log(`${C.green}✓ OTP code sent to your email inbox!${C.reset}`);
+
+        rl.question(`${C.cyan}Enter 6-Digit OTP: ${C.reset}`, async (otpInput) => {
+          const otp = otpInput.trim();
+          console.log(`${C.dim}Authenticating with Quantrexa Cloud...${C.reset}`);
+
+          const verifyRes = await fetch(`${BACKEND_URL}/api/verify-otp`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, otp })
+          });
+          const verifyData = await verifyRes.json();
+
+          if (verifyRes.ok && verifyData.success && verifyData.token) {
+            saveSession(verifyData.token, verifyData.user);
+            console.log(`\n${C.green}${C.bold}✓ Logged in as: ${verifyData.user.email}!${C.reset}\n`);
+            resolve(verifyData);
+          } else {
+            console.log(`${C.red}❌ Invalid OTP code.${C.reset}\n`);
+            resolve(false);
+          }
+        });
+      } catch (err) {
+        console.log(`${C.red}Connection error: ${err.message}${C.reset}\n`);
+        resolve(false);
+      }
+    });
+  });
+}
+
+async function startAgent() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  let session = getSavedSession();
+
+  // If not logged in, enforce login first
+  if (!session) {
+    const loggedIn = await promptLogin(rl);
+    if (!loggedIn) {
+      console.log(`${C.red}Authentication required. Quantrexa CLI exiting.${C.reset}`);
+      rl.close();
+      process.exit(1);
+    }
+    session = getSavedSession();
+  }
+
+  console.clear();
+  console.log(`${C.bold}${C.cyan}======================================================${C.reset}`);
+  console.log(`${C.bold}${C.magenta}     QUANTREXA PRIME — AUTONOMOUS CODING AGENT        ${C.reset}`);
+  console.log(`${C.cyan}======================================================${C.reset}`);
+  console.log(`${C.green}● Cloud Brain:${C.reset} Google Gemini 2.5 Flash (${BACKEND_URL})`);
+  console.log(`${C.green}● User Account:${C.reset} ${session.user?.email}`);
+  console.log(`${C.yellow}● Local Dir   :${C.reset} ${process.cwd()}`);
+  console.log(`${C.dim}Commands: 'logout' to switch account | 'exit' to quit.${C.reset}\n`);
+
+  const conversation = [
+    {
+      role: "system",
+      content: `You are Quantrexa Autonomous Coding Agent powered by Gemini.
+You run directly on the user's terminal inside directory: ${process.cwd()}.
+You have tools to: read_file, write_file, list_directory, run_command, and web_search.
+When tasked with writing, fixing, or building software:
+1. Examine existing files first if necessary.
+2. Write full, complete, production-ready code directly to disk using write_file.
+3. If dependencies or builds are required, execute them using run_command.
+4. Report back concisely once the tasks are completed.`
+    }
+  ];
+
+  const ask = () => {
+    rl.question(`${C.bold}${C.cyan}Quantrexa > ${C.reset}`, async (input) => {
+      const query = input.trim();
+      if (!query) return ask();
+
+      if (query.toLowerCase() === 'exit' || query.toLowerCase() === 'quit') {
+        console.log(`\n${C.yellow}Goodbye!${C.reset}\n`);
+        rl.close();
+        process.exit(0);
+      }
+
+      if (query.toLowerCase() === 'logout') {
+        clearSession();
+        console.log(`\n${C.yellow}Logged out successfully.${C.reset}\n`);
+        rl.close();
+        process.exit(0);
+      }
+
+      conversation.push({ role: "user", content: query });
+      console.log(`${C.dim}Agent thinking with Gemini...${C.reset}`);
+
+      try {
+        let isComplete = false;
+        let loopCount = 0;
+
+        while (!isComplete && loopCount < 10) {
+          loopCount++;
+
+          const res = await fetch(`${BACKEND_URL}/api/agent`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${session.token}`,
+              'x-client-type': 'cli'
+            },
+            body: JSON.stringify({
+              conversation,
+              tools: AGENT_TOOLS
+            })
+          });
+
+          if (res.status === 401) {
+            console.log(`\n${C.red}Session expired. Please login again.${C.reset}`);
+            clearSession();
+            rl.close();
+            process.exit(1);
+          }
+
+          const data = await res.json();
+          const choice = data.choices?.[0];
+          if (!choice) throw new Error(data.error || "Backend returned empty response.");
+
+          const msg = choice.message;
+
+          // Agent executes tool on user's machine
+          if (msg.tool_calls && msg.tool_calls.length) {
+            conversation.push(msg);
+
+            for (const call of msg.tool_calls) {
+              const fnName = call.function.name;
+              const fnArgs = JSON.parse(call.function.arguments || "{}");
+
+              const result = await executeLocalTool(fnName, fnArgs);
+
+              conversation.push({
+                role: "tool",
+                tool_call_id: call.id,
+                name: fnName,
+                content: String(result)
+              });
+            }
+          } else {
+            console.log(`\n${C.bold}${C.green}Quantrexa Agent:${C.reset}\n${msg.content}\n`);
+            conversation.push(msg);
+            isComplete = true;
+          }
+        }
+      } catch (err) {
+        console.error(`${C.red}Error: ${err.message}${C.reset}\n`);
+      }
+
+      ask();
+    });
+  };
+
+  ask();
+}
+
+startAgent();

package/package.json

@@ -1,6 +1,16 @@
-{
-  "name": "quantrexa-ai",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+  "name": "quantrexa-ai",
+  "version": "1.0.0",
+  "description": "Quantrexa Prime AI — Autonomous Developer & System CLI Agent",
+  "main": "cli.js",
+  "bin": {
+    "quantrexa": "./cli.js",
+    "quantrexa-ai": "./cli.js"
+  },
+  "keywords": ["quantrexa", "ai", "cli", "agent", "gemini", "coding", "developer"],
+  "author": "Purav Raj",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.