snow-ai 0.8.12 → 0.8.13

package/bundle/cli.mjs

@@ -509646,6 +509646,222 @@ var init_toolDisplayConfig = __esm({
   }
 });
 
+// dist/utils/ui/diffPreview.js
+import fs38 from "fs";
+function readOriginalFile(filePath) {
+  try {
+    if (!filePath || !fs38.existsSync(filePath))
+      return null;
+    return fs38.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function computeHashlinePreview(originalContent, operations) {
+  if (!Array.isArray(operations) || operations.length === 0) {
+    return originalContent;
+  }
+  const mutableLines = originalContent.split("\n");
+  const parsed = operations.map((op2) => {
+    const startMatch = String(op2.startAnchor ?? "").match(/^(\d+):/);
+    const endMatch = String(op2.endAnchor ?? "").match(/^(\d+):/);
+    return {
+      type: op2.type,
+      content: op2.content ?? "",
+      startLine: startMatch ? parseInt(startMatch[1], 10) : 0,
+      endLine: endMatch ? parseInt(endMatch[1], 10) : 0
+    };
+  }).filter((op2) => op2.startLine > 0 && op2.endLine > 0).sort((a, b) => b.startLine - a.startLine);
+  for (const op2 of parsed) {
+    const newLines = op2.content.split("\n");
+    switch (op2.type) {
+      case "replace":
+        mutableLines.splice(op2.startLine - 1, op2.endLine - op2.startLine + 1, ...newLines);
+        break;
+      case "insert_after":
+        mutableLines.splice(op2.startLine, 0, ...newLines);
+        break;
+      case "delete":
+        mutableLines.splice(op2.startLine - 1, op2.endLine - op2.startLine + 1);
+        break;
+    }
+  }
+  return mutableLines.join("\n");
+}
+function computeReplaceEditPreview(originalContent, searchContent, replaceContent) {
+  const idx = originalContent.indexOf(searchContent);
+  if (idx !== -1) {
+    return originalContent.substring(0, idx) + replaceContent + originalContent.substring(idx + searchContent.length);
+  }
+  return originalContent;
+}
+function collectDiffPreviewEntries(toolName, toolArgs) {
+  const entries = [];
+  try {
+    const parsed = JSON.parse(toolArgs);
+    if (typeof parsed.filePath === "string" && parsed.filePath.trimStart().startsWith("[")) {
+      try {
+        parsed.filePath = JSON.parse(parsed.filePath);
+      } catch {
+      }
+    }
+    if (toolName === "filesystem-edit" && parsed.filePath) {
+      if (typeof parsed.filePath === "string") {
+        const originalContent = readOriginalFile(parsed.filePath);
+        if (originalContent !== null) {
+          const newContent = computeHashlinePreview(originalContent, parsed.operations);
+          entries.push({
+            filePath: parsed.filePath,
+            oldContent: originalContent,
+            newContent
+          });
+        }
+      } else if (Array.isArray(parsed.filePath)) {
+        for (const item of parsed.filePath) {
+          if (item && typeof item === "object" && typeof item.path === "string") {
+            const originalContent = readOriginalFile(item.path);
+            if (originalContent !== null) {
+              const newContent = computeHashlinePreview(originalContent, item.operations);
+              entries.push({
+                filePath: item.path,
+                oldContent: originalContent,
+                newContent
+              });
+            }
+          }
+        }
+      }
+    }
+    if (toolName === "filesystem-replaceedit" && parsed.filePath) {
+      if (typeof parsed.filePath === "string") {
+        const originalContent = readOriginalFile(parsed.filePath);
+        if (originalContent !== null) {
+          const newContent = parsed.searchContent && parsed.replaceContent !== void 0 ? computeReplaceEditPreview(originalContent, parsed.searchContent, parsed.replaceContent) : originalContent;
+          entries.push({
+            filePath: parsed.filePath,
+            oldContent: originalContent,
+            newContent
+          });
+        }
+      } else if (Array.isArray(parsed.filePath)) {
+        for (const item of parsed.filePath) {
+          if (typeof item === "string") {
+            const originalContent = readOriginalFile(item);
+            if (originalContent !== null) {
+              const newContent = parsed.searchContent && parsed.replaceContent !== void 0 ? computeReplaceEditPreview(originalContent, parsed.searchContent, parsed.replaceContent) : originalContent;
+              entries.push({
+                filePath: item,
+                oldContent: originalContent,
+                newContent
+              });
+            }
+          } else if (item && typeof item === "object" && typeof item.path === "string") {
+            const originalContent = readOriginalFile(item.path);
+            if (originalContent !== null) {
+              const search = item.searchContent ?? parsed.searchContent;
+              const replace = item.replaceContent ?? parsed.replaceContent;
+              const newContent = search && replace !== void 0 ? computeReplaceEditPreview(originalContent, search, replace) : originalContent;
+              entries.push({
+                filePath: item.path,
+                oldContent: originalContent,
+                newContent
+              });
+            }
+          }
+        }
+      }
+    }
+    if (toolName === "filesystem-create" && parsed.filePath) {
+      if (typeof parsed.filePath === "string" && parsed.content) {
+        const originalContent = readOriginalFile(parsed.filePath) ?? "";
+        entries.push({
+          filePath: parsed.filePath,
+          oldContent: originalContent,
+          newContent: parsed.content
+        });
+      } else if (Array.isArray(parsed.filePath)) {
+        for (const item of parsed.filePath) {
+          if (item && typeof item === "object" && typeof item.path === "string" && typeof item.content === "string") {
+            const originalContent = readOriginalFile(item.path) ?? "";
+            entries.push({
+              filePath: item.path,
+              oldContent: originalContent,
+              newContent: item.content
+            });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+function enrichPendingEditArgs(toolName, toolArgs) {
+  if (toolName !== "filesystem-edit" && toolName !== "filesystem-replaceedit" && toolName !== "filesystem-create") {
+    return toolArgs;
+  }
+  const rawFilePath = toolArgs["filePath"];
+  if (typeof rawFilePath === "string" && rawFilePath.trimStart().startsWith("[")) {
+    try {
+      toolArgs = { ...toolArgs, filePath: JSON.parse(rawFilePath) };
+    } catch {
+    }
+  }
+  const isBatch = toolArgs["isBatch"] || Array.isArray(toolArgs["filePath"]);
+  if (!isBatch) {
+    const entries2 = collectDiffPreviewEntries(toolName, JSON.stringify(toolArgs));
+    if (entries2.length === 1) {
+      const entry = entries2[0];
+      if (toolName === "filesystem-create") {
+        return {
+          ...toolArgs,
+          content: entry.newContent,
+          path: entry.filePath
+        };
+      }
+      return {
+        ...toolArgs,
+        oldContent: entry.oldContent,
+        newContent: entry.newContent,
+        filename: entry.filePath
+      };
+    }
+    return toolArgs;
+  }
+  const entries = collectDiffPreviewEntries(toolName, JSON.stringify(toolArgs));
+  if (entries.length === 0) {
+    return toolArgs;
+  }
+  if (toolName === "filesystem-create") {
+    const batchResults2 = entries.map((entry) => ({
+      success: true,
+      path: entry.filePath,
+      content: entry.newContent
+    }));
+    return {
+      ...toolArgs,
+      isBatch: true,
+      batchResults: batchResults2
+    };
+  }
+  const batchResults = entries.map((entry) => ({
+    success: true,
+    path: entry.filePath,
+    oldContent: entry.oldContent,
+    newContent: entry.newContent
+  }));
+  return {
+    ...toolArgs,
+    isBatch: true,
+    batchResults
+  };
+}
+var init_diffPreview = __esm({
+  "dist/utils/ui/diffPreview.js"() {
+    "use strict";
+  }
+});
+
 // dist/hooks/conversation/core/subAgentMessageHandler.js
 var subAgentMessageHandler_exports = {};
 __export(subAgentMessageHandler_exports, {
@@ -509781,6 +509997,7 @@ var init_subAgentMessageHandler = __esm({
     "use strict";
     init_messageFormatter();
     init_toolDisplayConfig();
+    init_diffPreview();
     _teammateStreamMap = /* @__PURE__ */ new Map();
     _teammateStreamListeners = /* @__PURE__ */ new Set();
     _teammateStreamSnapshot = [];
@@ -510369,6 +510586,7 @@ var init_subAgentMessageHandler = __esm({
           } catch {
             toolArgs = {};
           }
+          const enrichedArgs = enrichPendingEditArgs(toolCall.function.name, toolArgs);
           let paramDisplay = "";
           if (toolCall.function.name === "terminal-execute" && toolArgs.command) {
             paramDisplay = ` "${toolArgs.command}"`;
@@ -510380,7 +510598,7 @@ var init_subAgentMessageHandler = __esm({
             role: "subagent",
             content: `\x1B[38;2;184;122;206m\u2687\u26A1 ${toolDisplay.toolName}${paramDisplay}\x1B[0m`,
             streaming: false,
-            toolCall: { name: toolCall.function.name, arguments: toolArgs },
+            toolCall: { name: toolCall.function.name, arguments: enrichedArgs },
             toolCallId: toolCall.id,
             toolPending: true,
             messageStatus: "pending",
@@ -510621,7 +510839,7 @@ var init_subAgentMessageHandler = __esm({
 });
 
 // dist/utils/team/teamSnapshot.js
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as path44 from "path";
 import * as os23 from "os";
 function getTeamSnapshotDir() {
@@ -510633,16 +510851,16 @@ function getTeamSnapshotFilePath() {
 }
 function ensureDir5() {
   const dir = getTeamSnapshotDir();
-  if (!fs38.existsSync(dir)) {
-    fs38.mkdirSync(dir, { recursive: true });
+  if (!fs39.existsSync(dir)) {
+    fs39.mkdirSync(dir, { recursive: true });
   }
 }
 function readSnapshotData() {
   const filePath = getTeamSnapshotFilePath();
-  if (!fs38.existsSync(filePath))
+  if (!fs39.existsSync(filePath))
     return {};
   try {
-    return JSON.parse(fs38.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs39.readFileSync(filePath, "utf-8"));
   } catch {
     return {};
   }
@@ -510650,7 +510868,7 @@ function readSnapshotData() {
 function saveSnapshotData(data) {
   ensureDir5();
   try {
-    fs38.writeFileSync(getTeamSnapshotFilePath(), JSON.stringify(data, null, 2), "utf-8");
+    fs39.writeFileSync(getTeamSnapshotFilePath(), JSON.stringify(data, null, 2), "utf-8");
   } catch (error42) {
     console.error("Failed to save team snapshot data:", error42);
   }
@@ -519217,7 +519435,7 @@ var require_node17 = __commonJS({
 
 // dist/mcp/lsp/LSPClient.js
 import { spawn as spawn9 } from "child_process";
-import { promises as fs39 } from "fs";
+import { promises as fs40 } from "fs";
 import * as path45 from "path";
 var import_node, LSPClient;
 var init_LSPClient = __esm({
@@ -519323,7 +519541,7 @@ var init_LSPClient = __esm({
           return rootPath;
         }
         try {
-          const entries = await fs39.readdir(rootPath, { withFileTypes: true });
+          const entries = await fs40.readdir(rootPath, { withFileTypes: true });
           const solutions = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".sln")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
           if (solutions.length === 0)
             return null;
@@ -519905,7 +520123,7 @@ var init_LSPServerRegistry = __esm({
 });
 
 // dist/mcp/lsp/LSPManager.js
-import { promises as fs40 } from "fs";
+import { promises as fs41 } from "fs";
 import * as path46 from "path";
 var LSPManager;
 var init_LSPManager = __esm({
@@ -520112,7 +520330,7 @@ var init_LSPManager = __esm({
           return this.documentCache.get(fullPath);
         }
         try {
-          const content = await fs40.readFile(fullPath, "utf-8");
+          const content = await fs41.readFile(fullPath, "utf-8");
           this.documentCache.set(fullPath, content);
           return content;
         } catch (error42) {
@@ -522205,7 +522423,7 @@ __export(roleSubagent_exports, {
   listRoleSubagents: () => listRoleSubagents,
   loadSubAgentCustomRole: () => loadSubAgentCustomRole
 });
-import fs41 from "fs/promises";
+import fs42 from "fs/promises";
 import path49 from "path";
 import { homedir as homedir15 } from "os";
 import { existsSync as existsSync27, readdirSync as readdirSync5, readFileSync as readFileSync22 } from "fs";
@@ -522240,8 +522458,8 @@ async function createRoleSubagentFile(agentName, location, projectRoot) {
       };
     }
     const dir = path49.dirname(filePath);
-    await fs41.mkdir(dir, { recursive: true });
-    await fs41.writeFile(filePath, "", "utf-8");
+    await fs42.mkdir(dir, { recursive: true });
+    await fs42.writeFile(filePath, "", "utf-8");
     return { success: true, path: filePath };
   } catch (error42) {
     return {
@@ -522261,7 +522479,7 @@ async function deleteRoleSubagentFile(agentName, location, projectRoot) {
         error: `Role file for "${agentName}" does not exist at this location`
       };
     }
-    await fs41.unlink(filePath);
+    await fs42.unlink(filePath);
     return { success: true, path: filePath };
   } catch (error42) {
     return {
@@ -527153,7 +527371,7 @@ var init_stateManager = __esm({
 });
 
 // dist/utils/connection/instanceLock.js
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path50 from "path";
 var InstanceLockManager;
 var init_instanceLock = __esm({
@@ -527171,8 +527389,8 @@ var init_instanceLock = __esm({
       }
       // Ensure .snow/locks directory exists
       ensureLocksDir() {
-        if (!fs42.existsSync(this.locksDir)) {
-          fs42.mkdirSync(this.locksDir, { recursive: true });
+        if (!fs43.existsSync(this.locksDir)) {
+          fs43.mkdirSync(this.locksDir, { recursive: true });
         }
       }
       // Get instance lock file path
@@ -527183,16 +527401,16 @@ var init_instanceLock = __esm({
       isLocked(instanceId) {
         try {
           const lockPath = this.getLockPath(instanceId);
-          if (!fs42.existsSync(lockPath)) {
+          if (!fs43.existsSync(lockPath)) {
             return false;
           }
-          const lockContent = fs42.readFileSync(lockPath, "utf-8");
+          const lockContent = fs43.readFileSync(lockPath, "utf-8");
           const lockData = JSON.parse(lockContent);
           try {
             process.kill(lockData.pid, 0);
             return true;
           } catch {
-            fs42.unlinkSync(lockPath);
+            fs43.unlinkSync(lockPath);
             return false;
           }
         } catch {
@@ -527211,7 +527429,7 @@ var init_instanceLock = __esm({
             pid: process.pid,
             timestamp: Date.now()
           };
-          fs42.writeFileSync(lockPath, JSON.stringify(lockData), "utf-8");
+          fs43.writeFileSync(lockPath, JSON.stringify(lockData), "utf-8");
           return true;
         } catch {
           return false;
@@ -527221,8 +527439,8 @@ var init_instanceLock = __esm({
       unlock(instanceId) {
         try {
           const lockPath = this.getLockPath(instanceId);
-          if (fs42.existsSync(lockPath)) {
-            fs42.unlinkSync(lockPath);
+          if (fs43.existsSync(lockPath)) {
+            fs43.unlinkSync(lockPath);
           }
         } catch {
         }
@@ -527533,7 +527751,7 @@ var init_interactionManager = __esm({
 });
 
 // dist/utils/connection/projectData.js
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import * as path51 from "path";
 var ProjectDataManager;
 var init_projectData = __esm({
@@ -527561,7 +527779,7 @@ var init_projectData = __esm({
           if (result2.length >= maxFiles) {
             return;
           }
-          const entries = await fs43.promises.readdir(dir, { withFileTypes: true });
+          const entries = await fs44.promises.readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
             if (result2.length >= maxFiles) {
               return;
@@ -534152,7 +534370,7 @@ var init_esm6 = __esm({
 
 // dist/agents/codebaseIndexAgent.js
 import path52 from "node:path";
-import fs44 from "node:fs";
+import fs45 from "node:fs";
 import crypto5 from "node:crypto";
 var import_ignore, CodebaseIndexAgent;
 var init_codebaseIndexAgent = __esm({
@@ -534261,7 +534479,7 @@ var init_codebaseIndexAgent = __esm({
           return;
         }
         const gitignorePath = path52.join(this.projectRoot, ".gitignore");
-        if (!fs44.existsSync(gitignorePath)) {
+        if (!fs45.existsSync(gitignorePath)) {
           const { getCurrentLanguage: getCurrentLanguage2 } = await Promise.resolve().then(() => (init_languageConfig(), languageConfig_exports));
           const { translations: translations2 } = await Promise.resolve().then(() => (init_i18n(), i18n_exports));
           const currentLanguage = getCurrentLanguage2();
@@ -534559,8 +534777,8 @@ var init_codebaseIndexAgent = __esm({
        */
       loadGitignore() {
         const gitignorePath = path52.join(this.projectRoot, ".gitignore");
-        if (fs44.existsSync(gitignorePath)) {
-          const content = fs44.readFileSync(gitignorePath, "utf-8");
+        if (fs45.existsSync(gitignorePath)) {
+          const content = fs45.readFileSync(gitignorePath, "utf-8");
           this.ignoreFilter.add(content);
         }
       }
@@ -534595,7 +534813,7 @@ var init_codebaseIndexAgent = __esm({
         const scanDir = (dir) => {
           let entries;
           try {
-            entries = fs44.readdirSync(dir, { withFileTypes: true });
+            entries = fs45.readdirSync(dir, { withFileTypes: true });
           } catch (error42) {
             if (error42.code === "EPERM" || error42.code === "EACCES") {
               logger.warn(`\u8DF3\u8FC7\u65E0\u6743\u9650\u8BBF\u95EE\u7684\u76EE\u5F55: ${dir}`);
@@ -534677,7 +534895,7 @@ var init_codebaseIndexAgent = __esm({
             content = docContent.text;
             fileHash = crypto5.createHash("sha256").update(content).digest("hex");
           } else {
-            content = fs44.readFileSync(filePath, "utf-8");
+            content = fs45.readFileSync(filePath, "utf-8");
             fileHash = crypto5.createHash("sha256").update(content).digest("hex");
           }
           if (this.db.hasFileHash(fileHash)) {
@@ -536475,7 +536693,7 @@ var taskManager_exports = {};
 __export(taskManager_exports, {
   taskManager: () => taskManager
 });
-import fs45 from "fs/promises";
+import fs46 from "fs/promises";
 import path53 from "path";
 import os25 from "os";
 import { randomUUID as randomUUID8 } from "crypto";
@@ -536516,7 +536734,7 @@ var init_taskManager = __esm({
       }
       async ensureTasksDir() {
         try {
-          await fs45.mkdir(this.tasksDir, { recursive: true });
+          await fs46.mkdir(this.tasksDir, { recursive: true });
         } catch (error42) {
         }
       }
@@ -536542,12 +536760,12 @@ var init_taskManager = __esm({
       async saveTask(task) {
         await this.ensureTasksDir();
         const taskPath = this.getTaskPath(task.id);
-        await fs45.writeFile(taskPath, JSON.stringify(task, null, 2));
+        await fs46.writeFile(taskPath, JSON.stringify(task, null, 2));
       }
       async loadTask(taskId) {
         try {
           const taskPath = this.getTaskPath(taskId);
-          const data = await fs45.readFile(taskPath, "utf-8");
+          const data = await fs46.readFile(taskPath, "utf-8");
           return JSON.parse(data);
         } catch (error42) {
           return null;
@@ -536557,12 +536775,12 @@ var init_taskManager = __esm({
         await this.ensureTasksDir();
         const tasks = [];
         try {
-          const files = await fs45.readdir(this.tasksDir);
+          const files = await fs46.readdir(this.tasksDir);
           for (const file2 of files) {
             if (file2.endsWith(".json")) {
               try {
                 const taskPath = path53.join(this.tasksDir, file2);
-                const data = await fs45.readFile(taskPath, "utf-8");
+                const data = await fs46.readFile(taskPath, "utf-8");
                 const task = JSON.parse(data);
                 tasks.push({
                   id: task.id,
@@ -536597,7 +536815,7 @@ var init_taskManager = __esm({
             }
           }
           const taskPath = this.getTaskPath(taskId);
-          await fs45.unlink(taskPath);
+          await fs46.unlink(taskPath);
           return true;
         } catch (error42) {
           return false;
@@ -536893,16 +537111,16 @@ __export(fileUtils_exports, {
   getFileLineCount: () => getFileLineCount,
   parseAndValidateFileReferences: () => parseAndValidateFileReferences
 });
-import fs46 from "fs";
+import fs47 from "fs";
 import path54 from "path";
 function getFileLineCount(filePath) {
   return new Promise((resolve15) => {
     try {
-      if (!fs46.existsSync(filePath)) {
+      if (!fs47.existsSync(filePath)) {
         resolve15(0);
         return;
       }
-      const content = fs46.readFileSync(filePath, "utf-8");
+      const content = fs47.readFileSync(filePath, "utf-8");
       const lines = content.split("\n").length;
       resolve15(lines);
     } catch (error42) {
@@ -536950,7 +537168,7 @@ async function getFileInfo(filePath) {
     let actualPath = filePath;
     let exists = false;
     for (const tryPath of uniquePaths) {
-      if (fs46.existsSync(tryPath)) {
+      if (fs47.existsSync(tryPath)) {
         actualPath = tryPath;
         exists = true;
         break;
@@ -536962,7 +537180,7 @@ async function getFileInfo(filePath) {
     let lineCount = 0;
     if (exists) {
       if (isImage) {
-        const buffer = fs46.readFileSync(actualPath);
+        const buffer = fs47.readFileSync(actualPath);
         const base643 = buffer.toString("base64");
         mimeType = getMimeType(actualPath);
         imageData = `data:${mimeType};base64,${base643}`;
@@ -537253,223 +537471,36 @@ var init_sessionInitializer = __esm({
   }
 });
 
-// dist/utils/ui/diffPreview.js
-import fs47 from "fs";
-function readOriginalFile(filePath) {
-  try {
-    if (!filePath || !fs47.existsSync(filePath))
-      return null;
-    return fs47.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function computeHashlinePreview(originalContent, operations) {
-  if (!Array.isArray(operations) || operations.length === 0) {
-    return originalContent;
-  }
-  const mutableLines = originalContent.split("\n");
-  const parsed = operations.map((op2) => {
-    const startMatch = String(op2.startAnchor ?? "").match(/^(\d+):/);
-    const endMatch = String(op2.endAnchor ?? "").match(/^(\d+):/);
-    return {
-      type: op2.type,
-      content: op2.content ?? "",
-      startLine: startMatch ? parseInt(startMatch[1], 10) : 0,
-      endLine: endMatch ? parseInt(endMatch[1], 10) : 0
-    };
-  }).filter((op2) => op2.startLine > 0 && op2.endLine > 0).sort((a, b) => b.startLine - a.startLine);
-  for (const op2 of parsed) {
-    const newLines = op2.content.split("\n");
-    switch (op2.type) {
-      case "replace":
-        mutableLines.splice(op2.startLine - 1, op2.endLine - op2.startLine + 1, ...newLines);
-        break;
-      case "insert_after":
-        mutableLines.splice(op2.startLine, 0, ...newLines);
-        break;
-      case "delete":
-        mutableLines.splice(op2.startLine - 1, op2.endLine - op2.startLine + 1);
-        break;
-    }
-  }
-  return mutableLines.join("\n");
-}
-function computeReplaceEditPreview(originalContent, searchContent, replaceContent) {
-  const idx = originalContent.indexOf(searchContent);
-  if (idx !== -1) {
-    return originalContent.substring(0, idx) + replaceContent + originalContent.substring(idx + searchContent.length);
-  }
-  return originalContent;
-}
-function collectDiffPreviewEntries(toolName, toolArgs) {
-  const entries = [];
-  try {
-    const parsed = JSON.parse(toolArgs);
-    if (typeof parsed.filePath === "string" && parsed.filePath.trimStart().startsWith("[")) {
-      try {
-        parsed.filePath = JSON.parse(parsed.filePath);
-      } catch {
-      }
-    }
-    if (toolName === "filesystem-edit" && parsed.filePath) {
-      if (typeof parsed.filePath === "string") {
-        const originalContent = readOriginalFile(parsed.filePath);
-        if (originalContent !== null) {
-          const newContent = computeHashlinePreview(originalContent, parsed.operations);
-          entries.push({
-            filePath: parsed.filePath,
-            oldContent: originalContent,
-            newContent
-          });
-        }
-      } else if (Array.isArray(parsed.filePath)) {
-        for (const item of parsed.filePath) {
-          if (item && typeof item === "object" && typeof item.path === "string") {
-            const originalContent = readOriginalFile(item.path);
-            if (originalContent !== null) {
-              const newContent = computeHashlinePreview(originalContent, item.operations);
-              entries.push({
-                filePath: item.path,
-                oldContent: originalContent,
-                newContent
-              });
-            }
-          }
-        }
+// dist/utils/session/sessionConverter.js
+function findToolResultDiffData(sessionMessages, startIndex, toolCallId) {
+  for (let j = startIndex + 1; j < sessionMessages.length; j++) {
+    const nextMsg = sessionMessages[j];
+    if (!nextMsg)
+      break;
+    if (nextMsg.role === "tool" && nextMsg.tool_call_id === toolCallId) {
+      const savedEditDiffData = nextMsg.editDiffData;
+      if (savedEditDiffData && (typeof savedEditDiffData.oldContent === "string" || typeof savedEditDiffData.content === "string" || Array.isArray(savedEditDiffData.batchResults))) {
+        return savedEditDiffData;
       }
-    }
-    if (toolName === "filesystem-replaceedit" && parsed.filePath) {
-      if (typeof parsed.filePath === "string") {
-        const originalContent = readOriginalFile(parsed.filePath);
-        if (originalContent !== null) {
-          const newContent = parsed.searchContent && parsed.replaceContent !== void 0 ? computeReplaceEditPreview(originalContent, parsed.searchContent, parsed.replaceContent) : originalContent;
-          entries.push({
-            filePath: parsed.filePath,
-            oldContent: originalContent,
-            newContent
-          });
-        }
-      } else if (Array.isArray(parsed.filePath)) {
-        for (const item of parsed.filePath) {
-          if (typeof item === "string") {
-            const originalContent = readOriginalFile(item);
-            if (originalContent !== null) {
-              const newContent = parsed.searchContent && parsed.replaceContent !== void 0 ? computeReplaceEditPreview(originalContent, parsed.searchContent, parsed.replaceContent) : originalContent;
-              entries.push({
-                filePath: item,
-                oldContent: originalContent,
-                newContent
-              });
-            }
-          } else if (item && typeof item === "object" && typeof item.path === "string") {
-            const originalContent = readOriginalFile(item.path);
-            if (originalContent !== null) {
-              const search = item.searchContent ?? parsed.searchContent;
-              const replace = item.replaceContent ?? parsed.replaceContent;
-              const newContent = search && replace !== void 0 ? computeReplaceEditPreview(originalContent, search, replace) : originalContent;
-              entries.push({
-                filePath: item.path,
-                oldContent: originalContent,
-                newContent
-              });
-            }
-          }
-        }
+      const toolName = findToolNameForToolCall(sessionMessages, startIndex, toolCallId);
+      if (toolName) {
+        return extractFilesystemEditDiffDataForPersistence(toolName, nextMsg.content);
       }
+      return void 0;
     }
-    if (toolName === "filesystem-create" && parsed.filePath) {
-      if (typeof parsed.filePath === "string" && parsed.content) {
-        const originalContent = readOriginalFile(parsed.filePath) ?? "";
-        entries.push({
-          filePath: parsed.filePath,
-          oldContent: originalContent,
-          newContent: parsed.content
-        });
-      } else if (Array.isArray(parsed.filePath)) {
-        for (const item of parsed.filePath) {
-          if (item && typeof item === "object" && typeof item.path === "string" && typeof item.content === "string") {
-            const originalContent = readOriginalFile(item.path) ?? "";
-            entries.push({
-              filePath: item.path,
-              oldContent: originalContent,
-              newContent: item.content
-            });
-          }
-        }
-      }
+    if (nextMsg.role === "assistant" && !nextMsg.subAgentInternal) {
+      break;
     }
-  } catch {
   }
-  return entries;
+  return void 0;
 }
-function enrichPendingEditArgs(toolName, toolArgs) {
-  if (toolName !== "filesystem-edit" && toolName !== "filesystem-replaceedit" && toolName !== "filesystem-create") {
-    return toolArgs;
-  }
-  const rawFilePath = toolArgs["filePath"];
-  if (typeof rawFilePath === "string" && rawFilePath.trimStart().startsWith("[")) {
-    try {
-      toolArgs = { ...toolArgs, filePath: JSON.parse(rawFilePath) };
-    } catch {
-    }
-  }
-  const isBatch = toolArgs["isBatch"] || Array.isArray(toolArgs["filePath"]);
-  if (!isBatch) {
-    const entries2 = collectDiffPreviewEntries(toolName, JSON.stringify(toolArgs));
-    if (entries2.length === 1) {
-      const entry = entries2[0];
-      if (toolName === "filesystem-create") {
-        return {
-          ...toolArgs,
-          content: entry.newContent,
-          path: entry.filePath
-        };
-      }
-      return {
-        ...toolArgs,
-        oldContent: entry.oldContent,
-        newContent: entry.newContent,
-        filename: entry.filePath
-      };
-    }
-    return toolArgs;
-  }
-  const entries = collectDiffPreviewEntries(toolName, JSON.stringify(toolArgs));
-  if (entries.length === 0) {
-    return toolArgs;
-  }
-  if (toolName === "filesystem-create") {
-    const batchResults2 = entries.map((entry) => ({
-      success: true,
-      path: entry.filePath,
-      content: entry.newContent
-    }));
-    return {
-      ...toolArgs,
-      isBatch: true,
-      batchResults: batchResults2
-    };
-  }
-  const batchResults = entries.map((entry) => ({
-    success: true,
-    path: entry.filePath,
-    oldContent: entry.oldContent,
-    newContent: entry.newContent
-  }));
-  return {
-    ...toolArgs,
-    isBatch: true,
-    batchResults
-  };
+function findToolNameForToolCall(sessionMessages, assistantIndex, toolCallId) {
+  const msg = sessionMessages[assistantIndex];
+  if (!msg || !msg.tool_calls)
+    return void 0;
+  const tc = msg.tool_calls.find((t) => t.id === toolCallId);
+  return tc == null ? void 0 : tc.function.name;
 }
-var init_diffPreview = __esm({
-  "dist/utils/ui/diffPreview.js"() {
-    "use strict";
-  }
-});
-
-// dist/utils/session/sessionConverter.js
 function cleanThinkingContent3(content) {
   return content.replace(/\s*<\/?think(?:ing)?>\s*/gi, "").trim();
 }
@@ -537538,13 +537569,15 @@ function convertSessionMessagesToUI(sessionMessages) {
           const params = toolDisplay.args.map((arg) => `${arg.key}: ${arg.value}`).join(", ");
           paramDisplay = ` (${params})`;
         }
+        const subAgentSavedDiffData = findToolResultDiffData(sessionMessages, i, toolCall.id);
+        const subAgentEnrichedArgs = subAgentSavedDiffData ? { ...toolArgs, ...subAgentSavedDiffData } : enrichPendingEditArgs(toolCall.function.name, toolArgs);
         uiMessages.push({
           role: "subagent",
           content: `\x1B[38;2;184;122;206m\u2687\u26A1 ${toolDisplay.toolName}${paramDisplay}\x1B[0m`,
           streaming: false,
           toolCall: {
             name: toolCall.function.name,
-            arguments: enrichPendingEditArgs(toolCall.function.name, toolArgs)
+            arguments: subAgentEnrichedArgs
           },
           toolCallId: toolCall.id,
           toolPending: false,
@@ -537712,7 +537745,8 @@ function convertSessionMessagesToUI(sessionMessages) {
         }
         const needTwoSteps = isToolNeedTwoStepDisplay(toolCall.function.name);
         if (needTwoSteps) {
-          const enrichedArgs = enrichPendingEditArgs(toolCall.function.name, toolArgs);
+          const savedDiffData = findToolResultDiffData(sessionMessages, i, toolCall.id);
+          const enrichedArgs = savedDiffData ? { ...toolArgs, ...savedDiffData } : enrichPendingEditArgs(toolCall.function.name, toolArgs);
           uiMessages.push({
             role: "assistant",
             content: `\u26A1 ${toolDisplay.toolName}`,
@@ -560131,6 +560165,10 @@ function useConfigInput(state, callbacks) {
     setRetryDelayMs,
     thinkingBudgetTokens,
     setThinkingBudgetTokens,
+    setThinkingEffort,
+    setGeminiThinkingLevel,
+    setResponsesReasoningEffort,
+    setChatReasoningEffort,
     autoCompressThreshold,
     setAutoCompressThreshold,
     setAdvancedModel,
@@ -560241,6 +560279,14 @@ function useConfigInput(state, callbacks) {
             setBasicModel(cleaned);
           } else if (currentField === "visionModel") {
             setVisionModel(cleaned);
+          } else if (currentField === "thinkingEffort") {
+            setThinkingEffort(cleaned);
+          } else if (currentField === "geminiThinkingLevel") {
+            setGeminiThinkingLevel(cleaned);
+          } else if (currentField === "responsesReasoningEffort") {
+            setResponsesReasoningEffort(cleaned);
+          } else if (currentField === "chatReasoningEffort") {
+            setChatReasoningEffort(cleaned);
           }
         }
         setManualInputMode(false);
@@ -561913,20 +561959,40 @@ function ConfigSelectPanel({ state }) {
         setIsEditing(false);
       } }),
       currentField === "thinkingEffort" && import_react73.default.createElement(ScrollableSelectInput, { items: [
+        {
+          label: t.configScreen.manualInputOption,
+          value: "__MANUAL_INPUT__"
+        },
         { label: "low", value: "low" },
         { label: "medium", value: "medium" },
         { label: "high", value: "high" },
         { label: "max", value: "max" }
-      ], initialIndex: thinkingEffort === "low" ? 0 : thinkingEffort === "medium" ? 1 : thinkingEffort === "high" ? 2 : 3, isFocused: true, onSelect: (item) => {
+      ], initialIndex: Math.max(0, ["__MANUAL_INPUT__", "low", "medium", "high", "max"].indexOf(thinkingEffort)), isFocused: true, onSelect: (item) => {
+        if (item.value === "__MANUAL_INPUT__") {
+          setIsEditing(false);
+          state.setManualInputMode(true);
+          state.setManualInputValue(thinkingEffort);
+          return;
+        }
         setThinkingEffort(item.value);
         setIsEditing(false);
       } }),
       currentField === "geminiThinkingLevel" && import_react73.default.createElement(ScrollableSelectInput, { items: [
+        {
+          label: t.configScreen.manualInputOption,
+          value: "__MANUAL_INPUT__"
+        },
         { label: "MINIMAL", value: "minimal" },
         { label: "LOW", value: "low" },
         { label: "MEDIUM", value: "medium" },
         { label: "HIGH", value: "high" }
-      ], initialIndex: Math.max(0, ["minimal", "low", "medium", "high"].indexOf(geminiThinkingLevel)), isFocused: true, onSelect: (item) => {
+      ], initialIndex: Math.max(0, ["__MANUAL_INPUT__", "minimal", "low", "medium", "high"].indexOf(geminiThinkingLevel)), isFocused: true, onSelect: (item) => {
+        if (item.value === "__MANUAL_INPUT__") {
+          setIsEditing(false);
+          state.setManualInputMode(true);
+          state.setManualInputValue(geminiThinkingLevel);
+          return;
+        }
         setGeminiThinkingLevel(item.value);
         setIsEditing(false);
       } }),
@@ -561944,11 +562010,21 @@ function ConfigSelectPanel({ state }) {
         setIsEditing(false);
       } }),
       currentField === "chatReasoningEffort" && import_react73.default.createElement(ScrollableSelectInput, { items: [
+        {
+          label: t.configScreen.manualInputOption,
+          value: "__MANUAL_INPUT__"
+        },
         { label: "LOW", value: "low" },
         { label: "MEDIUM", value: "medium" },
         { label: "HIGH", value: "high" },
         { label: "MAX", value: "max" }
-      ], initialIndex: Math.max(0, ["low", "medium", "high", "max"].indexOf(chatReasoningEffort)), isFocused: true, onSelect: (item) => {
+      ], initialIndex: Math.max(0, ["__MANUAL_INPUT__", "low", "medium", "high", "max"].indexOf(chatReasoningEffort)), isFocused: true, onSelect: (item) => {
+        if (item.value === "__MANUAL_INPUT__") {
+          setIsEditing(false);
+          state.setManualInputMode(true);
+          state.setManualInputValue(chatReasoningEffort);
+          return;
+        }
         setChatReasoningEffort(item.value);
         setIsEditing(false);
       } }),
@@ -562137,8 +562213,9 @@ function ModelSelect({ state }) {
   );
 }
 function ReasoningEffortSelect({ state }) {
-  const { supportsXHigh, responsesReasoningEffort, setResponsesReasoningEffort, setIsEditing } = state;
+  const { t, supportsXHigh, responsesReasoningEffort, setResponsesReasoningEffort, setIsEditing } = state;
   const effortOptions = [
+    { label: t.configScreen.manualInputOption, value: "__MANUAL_INPUT__" },
     { label: "NONE", value: "none" },
     { label: "LOW", value: "low" },
     { label: "MEDIUM", value: "medium" },
@@ -562146,8 +562223,13 @@ function ReasoningEffortSelect({ state }) {
     ...supportsXHigh ? [{ label: "XHIGH", value: "xhigh" }] : []
   ];
   return import_react73.default.createElement(ScrollableSelectInput, { items: effortOptions, initialIndex: Math.max(0, effortOptions.findIndex((opt) => opt.value === responsesReasoningEffort)), isFocused: true, onSelect: (item) => {
-    const nextEffort = item.value;
-    setResponsesReasoningEffort(nextEffort === "xhigh" && !supportsXHigh ? "high" : nextEffort);
+    if (item.value === "__MANUAL_INPUT__") {
+      setIsEditing(false);
+      state.setManualInputMode(true);
+      state.setManualInputValue(responsesReasoningEffort);
+      return;
+    }
+    setResponsesReasoningEffort(item.value);
     setIsEditing(false);
   } });
 }
@@ -562320,7 +562402,11 @@ function ManualInputView({ state, inlineMode }) {
         { color: theme14.colors.menuInfo },
         currentField === "advancedModel" && t.configScreen.advancedModel,
         currentField === "basicModel" && t.configScreen.basicModel,
-        currentField === "visionModel" && t.configScreen.visionModel
+        currentField === "visionModel" && t.configScreen.visionModel,
+        currentField === "thinkingEffort" && t.configScreen.thinkingEffort,
+        currentField === "geminiThinkingLevel" && t.configScreen.geminiThinkingLevel,
+        currentField === "responsesReasoningEffort" && t.configScreen.responsesReasoningEffort,
+        currentField === "chatReasoningEffort" && t.configScreen.chatReasoningEffort
       ),
       import_react74.default.createElement(
         Box_default,
@@ -675602,12 +675688,37 @@ var init_ModelsPanel = __esm({
           return;
         }
         if (thinkingInputMode) {
-          if (key.return) {
-            const parsed = Number.parseInt(thinkingInputValue.trim(), 10);
-            if (!Number.isNaN(parsed) && parsed >= 0) {
-              if (thinkingInputMode === "anthropicBudgetTokens") {
+          if (thinkingInputMode === "anthropicBudgetTokens") {
+            if (key.return) {
+              const parsed = Number.parseInt(thinkingInputValue.trim(), 10);
+              if (!Number.isNaN(parsed) && parsed >= 0) {
                 void applyAnthropicBudgetTokens(parsed);
               }
+              setThinkingInputMode(null);
+              setThinkingInputValue("");
+              return;
+            }
+            if (key.backspace || key.delete) {
+              setThinkingInputValue((prev) => prev.slice(0, -1));
+              return;
+            }
+            if (input2 && /[0-9]/.test(input2)) {
+              setThinkingInputValue((prev) => prev + input2);
+            }
+            return;
+          }
+          if (key.return) {
+            const cleaned = thinkingInputValue.trim();
+            if (cleaned) {
+              if (thinkingInputMode === "thinkingEffort") {
+                void applyThinkingEffort(cleaned);
+              } else if (thinkingInputMode === "geminiThinkingLevel") {
+                void applyGeminiLevel(cleaned);
+              } else if (thinkingInputMode === "responsesReasoningEffort") {
+                void applyResponsesEffort(cleaned);
+              } else if (thinkingInputMode === "chatReasoningEffort") {
+                void applyChatReasoningEffort(cleaned);
+              }
             }
             setThinkingInputMode(null);
             setThinkingInputValue("");
@@ -675617,7 +675728,7 @@ var init_ModelsPanel = __esm({
             setThinkingInputValue((prev) => prev.slice(0, -1));
             return;
           }
-          if (input2 && /[0-9]/.test(input2)) {
+          if (input2 && /[a-zA-Z0-9_-]/.test(input2)) {
             setThinkingInputValue((prev) => prev + input2);
           }
           return;
@@ -675881,7 +675992,7 @@ var init_ModelsPanel = __esm({
           thinkingInputMode && import_react187.default.createElement(
             Box_default,
             { flexDirection: "column", marginTop: 1 },
-            import_react187.default.createElement(Text, { color: theme14.colors.menuInfo }, t.modelsPanel.inputNumberHint),
+            import_react187.default.createElement(Text, { color: theme14.colors.menuInfo }, thinkingInputMode === "anthropicBudgetTokens" ? t.modelsPanel.inputNumberHint : t.modelsPanel.manualInputHint),
             import_react187.default.createElement(
               Box_default,
               { marginLeft: 1 },
@@ -675916,11 +676027,19 @@ var init_ModelsPanel = __esm({
             Box_default,
             { marginTop: 1 },
             import_react187.default.createElement(ScrollableSelectInput, { items: (requestMethod === "anthropic" ? [
+              {
+                label: t.modelsPanel.manualInputOption,
+                value: "__MANUAL_INPUT__"
+              },
               { label: "low", value: "low" },
               { label: "medium", value: "medium" },
               { label: "high", value: "high" },
               { label: "max", value: "max" }
             ] : [
+              {
+                label: t.modelsPanel.manualInputOption,
+                value: "__MANUAL_INPUT__"
+              },
               { label: "none", value: "none" },
               { label: "low", value: "low" },
               { label: "medium", value: "medium" },
@@ -675930,6 +676049,18 @@ var init_ModelsPanel = __esm({
               label: i.label,
               value: i.value
             })), limit: 6, disableNumberShortcuts: true, initialIndex: Math.max(0, requestMethod === "anthropic" ? ["low", "medium", "high", "max"].indexOf(thinkingEffort) : ["none", "low", "medium", "high", "xhigh"].indexOf(responsesReasoningEffort)), isFocused: true, onSelect: (item) => {
+              if (item.value === "__MANUAL_INPUT__") {
+                if (requestMethod === "anthropic") {
+                  setIsThinkingEffortSelecting(false);
+                  setThinkingInputMode("thinkingEffort");
+                  setThinkingInputValue(thinkingEffort);
+                } else {
+                  setIsThinkingEffortSelecting(false);
+                  setThinkingInputMode("responsesReasoningEffort");
+                  setThinkingInputValue(responsesReasoningEffort);
+                }
+                return;
+              }
               if (requestMethod === "anthropic") {
                 void applyThinkingEffort(item.value);
               } else {
@@ -675954,11 +676085,21 @@ var init_ModelsPanel = __esm({
             Box_default,
             { marginTop: 1 },
             import_react187.default.createElement(ScrollableSelectInput, { items: [
+              {
+                label: t.modelsPanel.manualInputOption,
+                value: "__MANUAL_INPUT__"
+              },
               { label: "MINIMAL", value: "minimal" },
               { label: "LOW", value: "low" },
               { label: "MEDIUM", value: "medium" },
               { label: "HIGH", value: "high" }
             ], limit: 6, disableNumberShortcuts: true, initialIndex: Math.max(0, ["minimal", "low", "medium", "high"].indexOf(geminiThinkingLevel)), isFocused: true, onSelect: (item) => {
+              if (item.value === "__MANUAL_INPUT__") {
+                setIsGeminiLevelSelecting(false);
+                setThinkingInputMode("geminiThinkingLevel");
+                setThinkingInputValue(geminiThinkingLevel);
+                return;
+              }
               void applyGeminiLevel(item.value);
               setIsGeminiLevelSelecting(false);
             } })
@@ -675985,11 +676126,21 @@ var init_ModelsPanel = __esm({
             Box_default,
             { marginTop: 1 },
             import_react187.default.createElement(ScrollableSelectInput, { items: [
+              {
+                label: t.modelsPanel.manualInputOption,
+                value: "__MANUAL_INPUT__"
+              },
               { label: "LOW", value: "low" },
               { label: "MEDIUM", value: "medium" },
               { label: "HIGH", value: "high" },
               { label: "MAX", value: "max" }
             ], limit: 6, disableNumberShortcuts: true, initialIndex: Math.max(0, ["low", "medium", "high", "max"].indexOf(chatReasoningEffort)), isFocused: true, onSelect: (item) => {
+              if (item.value === "__MANUAL_INPUT__") {
+                setIsChatEffortSelecting(false);
+                setThinkingInputMode("chatReasoningEffort");
+                setThinkingInputValue(chatReasoningEffort);
+                return;
+              }
               void applyChatReasoningEffort(item.value);
               setIsChatEffortSelecting(false);
             } })
@@ -693541,7 +693692,7 @@ var require_package4 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "snow-ai",
-      version: "0.8.12",
+      version: "0.8.13",
       description: "Agentic coding in your terminal",
       license: "MIT",
       bin: {

package/bundle/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.8.12",
+	"version": "0.8.13",
 	"description": "Agentic coding in your terminal",
 	"license": "MIT",
 	"bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.8.12",
+	"version": "0.8.13",
 	"description": "Agentic coding in your terminal",
 	"license": "MIT",
 	"bin": {