@involvex/super-agent-cli 0.0.48 → 0.0.50

package/dist/index.js

@@ -46,6 +46,9 @@ class SettingsManager {
     this.userSettingsPath = path.join(os.homedir(), ".super-agent", "settings.json");
     this.projectSettingsPath = path.join(process.cwd(), ".super-agent", "settings.json");
   }
+  getStorageDirectory() {
+    return path.join(os.homedir(), ".super-agent");
+  }
   static getInstance() {
     if (!SettingsManager.instance) {
       SettingsManager.instance = new SettingsManager;
@@ -146,21 +149,24 @@ class SettingsManager {
       this.saveUserSettings(settings);
     }
   }
-  getAvailableModels() {
+  getAvailableModels(providerId) {
+    const activeProvider = providerId || this.getActiveProviderConfig()?.id || "grok";
+    let models = PROVIDER_MODELS[activeProvider];
+    if (!models) {
+      const config = this.getEffectiveSettings().providers[activeProvider];
+      if (config && PROVIDER_MODELS[config.provider]) {
+        models = PROVIDER_MODELS[config.provider];
+      }
+    }
+    if (models) {
+      return models;
+    }
     return [
       "grok-beta",
       "grok-vision-beta",
       "grok-2-vision-1212",
       "grok-2-1212",
-      "grok-code-fast-1",
-      "gpt-4o",
-      "gpt-4o-mini",
-      "o1-preview",
-      "o1-mini",
-      "gemini-3-pro-preview",
-      "gemini-2.5-pro",
-      "gemini-2.5-flash",
-      "GLM-4.7"
+      "grok-code-fast-1"
     ];
   }
   getApiKey() {
@@ -181,8 +187,48 @@ class SettingsManager {
 function getSettingsManager() {
   return SettingsManager.getInstance();
 }
-var SETTINGS_VERSION = 2, DEFAULT_USER_SETTINGS, DEFAULT_PROJECT_SETTINGS;
+var SETTINGS_VERSION = 2, PROVIDER_MODELS, DEFAULT_USER_SETTINGS, DEFAULT_PROJECT_SETTINGS;
 var init_settings_manager = __esm(() => {
+  PROVIDER_MODELS = {
+    grok: [
+      "grok-beta",
+      "grok-vision-beta",
+      "grok-2-vision-1212",
+      "grok-2-1212",
+      "grok-code-fast-1"
+    ],
+    openai: [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "o1-preview",
+      "o1-mini",
+      "gpt-4-turbo",
+      "gpt-3.5-turbo"
+    ],
+    gemini: [
+      "gemini-2.0-flash",
+      "gemini-2.0-pro-exp-02-05",
+      "gemini-1.5-pro",
+      "gemini-1.5-flash"
+    ],
+    mistral: ["mistral-large-latest", "mistral-small-latest", "codestral-latest"],
+    openrouter: [
+      "anthropic/claude-3.5-sonnet",
+      "anthropic/claude-3-opus",
+      "meta-llama/llama-3.1-70b-instruct",
+      "mistralai/mistral-large",
+      "google/gemini-flash-1.5"
+    ],
+    minimax: ["abab6.5s-chat"],
+    groq: [
+      "llama-3.3-70b-versatile",
+      "llama-3.1-8b-instant",
+      "mixtral-8x7b-32768"
+    ],
+    deepseek: ["deepseek-chat", "deepseek-coder"],
+    ollama: ["llama3", "mistral", "codellama"],
+    "workers-ai": ["@cf/meta/llama-3.1-70b-instruct"]
+  };
   DEFAULT_USER_SETTINGS = {
     active_provider: "grok",
     providers: {
@@ -944,7 +990,75 @@ function updateCurrentModel(modelName) {
 
 // src/hooks/use-input-handler.ts
 init_settings_manager();
+
+// src/utils/chat-manager.ts
+init_settings_manager();
 import * as fs3 from "fs-extra";
+import * as path3 from "path";
+
+class ChatManager {
+  static instance;
+  chatDirectory;
+  constructor() {
+    const settingsManager = getSettingsManager();
+    this.chatDirectory = path3.join(settingsManager.getStorageDirectory(), "chats");
+    this.ensureDirectoryExists();
+  }
+  static getInstance() {
+    if (!ChatManager.instance) {
+      ChatManager.instance = new ChatManager;
+    }
+    return ChatManager.instance;
+  }
+  ensureDirectoryExists() {
+    if (!fs3.existsSync(this.chatDirectory)) {
+      fs3.mkdirSync(this.chatDirectory, { recursive: true, mode: 448 });
+    }
+  }
+  getChatPath(name) {
+    return path3.join(this.chatDirectory, `${name}.json`);
+  }
+  async saveChat(name, history) {
+    const filePath = this.getChatPath(name);
+    await fs3.writeJson(filePath, {
+      name,
+      updatedAt: new Date().toISOString(),
+      history
+    }, { spaces: 2, mode: 384 });
+  }
+  async loadChat(name) {
+    const filePath = this.getChatPath(name);
+    if (!fs3.existsSync(filePath)) {
+      throw new Error(`Chat session '${name}' not found.`);
+    }
+    const data = await fs3.readJson(filePath);
+    return data.history.map((entry) => ({
+      ...entry,
+      timestamp: new Date(entry.timestamp)
+    }));
+  }
+  async listChats() {
+    if (!fs3.existsSync(this.chatDirectory)) {
+      return [];
+    }
+    const files = await fs3.readdir(this.chatDirectory);
+    return files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
+  }
+  async deleteChat(name) {
+    const filePath = this.getChatPath(name);
+    if (fs3.existsSync(filePath)) {
+      await fs3.unlink(filePath);
+    } else {
+      throw new Error(`Chat session '${name}' not found.`);
+    }
+  }
+}
+function getChatManager() {
+  return ChatManager.getInstance();
+}
+
+// src/hooks/use-input-handler.ts
+import * as fs4 from "fs-extra";
 function useInputHandler({
   agent,
   chatHistory,
@@ -1285,12 +1399,19 @@ function useInputHandler({
     { command: "/models", description: "Switch Super Agent Model" },
     { command: "/config", description: "View or edit configuration" },
     { command: "/provider", description: "Manage AI providers" },
+    { command: "/chat save <name>", description: "Save current chat" },
+    { command: "/chat load <name>", description: "Load a saved chat" },
+    { command: "/chat list", description: "List saved chats" },
+    { command: "/chat delete <name>", description: "Delete a saved chat" },
     { command: "/commit-and-push", description: "AI commit & push to remote" },
     { command: "/exit", description: "Exit the application" }
   ];
+  const [activeProvider, setActiveProvider] = useState3(() => {
+    return getSettingsManager().loadUserSettings().active_provider;
+  });
   const availableModels = useMemo2(() => {
     return loadModelConfig();
-  }, []);
+  }, [activeProvider]);
   const handleDirectCommand = async (input2) => {
     const trimmedInput = input2.trim();
     if (trimmedInput === "/clear") {
@@ -1361,15 +1482,27 @@ Config Commands:
       const settings = manager.loadUserSettings();
       if (settings.providers && settings.providers[providerId]) {
         manager.updateUserSetting("active_provider", providerId);
-        setChatHistory((prev) => [
-          ...prev,
-          {
-            type: "assistant",
-            content: `✓ Switched active provider to: ${providerId}`,
-            timestamp: new Date
-          }
-        ]);
-        const newConfig = settings.providers[providerId];
+        try {
+          agent.setProvider(providerId);
+          setActiveProvider(providerId);
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✓ Switched active provider to: ${providerId}`,
+              timestamp: new Date
+            }
+          ]);
+        } catch (error) {
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `❌ Failed to switch provider: ${error.message}`,
+              timestamp: new Date
+            }
+          ]);
+        }
       } else {
         setChatHistory((prev) => [
           ...prev,
@@ -1431,6 +1564,91 @@ Available models: ${modelNames.join(", ")}`,
       clearInput();
       return true;
     }
+    if (trimmedInput.startsWith("/chat ")) {
+      const args = trimmedInput.replace("/chat ", "").split(" ");
+      const action = args[0];
+      const name = args.slice(1).join(" ");
+      const chatManager = getChatManager();
+      try {
+        if (action === "save") {
+          if (!name) {
+            throw new Error("Chat name is required.");
+          }
+          await chatManager.saveChat(name, chatHistory);
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✓ Chat saved as '${name}'.`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (action === "load") {
+          if (!name) {
+            throw new Error("Chat name is required.");
+          }
+          const history = await chatManager.loadChat(name);
+          setChatHistory(history);
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✓ Chat '${name}' loaded.`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (action === "list") {
+          const chats = await chatManager.listChats();
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `Saved Chats:
+${chats.length ? chats.map((c) => `- ${c}`).join(`
+`) : "No saved chats."}`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (action === "delete") {
+          if (!name) {
+            throw new Error("Chat name is required.");
+          }
+          await chatManager.deleteChat(name);
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              type: "assistant",
+              content: `✓ Chat '${name}' deleted.`,
+              timestamp: new Date
+            }
+          ]);
+        } else if (action === "clear") {
+          setChatHistory([]);
+          setIsProcessing(false);
+          setIsStreaming(false);
+          setTokenCount(0);
+          setProcessingTime(0);
+          processingStartTime.current = 0;
+          ConfirmationService.getInstance().resetSession();
+          clearInput();
+          resetHistory();
+          return true;
+        } else {
+          throw new Error(`Unknown chat action: ${action}`);
+        }
+      } catch (error) {
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            type: "assistant",
+            content: `❌ Error: ${error.message}`,
+            timestamp: new Date
+          }
+        ]);
+      }
+      clearInput();
+      return true;
+    }
     if (trimmedInput === "/commit-and-push") {
       const userEntry = {
         type: "user",
@@ -1682,9 +1900,9 @@ ${commitMessage}`
       for (const mention of mentionMatches) {
         const filePath = mention.slice(1);
         try {
-          const stats = await fs3.stat(filePath);
+          const stats = await fs4.stat(filePath);
           if (stats.isFile()) {
-            const content = await fs3.readFile(filePath, "utf-8");
+            const content = await fs4.readFile(filePath, "utf-8");
             resolvedInput = resolvedInput.replace(mention, `
 
 --- FILE: ${filePath} ---
@@ -3250,8 +3468,8 @@ class ConfirmationTool {
   }
 }
 // src/tools/morph-editor.ts
-import * as path3 from "path";
-import fs4 from "fs-extra";
+import * as path4 from "path";
+import fs5 from "fs-extra";
 import axios from "axios";
 
 class MorphEditorTool {
@@ -3266,8 +3484,8 @@ class MorphEditorTool {
   }
   async editFile(targetFile, instructions, codeEdit) {
     try {
-      const resolvedPath = path3.resolve(targetFile);
-      if (!await fs4.pathExists(resolvedPath)) {
+      const resolvedPath = path4.resolve(targetFile);
+      if (!await fs5.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${targetFile}`
@@ -3279,7 +3497,7 @@ class MorphEditorTool {
           error: "MORPH_API_KEY not configured. Please set your Morph API key."
         };
       }
-      const initialCode = await fs4.readFile(resolvedPath, "utf-8");
+      const initialCode = await fs5.readFile(resolvedPath, "utf-8");
       const sessionFlags = this.confirmationService.getSessionFlags();
       if (!sessionFlags.fileOperations && !sessionFlags.allOperations) {
         const confirmationResult = await this.confirmationService.requestConfirmation({
@@ -3299,7 +3517,7 @@ ${codeEdit}`
         }
       }
       const mergedCode = await this.callMorphApply(instructions, initialCode, codeEdit);
-      await fs4.writeFile(resolvedPath, mergedCode, "utf-8");
+      await fs5.writeFile(resolvedPath, mergedCode, "utf-8");
       const oldLines = initialCode.split(`
 `);
       const newLines = mergedCode.split(`
@@ -3482,11 +3700,11 @@ ${codeEdit}`
   }
   async view(filePath, viewRange) {
     try {
-      const resolvedPath = path3.resolve(filePath);
-      if (await fs4.pathExists(resolvedPath)) {
-        const stats = await fs4.stat(resolvedPath);
+      const resolvedPath = path4.resolve(filePath);
+      if (await fs5.pathExists(resolvedPath)) {
+        const stats = await fs5.stat(resolvedPath);
         if (stats.isDirectory()) {
-          const files = await fs4.readdir(resolvedPath);
+          const files = await fs5.readdir(resolvedPath);
           return {
             success: true,
             output: `Directory contents of ${filePath}:
@@ -3494,7 +3712,7 @@ ${files.join(`
 `)}`
           };
         }
-        const content = await fs4.readFile(resolvedPath, "utf-8");
+        const content = await fs5.readFile(resolvedPath, "utf-8");
         const lines = content.split(`
 `);
         if (viewRange) {
@@ -3540,8 +3758,8 @@ ${numberedLines}${additionalLinesMessage}`
   }
 }
 // src/tools/project-map.ts
-import * as path4 from "path";
-import fs5 from "fs-extra";
+import * as path5 from "path";
+import fs6 from "fs-extra";
 
 class ProjectMapTool {
   currentDirectory = process.cwd();
@@ -3575,7 +3793,7 @@ Important Files:
     }
     let result = "";
     try {
-      const entries = await fs5.readdir(dir, { withFileTypes: true });
+      const entries = await fs6.readdir(dir, { withFileTypes: true });
       const sortedEntries = entries.sort((a, b) => {
         if (a.isDirectory() && !b.isDirectory()) {
           return -1;
@@ -3603,7 +3821,7 @@ Important Files:
         if (entry.isDirectory()) {
           result += `${indent}\uD83D\uDCC1 ${entry.name}/
 `;
-          result += await this.generateTree(path4.join(dir, entry.name), maxDepth, currentDepth + 1);
+          result += await this.generateTree(path5.join(dir, entry.name), maxDepth, currentDepth + 1);
         } else {
           result += `${indent}\uD83D\uDCC4 ${entry.name}
 `;
@@ -3625,8 +3843,8 @@ Important Files:
     ];
     const found = [];
     for (const pattern of importantPatterns) {
-      const fullPath = path4.join(this.currentDirectory, pattern);
-      if (await fs5.pathExists(fullPath)) {
+      const fullPath = path5.join(this.currentDirectory, pattern);
+      if (await fs6.pathExists(fullPath)) {
         found.push(pattern);
       }
     }
@@ -3638,8 +3856,8 @@ Important Files:
 }
 // src/tools/search.ts
 import { spawn } from "child_process";
-import * as path5 from "path";
-import fs6 from "fs-extra";
+import * as path6 from "path";
+import fs7 from "fs-extra";
 
 class SearchTool {
   confirmationService = ConfirmationService.getInstance();
@@ -3779,13 +3997,13 @@ class SearchTool {
         return;
       }
       try {
-        const entries = await fs6.readdir(dir, { withFileTypes: true });
+        const entries = await fs7.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           if (files.length >= maxResults) {
             break;
           }
-          const fullPath = path5.join(dir, entry.name);
-          const relativePath = path5.relative(this.currentDirectory, fullPath);
+          const fullPath = path6.join(dir, entry.name);
+          const relativePath = path6.relative(this.currentDirectory, fullPath);
           if (!options.includeHidden && entry.name.startsWith(".")) {
             continue;
           }
@@ -3884,19 +4102,19 @@ class SearchTool {
 }
 // src/tools/text-editor.ts
 import { writeFile as writeFilePromise } from "fs/promises";
-import * as path6 from "path";
-import fs7 from "fs-extra";
+import * as path7 from "path";
+import fs8 from "fs-extra";
 
 class TextEditorTool {
   editHistory = [];
   confirmationService = ConfirmationService.getInstance();
   async view(filePath, viewRange) {
     try {
-      const resolvedPath = path6.resolve(filePath);
-      if (await fs7.pathExists(resolvedPath)) {
-        const stats = await fs7.stat(resolvedPath);
+      const resolvedPath = path7.resolve(filePath);
+      if (await fs8.pathExists(resolvedPath)) {
+        const stats = await fs8.stat(resolvedPath);
         if (stats.isDirectory()) {
-          const files = await fs7.readdir(resolvedPath);
+          const files = await fs8.readdir(resolvedPath);
           return {
             success: true,
             output: `Directory contents of ${filePath}:
@@ -3904,7 +4122,7 @@ ${files.join(`
 `)}`
           };
         }
-        const content = await fs7.readFile(resolvedPath, "utf-8");
+        const content = await fs8.readFile(resolvedPath, "utf-8");
         const lines = content.split(`
 `);
         if (viewRange) {
@@ -3944,14 +4162,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async strReplace(filePath, oldStr, newStr, replaceAll = false) {
     try {
-      const resolvedPath = path6.resolve(filePath);
-      if (!await fs7.pathExists(resolvedPath)) {
+      const resolvedPath = path7.resolve(filePath);
+      if (!await fs8.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const content = await fs7.readFile(resolvedPath, "utf-8");
+      const content = await fs8.readFile(resolvedPath, "utf-8");
       if (!content.includes(oldStr)) {
         if (oldStr.includes(`
 `)) {
@@ -4019,7 +4237,7 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async create(filePath, content) {
     try {
-      const resolvedPath = path6.resolve(filePath);
+      const resolvedPath = path7.resolve(filePath);
       const sessionFlags = this.confirmationService.getSessionFlags();
       if (!sessionFlags.fileOperations && !sessionFlags.allOperations) {
         const contentLines = content.split(`
@@ -4045,8 +4263,8 @@ ${numberedLines}${additionalLinesMessage}`
           };
         }
       }
-      const dir = path6.dirname(resolvedPath);
-      await fs7.ensureDir(dir);
+      const dir = path7.dirname(resolvedPath);
+      await fs8.ensureDir(dir);
       await writeFilePromise(resolvedPath, content, "utf-8");
       this.editHistory.push({
         command: "create",
@@ -4070,14 +4288,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async replaceLines(filePath, startLine, endLine, newContent) {
     try {
-      const resolvedPath = path6.resolve(filePath);
-      if (!await fs7.pathExists(resolvedPath)) {
+      const resolvedPath = path7.resolve(filePath);
+      if (!await fs8.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const fileContent = await fs7.readFile(resolvedPath, "utf-8");
+      const fileContent = await fs8.readFile(resolvedPath, "utf-8");
       const lines = fileContent.split(`
 `);
       if (startLine < 1 || startLine > lines.length) {
@@ -4140,14 +4358,14 @@ ${numberedLines}${additionalLinesMessage}`
   }
   async insert(filePath, insertLine, content) {
     try {
-      const resolvedPath = path6.resolve(filePath);
-      if (!await fs7.pathExists(resolvedPath)) {
+      const resolvedPath = path7.resolve(filePath);
+      if (!await fs8.pathExists(resolvedPath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
         };
       }
-      const fileContent = await fs7.readFile(resolvedPath, "utf-8");
+      const fileContent = await fs8.readFile(resolvedPath, "utf-8");
       const lines = fileContent.split(`
 `);
       lines.splice(insertLine - 1, 0, content);
@@ -4183,19 +4401,19 @@ ${numberedLines}${additionalLinesMessage}`
       switch (lastEdit.command) {
         case "str_replace":
           if (lastEdit.path && lastEdit.old_str && lastEdit.new_str) {
-            const content = await fs7.readFile(lastEdit.path, "utf-8");
+            const content = await fs8.readFile(lastEdit.path, "utf-8");
             const revertedContent = content.replace(lastEdit.new_str, lastEdit.old_str);
             await writeFilePromise(lastEdit.path, revertedContent, "utf-8");
           }
           break;
         case "create":
           if (lastEdit.path) {
-            await fs7.remove(lastEdit.path);
+            await fs8.remove(lastEdit.path);
           }
           break;
         case "insert":
           if (lastEdit.path && lastEdit.insert_line) {
-            const content = await fs7.readFile(lastEdit.path, "utf-8");
+            const content = await fs8.readFile(lastEdit.path, "utf-8");
             const lines = content.split(`
 `);
             lines.splice(lastEdit.insert_line - 1, 1);
@@ -5326,19 +5544,19 @@ class OpenAICompatibleProvider {
 }
 
 // src/utils/custom-instructions.ts
-import * as path7 from "path";
+import * as path8 from "path";
 import * as os2 from "os";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 function loadCustomInstructions(workingDirectory = process.cwd()) {
   try {
-    let instructionsPath = path7.join(workingDirectory, ".super-agent", "SUPER_AGENT.md");
-    if (fs8.existsSync(instructionsPath)) {
-      const customInstructions = fs8.readFileSync(instructionsPath, "utf-8");
+    let instructionsPath = path8.join(workingDirectory, ".super-agent", "SUPER_AGENT.md");
+    if (fs9.existsSync(instructionsPath)) {
+      const customInstructions = fs9.readFileSync(instructionsPath, "utf-8");
       return customInstructions.trim();
     }
-    instructionsPath = path7.join(os2.homedir(), ".super-agent", "SUPER_AGENT.md");
-    if (fs8.existsSync(instructionsPath)) {
-      const customInstructions = fs8.readFileSync(instructionsPath, "utf-8");
+    instructionsPath = path8.join(os2.homedir(), ".super-agent", "SUPER_AGENT.md");
+    if (fs9.existsSync(instructionsPath)) {
+      const customInstructions = fs9.readFileSync(instructionsPath, "utf-8");
       return customInstructions.trim();
     }
     return null;
@@ -5770,6 +5988,30 @@ IMPORTANT RESPONSE GUIDELINES:
 Current working directory: ${process.cwd()}`
     });
   }
+  setProvider(providerId) {
+    const manager = getSettingsManager();
+    const settings = manager.loadUserSettings();
+    const activeProviderId = (providerId || "grok").toLowerCase();
+    if (activeProviderId === "zai") {}
+    const providerConfig = settings.providers[activeProviderId];
+    if (!providerConfig) {
+      throw new Error(`Provider '${activeProviderId}' not configured.`);
+    }
+    const providerType = providerConfig.provider || activeProviderId;
+    const effectiveApiKey = providerConfig.api_key || "";
+    const effectiveBaseURL = providerConfig.base_url || undefined;
+    const effectiveModel = providerConfig.model || providerConfig.default_model || "grok-code-fast-1";
+    if (providerType === "openai") {
+      this.superAgentClient = new OpenAIProvider(effectiveApiKey, effectiveBaseURL, effectiveModel);
+    } else if (providerType === "gemini" || providerType === "google") {
+      this.superAgentClient = new GeminiProvider(effectiveApiKey, effectiveBaseURL, effectiveModel);
+    } else if (providerType === "grok") {
+      this.superAgentClient = new GrokProvider(effectiveApiKey, effectiveBaseURL, effectiveModel);
+    } else {
+      this.superAgentClient = new OpenAICompatibleProvider(effectiveApiKey, effectiveBaseURL || "", effectiveModel, activeProviderId);
+    }
+    this.tokenCounter = createTokenCounter(effectiveModel);
+  }
   async initializeMCP() {
     Promise.resolve().then(async () => {
       try {
@@ -7211,7 +7453,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "@involvex/super-agent-cli",
-  version: "0.0.48",
+  version: "0.0.50",
   description: "An open-source AI agent that brings the power of Super Agent directly into your terminal.",
   keywords: [
     "cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@involvex/super-agent-cli",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "An open-source AI agent that brings the power of Super Agent directly into your terminal.",
   "keywords": [
     "cli",