@involvex/super-agent-cli 0.0.49 → 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;
@@ -987,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,
@@ -1328,6 +1399,10 @@ 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" }
   ];
@@ -1489,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",
@@ -1740,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} ---
@@ -3308,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 {
@@ -3324,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}`
@@ -3337,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({
@@ -3357,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(`
@@ -3540,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}:
@@ -3552,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) {
@@ -3598,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();
@@ -3633,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;
@@ -3661,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}
 `;
@@ -3683,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);
       }
     }
@@ -3696,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();
@@ -3837,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;
           }
@@ -3942,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}:
@@ -3962,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) {
@@ -4002,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(`
 `)) {
@@ -4077,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(`
@@ -4103,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",
@@ -4128,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) {
@@ -4198,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);
@@ -4241,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);
@@ -5384,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;
@@ -7293,7 +7453,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "@involvex/super-agent-cli",
-  version: "0.0.49",
+  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.49",
+  "version": "0.0.50",
   "description": "An open-source AI agent that brings the power of Super Agent directly into your terminal.",
   "keywords": [
     "cli",