@xagent/x-cli 1.2.13 → 1.2.14

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import OpenAI from 'openai';
-import * as fs9 from 'fs';
-import fs9__default, { existsSync, promises } from 'fs';
+import * as fs10 from 'fs';
+import fs10__default, { existsSync, promises } from 'fs';
 import * as path8 from 'path';
 import path8__default from 'path';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -13,8 +13,8 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { exec, execSync, spawn } from 'child_process';
 import { promisify } from 'util';
 import { createTwoFilesPatch } from 'diff';
-import * as fs6 from 'fs/promises';
-import fs6__default, { writeFile } from 'fs/promises';
+import * as fs7 from 'fs/promises';
+import fs7__default, { writeFile } from 'fs/promises';
 import * as ops6 from 'fs-extra';
 import { parse } from '@typescript-eslint/typescript-estree';
 import Fuse from 'fuse.js';
@@ -170,11 +170,11 @@ var init_client = __esm({
           };
           const logPath = process.env.XCLI_TOKEN_LOG || `${process.env.HOME}/.grok/token-usage.jsonl`;
           const dir = path8__default.dirname(logPath);
-          if (!fs9__default.existsSync(dir)) {
-            fs9__default.mkdirSync(dir, { recursive: true });
+          if (!fs10__default.existsSync(dir)) {
+            fs10__default.mkdirSync(dir, { recursive: true });
           }
           const logLine = JSON.stringify(tokenData) + "\n";
-          fs9__default.appendFileSync(logPath, logLine);
+          fs10__default.appendFileSync(logPath, logLine);
         } catch (error) {
           console.warn("Failed to log token usage:", error);
         }
@@ -435,8 +435,8 @@ var init_settings_manager = __esm({
        */
       ensureDirectoryExists(filePath) {
         const dir = path8.dirname(filePath);
-        if (!fs9.existsSync(dir)) {
-          fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+        if (!fs10.existsSync(dir)) {
+          fs10.mkdirSync(dir, { recursive: true, mode: 448 });
         }
       }
       /**
@@ -444,11 +444,11 @@ var init_settings_manager = __esm({
        */
       loadUserSettings() {
         try {
-          if (!fs9.existsSync(this.userSettingsPath)) {
+          if (!fs10.existsSync(this.userSettingsPath)) {
             this.saveUserSettings(DEFAULT_USER_SETTINGS);
             return { ...DEFAULT_USER_SETTINGS };
           }
-          const content = fs9.readFileSync(this.userSettingsPath, "utf-8");
+          const content = fs10.readFileSync(this.userSettingsPath, "utf-8");
           const settings = JSON.parse(content);
           return { ...DEFAULT_USER_SETTINGS, ...settings };
         } catch (error) {
@@ -466,9 +466,9 @@ var init_settings_manager = __esm({
         try {
           this.ensureDirectoryExists(this.userSettingsPath);
           let existingSettings = { ...DEFAULT_USER_SETTINGS };
-          if (fs9.existsSync(this.userSettingsPath)) {
+          if (fs10.existsSync(this.userSettingsPath)) {
             try {
-              const content = fs9.readFileSync(this.userSettingsPath, "utf-8");
+              const content = fs10.readFileSync(this.userSettingsPath, "utf-8");
               const parsed = JSON.parse(content);
               existingSettings = { ...DEFAULT_USER_SETTINGS, ...parsed };
             } catch (_error) {
@@ -476,7 +476,7 @@ var init_settings_manager = __esm({
             }
           }
           const mergedSettings = { ...existingSettings, ...settings };
-          fs9.writeFileSync(
+          fs10.writeFileSync(
             this.userSettingsPath,
             JSON.stringify(mergedSettings, null, 2),
             { mode: 384 }
@@ -509,11 +509,11 @@ var init_settings_manager = __esm({
        */
       loadProjectSettings() {
         try {
-          if (!fs9.existsSync(this.projectSettingsPath)) {
+          if (!fs10.existsSync(this.projectSettingsPath)) {
             this.saveProjectSettings(DEFAULT_PROJECT_SETTINGS);
             return { ...DEFAULT_PROJECT_SETTINGS };
           }
-          const content = fs9.readFileSync(this.projectSettingsPath, "utf-8");
+          const content = fs10.readFileSync(this.projectSettingsPath, "utf-8");
           const settings = JSON.parse(content);
           return { ...DEFAULT_PROJECT_SETTINGS, ...settings };
         } catch (error) {
@@ -531,9 +531,9 @@ var init_settings_manager = __esm({
         try {
           this.ensureDirectoryExists(this.projectSettingsPath);
           let existingSettings = { ...DEFAULT_PROJECT_SETTINGS };
-          if (fs9.existsSync(this.projectSettingsPath)) {
+          if (fs10.existsSync(this.projectSettingsPath)) {
             try {
-              const content = fs9.readFileSync(this.projectSettingsPath, "utf-8");
+              const content = fs10.readFileSync(this.projectSettingsPath, "utf-8");
               const parsed = JSON.parse(content);
               existingSettings = { ...DEFAULT_PROJECT_SETTINGS, ...parsed };
             } catch (_error) {
@@ -541,7 +541,7 @@ var init_settings_manager = __esm({
             }
           }
           const mergedSettings = { ...existingSettings, ...settings };
-          fs9.writeFileSync(
+          fs10.writeFileSync(
             this.projectSettingsPath,
             JSON.stringify(mergedSettings, null, 2)
           );
@@ -1926,12 +1926,12 @@ ${data ? JSON.stringify(data, null, 2) : "No additional data"}
 `;
     const workingDir = process.cwd();
     const logsDir = path8.join(workingDir, "logs");
-    const fs21 = fs9;
-    if (fs21.existsSync(logsDir)) {
-      const sessionFiles = fs21.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
+    const fs22 = fs10;
+    if (fs22.existsSync(logsDir)) {
+      const sessionFiles = fs22.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
       if (sessionFiles.length > 0) {
         const sessionFile = path8.join(logsDir, sessionFiles[sessionFiles.length - 1]);
-        fs21.appendFileSync(sessionFile, logEntry);
+        fs22.appendFileSync(sessionFile, logEntry);
       }
     }
   } catch (error) {
@@ -1944,7 +1944,7 @@ var init_text_editor = __esm({
     init_confirmation_service();
     pathExists = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -1959,16 +1959,16 @@ var init_text_editor = __esm({
         try {
           const resolvedPath = path8.resolve(filePath);
           if (await pathExists(resolvedPath)) {
-            const stats = await fs9.promises.stat(resolvedPath);
+            const stats = await fs10.promises.stat(resolvedPath);
             if (stats.isDirectory()) {
-              const files = await fs9.promises.readdir(resolvedPath);
+              const files = await fs10.promises.readdir(resolvedPath);
               return {
                 success: true,
                 output: `Directory contents of ${filePath}:
 ${files.join("\n")}`
               };
             }
-            const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+            const content = await fs10.promises.readFile(resolvedPath, "utf-8");
             const lines = content.split("\n");
             if (viewRange) {
               const [start, end] = viewRange;
@@ -2018,7 +2018,7 @@ ${numberedLines}${additionalLinesMessage}`
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           if (!content.includes(oldStr)) {
             if (oldStr.includes("\n")) {
               const fuzzyResult = this.findFuzzyMatch(content, oldStr);
@@ -2118,7 +2118,7 @@ ${numberedLines}${additionalLinesMessage}`
             }
           }
           const dir = path8.dirname(resolvedPath);
-          await fs9.promises.mkdir(dir, { recursive: true });
+          await fs10.promises.mkdir(dir, { recursive: true });
           await writeFile(resolvedPath, content, "utf-8");
           this.editHistory.push({
             command: "create",
@@ -2148,7 +2148,7 @@ ${numberedLines}${additionalLinesMessage}`
               error: `File not found: ${filePath}`
             };
           }
-          const fileContent = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const fileContent = await fs10.promises.readFile(resolvedPath, "utf-8");
           const lines = fileContent.split("\n");
           if (startLine < 1 || startLine > lines.length) {
             return {
@@ -2216,7 +2216,7 @@ ${numberedLines}${additionalLinesMessage}`
               error: `File not found: ${filePath}`
             };
           }
-          const fileContent = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const fileContent = await fs10.promises.readFile(resolvedPath, "utf-8");
           const lines = fileContent.split("\n");
           lines.splice(insertLine - 1, 0, content);
           const newContent = lines.join("\n");
@@ -2250,7 +2250,7 @@ ${numberedLines}${additionalLinesMessage}`
           switch (lastEdit.command) {
             case "str_replace":
               if (lastEdit.path && lastEdit.old_str && lastEdit.new_str) {
-                const content = await fs9.promises.readFile(lastEdit.path, "utf-8");
+                const content = await fs10.promises.readFile(lastEdit.path, "utf-8");
                 const revertedContent = content.replace(
                   lastEdit.new_str,
                   lastEdit.old_str
@@ -2260,12 +2260,12 @@ ${numberedLines}${additionalLinesMessage}`
               break;
             case "create":
               if (lastEdit.path) {
-                await fs9.promises.rm(lastEdit.path);
+                await fs10.promises.rm(lastEdit.path);
               }
               break;
             case "insert":
               if (lastEdit.path && lastEdit.insert_line) {
-                const content = await fs9.promises.readFile(lastEdit.path, "utf-8");
+                const content = await fs10.promises.readFile(lastEdit.path, "utf-8");
                 const lines = content.split("\n");
                 lines.splice(lastEdit.insert_line - 1, 1);
                 await writeFile(lastEdit.path, lines.join("\n"), "utf-8");
@@ -2593,13 +2593,17 @@ ${numberedLines}${additionalLinesMessage}`
     };
   }
 });
+var init_smart_edit = __esm({
+  "src/tools/smart-edit.ts"() {
+  }
+});
 var pathExists2, MorphEditorTool;
 var init_morph_editor = __esm({
   "src/tools/morph-editor.ts"() {
     init_confirmation_service();
     pathExists2 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -2652,7 +2656,7 @@ var init_morph_editor = __esm({
               error: "MORPH_API_KEY not configured. Please set your Morph API key."
             };
           }
-          const initialCode = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const initialCode = await fs10.promises.readFile(resolvedPath, "utf-8");
           const sessionFlags = this.confirmationService.getSessionFlags();
           if (!sessionFlags.fileOperations && !sessionFlags.allOperations) {
             const confirmationResult = await this.confirmationService.requestConfirmation(
@@ -2675,7 +2679,7 @@ ${codeEdit}`
             }
           }
           const mergedCode = await this.callMorphApply(instructions, initialCode, codeEdit);
-          await fs9.promises.writeFile(resolvedPath, mergedCode, "utf-8");
+          await fs10.promises.writeFile(resolvedPath, mergedCode, "utf-8");
           const oldLines = initialCode.split("\n");
           const newLines = mergedCode.split("\n");
           const diff = this.generateDiff(oldLines, newLines, targetFile);
@@ -2849,16 +2853,16 @@ ${codeEdit}`
         try {
           const resolvedPath = path8.resolve(filePath);
           if (await pathExists2(resolvedPath)) {
-            const stats = await fs9.promises.stat(resolvedPath);
+            const stats = await fs10.promises.stat(resolvedPath);
             if (stats.isDirectory()) {
-              const files = await fs9.promises.readdir(resolvedPath);
+              const files = await fs10.promises.readdir(resolvedPath);
               return {
                 success: true,
                 output: `Directory contents of ${filePath}:
 ${files.join("\n")}`
               };
             }
-            const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+            const content = await fs10.promises.readFile(resolvedPath, "utf-8");
             const lines = content.split("\n");
             if (viewRange) {
               const [start, end] = viewRange;
@@ -3286,7 +3290,7 @@ var init_search = __esm({
         const walkDir = async (dir, depth = 0) => {
           if (depth > 10 || files.length >= maxResults) return;
           try {
-            const entries = await fs9.promises.readdir(dir, { withFileTypes: true });
+            const entries = await fs10.promises.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
               if (files.length >= maxResults) break;
               const fullPath = path8.join(dir, entry.name);
@@ -3926,7 +3930,7 @@ var init_advanced_search = __esm({
     init_confirmation_service();
     pathExists4 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -3948,7 +3952,7 @@ var init_advanced_search = __esm({
               error: `Path not found: ${searchPath}`
             };
           }
-          const stats = await fs9.promises.stat(resolvedPath);
+          const stats = await fs10.promises.stat(resolvedPath);
           const filesToSearch = [];
           if (stats.isFile()) {
             filesToSearch.push(resolvedPath);
@@ -3991,7 +3995,7 @@ var init_advanced_search = __esm({
               error: `Path not found: ${searchPath}`
             };
           }
-          const stats = await fs9.promises.stat(resolvedPath);
+          const stats = await fs10.promises.stat(resolvedPath);
           const filesToProcess = [];
           if (stats.isFile()) {
             filesToProcess.push(resolvedPath);
@@ -4036,7 +4040,7 @@ var init_advanced_search = __esm({
             }
             for (const result of results) {
               if (result.success && result.preview) {
-                await fs9.promises.writeFile(result.filePath, result.preview, "utf-8");
+                await fs10.promises.writeFile(result.filePath, result.preview, "utf-8");
               }
             }
           }
@@ -4098,7 +4102,7 @@ ${matchingFiles.join("\n")}` : "No matching files found"
        * Search in a single file
        */
       async searchInFile(filePath, options) {
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         let pattern;
@@ -4149,7 +4153,7 @@ ${matchingFiles.join("\n")}` : "No matching files found"
        */
       async replaceInFile(filePath, options) {
         try {
-          const content = await fs9.promises.readFile(filePath, "utf-8");
+          const content = await fs10.promises.readFile(filePath, "utf-8");
           let pattern;
           try {
             if (options.isRegex) {
@@ -4200,7 +4204,7 @@ ${matchingFiles.join("\n")}` : "No matching files found"
       async getFilesRecursively(dirPath, options) {
         const files = [];
         const walk = async (currentPath) => {
-          const entries = await fs9.promises.readdir(currentPath, { withFileTypes: true });
+          const entries = await fs10.promises.readdir(currentPath, { withFileTypes: true });
           for (const entry of entries) {
             const fullPath = path8.join(currentPath, entry.name);
             if (entry.isDirectory()) {
@@ -4958,7 +4962,7 @@ var init_code_aware_editor = __esm({
     init_confirmation_service();
     pathExists6 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -4980,7 +4984,7 @@ var init_code_aware_editor = __esm({
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           const language = this.detectLanguage(filePath);
           const context = await this.parseCodeContext(content, language);
           const output = this.formatCodeAnalysis(context, filePath);
@@ -5007,7 +5011,7 @@ var init_code_aware_editor = __esm({
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           const language = this.detectLanguage(filePath);
           const context = await this.parseCodeContext(content, language);
           const result = await this.performRefactoring(content, context, operation, language);
@@ -5033,7 +5037,7 @@ var init_code_aware_editor = __esm({
               };
             }
           }
-          await fs9.promises.writeFile(resolvedPath, result.newContent, "utf-8");
+          await fs10.promises.writeFile(resolvedPath, result.newContent, "utf-8");
           return {
             success: true,
             output: result.output
@@ -5057,7 +5061,7 @@ var init_code_aware_editor = __esm({
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           const language = this.detectLanguage(filePath);
           const context = await this.parseCodeContext(content, language);
           const insertionPoint = this.findInsertionPoint(content, context, location, target);
@@ -5087,7 +5091,7 @@ var init_code_aware_editor = __esm({
               };
             }
           }
-          await fs9.promises.writeFile(resolvedPath, newContent, "utf-8");
+          await fs10.promises.writeFile(resolvedPath, newContent, "utf-8");
           return {
             success: true,
             output: `Code inserted at line ${insertionPoint.line + 1} in ${filePath}`
@@ -5111,7 +5115,7 @@ var init_code_aware_editor = __esm({
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           const language = this.detectLanguage(filePath);
           const formattedContent = await this.formatCodeContent(content, language, options);
           if (formattedContent === content) {
@@ -5139,7 +5143,7 @@ var init_code_aware_editor = __esm({
               };
             }
           }
-          await fs9.promises.writeFile(resolvedPath, formattedContent, "utf-8");
+          await fs10.promises.writeFile(resolvedPath, formattedContent, "utf-8");
           return {
             success: true,
             output: `Code formatted in ${filePath}`
@@ -5163,7 +5167,7 @@ var init_code_aware_editor = __esm({
               error: `File not found: ${filePath}`
             };
           }
-          const content = await fs9.promises.readFile(resolvedPath, "utf-8");
+          const content = await fs10.promises.readFile(resolvedPath, "utf-8");
           const language = this.detectLanguage(filePath);
           const context = await this.parseCodeContext(content, language);
           const missingImports = symbols.filter(
@@ -5204,7 +5208,7 @@ ${importsToAdd.join("\n")}`;
               };
             }
           }
-          await fs9.promises.writeFile(resolvedPath, newContent, "utf-8");
+          await fs10.promises.writeFile(resolvedPath, newContent, "utf-8");
           return {
             success: true,
             output: `Added ${missingImports.length} missing imports to ${filePath}`
@@ -6563,7 +6567,7 @@ var init_ast_parser = __esm({
     }
     pathExists8 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -6639,7 +6643,7 @@ var init_ast_parser = __esm({
           if (!await pathExists8(filePath)) {
             throw new Error(`File not found: ${filePath}`);
           }
-          const content = await fs9.promises.readFile(filePath, "utf-8");
+          const content = await fs10.promises.readFile(filePath, "utf-8");
           const language = this.detectLanguage(filePath);
           let result;
           if (language === "typescript" || language === "tsx") {
@@ -7333,7 +7337,7 @@ var init_symbol_search = __esm({
       async findSymbolUsages(symbolRef) {
         const usages = [];
         try {
-          const content = await fs9.promises.readFile(symbolRef.filePath, "utf-8");
+          const content = await fs10.promises.readFile(symbolRef.filePath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -7513,7 +7517,7 @@ var init_dependency_analyzer = __esm({
     init_ast_parser();
     pathExists9 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -7991,7 +7995,7 @@ var init_code_context = __esm({
     init_dependency_analyzer();
     pathExists10 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -8136,7 +8140,7 @@ var init_code_context = __esm({
       async analyzeUsagePatterns(symbol, filePath) {
         const patterns = [];
         try {
-          const content = await fs9.promises.readFile(filePath, "utf-8");
+          const content = await fs10.promises.readFile(filePath, "utf-8");
           const lines = content.split("\n");
           let callCount = 0;
           let assignmentCount = 0;
@@ -8289,7 +8293,7 @@ var init_code_context = __esm({
       }
       async analyzeSemanticContext(filePath, symbols, dependencies) {
         const fileName = path8__default.basename(filePath);
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const purpose = this.inferPurpose(fileName, symbols, content);
         const domain = this.extractDomain(filePath, symbols, dependencies);
         const patterns = this.detectDesignPatterns(content, symbols);
@@ -8418,7 +8422,7 @@ var init_code_context = __esm({
         };
       }
       async calculateCodeMetrics(filePath, symbols) {
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const codeLines = lines.filter((line) => line.trim().length > 0 && !line.trim().startsWith("//"));
         const linesOfCode = codeLines.length;
@@ -8527,7 +8531,7 @@ var init_refactoring_assistant = __esm({
     init_operation_history();
     pathExists11 = async (filePath) => {
       try {
-        await fs9.promises.access(filePath, fs9.constants.F_OK);
+        await fs10.promises.access(filePath, fs10.constants.F_OK);
         return true;
       } catch {
         return false;
@@ -8647,7 +8651,7 @@ var init_refactoring_assistant = __esm({
         if (!await pathExists11(filePath)) {
           throw new Error(`File not found: ${filePath}`);
         }
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         if (startLine < 0 || endLine >= lines.length || startLine > endLine) {
           throw new Error("Invalid line range");
@@ -8722,7 +8726,7 @@ var init_refactoring_assistant = __esm({
         if (!filePath || !variableName) {
           throw new Error("File path and variable name are required");
         }
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const startLineContent = lines[startLine];
         const endLineContent = lines[endLine];
@@ -8797,7 +8801,7 @@ var init_refactoring_assistant = __esm({
         if (!functionSymbol) {
           throw new Error(`Function '${symbolName}' not found`);
         }
-        const content = await fs9.promises.readFile(filePath, "utf-8");
+        const content = await fs10.promises.readFile(filePath, "utf-8");
         const lines = content.split("\n");
         const functionLines = lines.slice(functionSymbol.startPosition.row, functionSymbol.endPosition.row + 1);
         const functionBody = this.extractFunctionBody(functionLines.join("\n"));
@@ -8907,7 +8911,7 @@ var init_refactoring_assistant = __esm({
       }
       async generateRenameChanges(ref, oldName, newName, includeComments, includeStrings) {
         const changes = [];
-        const content = await fs9.promises.readFile(ref.filePath, "utf-8");
+        const content = await fs10.promises.readFile(ref.filePath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           const line = lines[i];
@@ -9282,7 +9286,7 @@ var init_codebase_explorer = __esm({
           return files;
         }
         try {
-          const entries = await fs6__default.readdir(dirPath, { withFileTypes: true });
+          const entries = await fs7__default.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
             const fullPath = path8__default.join(dirPath, entry.name);
             const relativePath = path8__default.relative(options.rootPath, fullPath);
@@ -9305,7 +9309,7 @@ var init_codebase_explorer = __esm({
               files.push(...subFiles);
             } else {
               try {
-                const stats = await fs6__default.stat(fullPath);
+                const stats = await fs7__default.stat(fullPath);
                 fileInfo.size = stats.size;
                 fileInfo.lastModified = stats.mtimeMs;
                 if (fileInfo.size > this.settings.maxFileSize) {
@@ -9578,7 +9582,7 @@ var init_codebase_explorer = __esm({
       async detectProjectType(rootPath, files) {
         const packageJsonPath = path8__default.join(rootPath, "package.json");
         try {
-          const packageJson = await fs6__default.readFile(packageJsonPath, "utf-8");
+          const packageJson = await fs7__default.readFile(packageJsonPath, "utf-8");
           const pkg = JSON.parse(packageJson);
           if (pkg.dependencies?.react || pkg.devDependencies?.react) return "react";
           if (pkg.dependencies?.vue || pkg.devDependencies?.vue) return "vue";
@@ -9774,7 +9778,7 @@ var init_codebase_explorer = __esm({
        */
       async calculateFileChecksum(filePath) {
         try {
-          const content = await fs6__default.readFile(filePath);
+          const content = await fs7__default.readFile(filePath);
           return crypto2.createHash("sha256").update(content).digest("hex");
         } catch {
           return "";
@@ -9958,7 +9962,7 @@ var init_incremental_indexer = __esm({
       async scanDirectory(dirPath, options, files, depth = 0) {
         if (depth > 10) return;
         try {
-          const entries = await fs6__default.readdir(dirPath, { withFileTypes: true });
+          const entries = await fs7__default.readdir(dirPath, { withFileTypes: true });
           for (const entry of entries) {
             const fullPath = path8__default.join(dirPath, entry.name);
             if (!this.shouldTrackFile(fullPath, options)) {
@@ -9968,7 +9972,7 @@ var init_incremental_indexer = __esm({
               await this.scanDirectory(fullPath, options, files, depth + 1);
             } else {
               try {
-                const stats = await fs6__default.stat(fullPath);
+                const stats = await fs7__default.stat(fullPath);
                 if (options.maxFileSize && stats.size > options.maxFileSize) {
                   continue;
                 }
@@ -10008,7 +10012,7 @@ var init_incremental_indexer = __esm({
       }
       async calculateChecksum(filePath) {
         try {
-          const content = await fs6__default.readFile(filePath);
+          const content = await fs7__default.readFile(filePath);
           return crypto2.createHash("sha256").update(content).digest("hex");
         } catch {
           return "";
@@ -11663,7 +11667,7 @@ var init_autonomous_executor = __esm({
         let originalContent = "";
         try {
           if (operation !== "create") {
-            originalContent = await fs6.readFile(filePath, "utf-8");
+            originalContent = await fs7.readFile(filePath, "utf-8");
           }
         } catch (error) {
           if (operation === "update") {
@@ -11719,11 +11723,11 @@ var init_autonomous_executor = __esm({
        */
       async applyFileTransaction(step) {
         const dir = path8.dirname(step.filePath);
-        await fs6.mkdir(dir, { recursive: true });
+        await fs7.mkdir(dir, { recursive: true });
         if (step.operation === "delete") {
-          await fs6.unlink(step.filePath);
+          await fs7.unlink(step.filePath);
         } else {
-          await fs6.writeFile(step.filePath, step.newContent, "utf-8");
+          await fs7.writeFile(step.filePath, step.newContent, "utf-8");
         }
       }
       /**
@@ -11732,15 +11736,15 @@ var init_autonomous_executor = __esm({
       async rollbackFileTransaction(step) {
         if (step.operation === "create") {
           try {
-            await fs6.unlink(step.filePath);
+            await fs7.unlink(step.filePath);
           } catch {
           }
         } else if (step.operation === "update") {
-          await fs6.writeFile(step.filePath, step.originalContent, "utf-8");
+          await fs7.writeFile(step.filePath, step.originalContent, "utf-8");
         } else if (step.operation === "delete") {
           const dir = path8.dirname(step.filePath);
-          await fs6.mkdir(dir, { recursive: true });
-          await fs6.writeFile(step.filePath, step.originalContent, "utf-8");
+          await fs7.mkdir(dir, { recursive: true });
+          await fs7.writeFile(step.filePath, step.originalContent, "utf-8");
         }
       }
       /**
@@ -12249,7 +12253,7 @@ var init_autonomous_executor = __esm({
           await this.transactionManager.commitTransaction(transactionId);
           for (const file of filesModified) {
             try {
-              const content = await fs6.readFile(file, "utf-8");
+              const content = await fs7.readFile(file, "utf-8");
               context.fileSnapshots.set(file, content);
             } catch {
             }
@@ -12358,13 +12362,13 @@ var init_autonomous_executor = __esm({
       async saveTaskState(task) {
         try {
           const stateFile = path8.join(this.config.rootPath, ".autonomous", `task_${task.id}.json`);
-          await fs6.mkdir(path8.dirname(stateFile), { recursive: true });
+          await fs7.mkdir(path8.dirname(stateFile), { recursive: true });
           const state = {
             task,
             timestamp: Date.now(),
             version: "1.0"
           };
-          await fs6.writeFile(stateFile, JSON.stringify(state, null, 2), "utf-8");
+          await fs7.writeFile(stateFile, JSON.stringify(state, null, 2), "utf-8");
         } catch (error) {
           console.warn("Failed to save task state:", error);
         }
@@ -12375,7 +12379,7 @@ var init_autonomous_executor = __esm({
       async loadTaskState(taskId) {
         try {
           const stateFile = path8.join(this.config.rootPath, ".autonomous", `task_${taskId}.json`);
-          const content = await fs6.readFile(stateFile, "utf-8");
+          const content = await fs7.readFile(stateFile, "utf-8");
           const state = JSON.parse(content);
           return state.task;
         } catch {
@@ -12409,7 +12413,7 @@ var init_autonomous_executor = __esm({
         console.log(`\u{1F916} Generating changes for: "${goal}" in ${filePath}`);
         let currentContent = "";
         try {
-          currentContent = await fs6.readFile(filePath, "utf-8");
+          currentContent = await fs7.readFile(filePath, "utf-8");
         } catch {
           currentContent = "";
         }
@@ -12907,12 +12911,12 @@ var init_agent_framework = __esm({
        */
       async loadPersistedMemory() {
         try {
-          await fs6.mkdir(this.memoryPath, { recursive: true });
-          const files = await fs6.readdir(this.memoryPath);
+          await fs7.mkdir(this.memoryPath, { recursive: true });
+          const files = await fs7.readdir(this.memoryPath);
           for (const file of files) {
             if (file.endsWith(".json")) {
               try {
-                const content = await fs6.readFile(path8.join(this.memoryPath, file), "utf-8");
+                const content = await fs7.readFile(path8.join(this.memoryPath, file), "utf-8");
                 const sessionData = JSON.parse(content);
                 const session = {
                   ...sessionData,
@@ -12953,7 +12957,7 @@ var init_agent_framework = __esm({
             },
             learnedPatterns: Array.from(session.learnedPatterns.entries())
           };
-          await fs6.writeFile(filePath, JSON.stringify(serializable, null, 2), "utf-8");
+          await fs7.writeFile(filePath, JSON.stringify(serializable, null, 2), "utf-8");
         } catch (error) {
           console.warn(`Failed to persist session ${session.id}:`, error);
         }
@@ -12968,7 +12972,7 @@ var init_agent_framework = __esm({
        */
       async loadPlugins() {
         try {
-          await fs6.mkdir(this.pluginPath, { recursive: true });
+          await fs7.mkdir(this.pluginPath, { recursive: true });
         } catch (error) {
           console.warn("Failed to load plugins:", error);
         }
@@ -13393,6 +13397,7 @@ var init_tools2 = __esm({
   "src/tools/index.ts"() {
     init_bash();
     init_text_editor();
+    init_smart_edit();
     init_morph_editor();
     init_todo_tool();
     init_confirmation_tool();
@@ -13472,10 +13477,10 @@ var init_token_counter = __esm({
 function loadCustomInstructions(workingDirectory = process.cwd()) {
   try {
     const instructionsPath = path8.join(workingDirectory, ".grok", "GROK.md");
-    if (!fs9.existsSync(instructionsPath)) {
+    if (!fs10.existsSync(instructionsPath)) {
       return null;
     }
-    const customInstructions = fs9.readFileSync(instructionsPath, "utf-8");
+    const customInstructions = fs10.readFileSync(instructionsPath, "utf-8");
     return customInstructions.trim();
   } catch (error) {
     console.warn("Failed to load custom instructions:", error);
@@ -13591,10 +13596,10 @@ var init_execution_orchestrator = __esm({
         const state = /* @__PURE__ */ new Map();
         try {
           const walkDir = (dir) => {
-            const files = fs9.readdirSync(dir);
+            const files = fs10.readdirSync(dir);
             for (const file of files) {
               const filePath = path8.join(dir, file);
-              const stat = fs9.statSync(filePath);
+              const stat = fs10.statSync(filePath);
               if (stat.isDirectory() && !file.startsWith(".") && file !== "node_modules") {
                 walkDir(filePath);
               } else if (stat.isFile()) {
@@ -13642,7 +13647,7 @@ var init_execution_orchestrator = __esm({
         console.log(`[grok-one-shot] #${step.id} Changes detected:`);
         for (const change of step.changes) {
           console.log(`  ${change.changeType.toUpperCase()}: ${change.filePath}`);
-          if (change.changeType === "modified" && fs9.existsSync(change.filePath)) {
+          if (change.changeType === "modified" && fs10.existsSync(change.filePath)) {
             try {
               if (this.isGitRepository()) {
                 const diff = execSync(`git diff --no-index /dev/null ${change.filePath} 2>/dev/null || git diff ${change.filePath}`, {
@@ -13668,8 +13673,8 @@ var init_execution_orchestrator = __esm({
         }
         try {
           const patchesDir = path8.join(__require("os").homedir(), ".grok", "patches");
-          if (!fs9.existsSync(patchesDir)) {
-            fs9.mkdirSync(patchesDir, { recursive: true });
+          if (!fs10.existsSync(patchesDir)) {
+            fs10.mkdirSync(patchesDir, { recursive: true });
           }
           const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const patchFile = path8.join(patchesDir, `step-${step.id}-${timestamp}.patch`);
@@ -13679,7 +13684,7 @@ var init_execution_orchestrator = __esm({
 
 `;
           for (const change of step.changes) {
-            if (change.changeType === "modified" && fs9.existsSync(change.filePath)) {
+            if (change.changeType === "modified" && fs10.existsSync(change.filePath)) {
               try {
                 const diff = execSync(`git diff ${change.filePath}`, {
                   encoding: "utf-8",
@@ -13693,7 +13698,7 @@ ${diff}
               }
             }
           }
-          fs9.writeFileSync(patchFile, patchContent);
+          fs10.writeFileSync(patchFile, patchContent);
           console.log(`[grok-one-shot] #${step.id} Patch saved: ${patchFile}`);
           return patchFile;
         } catch (error) {
@@ -13709,10 +13714,10 @@ ${diff}
           return;
         }
         for (const change of step.changes) {
-          if ((change.changeType === "modified" || change.changeType === "created") && fs9.existsSync(change.filePath)) {
+          if ((change.changeType === "modified" || change.changeType === "created") && fs10.existsSync(change.filePath)) {
             try {
               const backupPath = `${change.filePath}.bak`;
-              fs9.copyFileSync(change.filePath, backupPath);
+              fs10.copyFileSync(change.filePath, backupPath);
               change.backupPath = backupPath;
               console.log(`[grok-one-shot] #${step.id} Backup created: ${backupPath}`);
             } catch (_error) {
@@ -13804,10 +13809,10 @@ Auto-generated by grok-one-shot execution orchestrator`;
         try {
           const testFiles = [];
           const walkDir = (dir) => {
-            const files = fs9.readdirSync(dir);
+            const files = fs10.readdirSync(dir);
             for (const file of files) {
               const filePath = path8.join(dir, file);
-              const stat = fs9.statSync(filePath);
+              const stat = fs10.statSync(filePath);
               if (stat.isDirectory() && !file.startsWith(".") && file !== "node_modules") {
                 walkDir(filePath);
               } else if (stat.isFile() && (file.includes("test") || file.includes("spec"))) {
@@ -13826,7 +13831,7 @@ Auto-generated by grok-one-shot execution orchestrator`;
        */
       findBuildFiles() {
         const buildFiles = ["package.json", "tsconfig.json", "webpack.config.js", "babel.config.js"];
-        return buildFiles.filter((file) => fs9.existsSync(file));
+        return buildFiles.filter((file) => fs10.existsSync(file));
       }
       /**
        * Find source files
@@ -13835,10 +13840,10 @@ Auto-generated by grok-one-shot execution orchestrator`;
         try {
           const sourceFiles = [];
           const walkDir = (dir) => {
-            const files = fs9.readdirSync(dir);
+            const files = fs10.readdirSync(dir);
             for (const file of files) {
               const filePath = path8.join(dir, file);
-              const stat = fs9.statSync(filePath);
+              const stat = fs10.statSync(filePath);
               if (stat.isDirectory() && !file.startsWith(".") && file !== "node_modules") {
                 walkDir(filePath);
               } else if (stat.isFile() && (file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx"))) {
@@ -18863,8 +18868,8 @@ var init_codebase_indexer = __esm({
         };
       }
       async indexFile(filePath) {
-        const stats = await fs9__default.promises.stat(filePath);
-        const content = await fs9__default.promises.readFile(filePath, "utf8");
+        const stats = await fs10__default.promises.stat(filePath);
+        const content = await fs10__default.promises.readFile(filePath, "utf8");
         const extension = path8__default.extname(filePath);
         const language = this.detectLanguage(extension);
         return {
@@ -18879,7 +18884,7 @@ var init_codebase_indexer = __esm({
         };
       }
       async extractSymbols(filePath) {
-        const content = await fs9__default.promises.readFile(filePath, "utf8");
+        const content = await fs10__default.promises.readFile(filePath, "utf8");
         const extension = path8__default.extname(filePath);
         const symbols = [];
         if (extension === ".ts" || extension === ".js" || extension === ".tsx" || extension === ".jsx") {
@@ -19029,7 +19034,7 @@ var init_codebase_indexer = __esm({
           const dirInfo = dirMap.get(dir);
           dirInfo.fileCount++;
           try {
-            const stats = await fs9__default.promises.stat(file);
+            const stats = await fs10__default.promises.stat(file);
             dirInfo.totalSize += stats.size;
           } catch (error) {
           }
@@ -19056,7 +19061,7 @@ var init_codebase_indexer = __esm({
         const packageJson = configFiles.find((f) => path8__default.basename(f) === "package.json");
         if (packageJson) {
           try {
-            const pkg = JSON.parse(fs9__default.readFileSync(packageJson, "utf8"));
+            const pkg = JSON.parse(fs10__default.readFileSync(packageJson, "utf8"));
             if (pkg.main) entryPoints.push(path8__default.resolve(path8__default.dirname(packageJson), pkg.main));
             if (pkg.types) entryPoints.push(path8__default.resolve(path8__default.dirname(packageJson), pkg.types));
           } catch (error) {
@@ -19838,7 +19843,7 @@ var init_semantic_code_search = __esm({
       }
       async extractContext(symbol) {
         try {
-          const content = await fs6__default.readFile(symbol.filePath, "utf8");
+          const content = await fs7__default.readFile(symbol.filePath, "utf8");
           const lines = content.split("\n");
           const startLine = Math.max(0, symbol.line - 3);
           const endLine = Math.min(lines.length, symbol.line + 3);
@@ -19879,7 +19884,7 @@ var init_semantic_code_search = __esm({
         for (const [filePath, fileInfo] of index.files) {
           if (fileInfo.language === "unknown" || fileInfo.size > 1e5) continue;
           try {
-            const content = await fs6__default.readFile(filePath, "utf8");
+            const content = await fs7__default.readFile(filePath, "utf8");
             const lines = content.split("\n");
             for (let i = 0; i < lines.length; i++) {
               const line = lines[i].toLowerCase();
@@ -21622,12 +21627,12 @@ EOF`;
       saveSessionLog() {
         try {
           const sessionDir = path8__default.join(__require("os").homedir(), ".grok");
-          if (!fs9__default.existsSync(sessionDir)) {
-            fs9__default.mkdirSync(sessionDir, { recursive: true });
+          if (!fs10__default.existsSync(sessionDir)) {
+            fs10__default.mkdirSync(sessionDir, { recursive: true });
           }
           const sessionFile = path8__default.join(sessionDir, "session.log");
           const logLines = this.chatHistory.map((entry) => JSON.stringify(entry)).join("\n") + "\n";
-          fs9__default.writeFileSync(sessionFile, logLines);
+          fs10__default.writeFileSync(sessionFile, logLines);
         } catch (error) {
           console.warn("Failed to save session log:", error);
         }
@@ -21876,8 +21881,8 @@ EOF`;
       logEntry(entry) {
         try {
           const dir = path8__default.dirname(this.sessionLogPath);
-          if (!fs9__default.existsSync(dir)) {
-            fs9__default.mkdirSync(dir, { recursive: true });
+          if (!fs10__default.existsSync(dir)) {
+            fs10__default.mkdirSync(dir, { recursive: true });
           }
           const logLine = JSON.stringify({
             type: entry.type,
@@ -21886,7 +21891,7 @@ EOF`;
             toolCallId: entry.toolCall?.id,
             toolCallsCount: entry.toolCalls?.length
           }) + "\n";
-          fs9__default.appendFileSync(this.sessionLogPath, logLine);
+          fs10__default.appendFileSync(this.sessionLogPath, logLine);
         } catch (error) {
           console.warn("Failed to log session entry:", error);
         }
@@ -24076,7 +24081,7 @@ var init_readonly_filesystem_overlay = __esm({
           };
         }
         try {
-          const actualContent = await fs9__default.promises.readFile(resolvedPath, "utf-8");
+          const actualContent = await fs10__default.promises.readFile(resolvedPath, "utf-8");
           return {
             success: true,
             output: this.formatFileContent(actualContent, args),
@@ -24133,7 +24138,7 @@ var init_readonly_filesystem_overlay = __esm({
         const filePath = args.path || args.file_path || args.filename;
         const content = args.content || "";
         const resolvedPath = path8__default.resolve(this.config.baseDirectory, filePath);
-        const fileExists = fs9__default.existsSync(resolvedPath);
+        const fileExists = fs10__default.existsSync(resolvedPath);
         const sizeImpact = content.length;
         return {
           type: "file_creation",
@@ -24162,7 +24167,7 @@ var init_readonly_filesystem_overlay = __esm({
         const filePath = args.path || args.file_path || args.filename;
         const resolvedPath = path8__default.resolve(this.config.baseDirectory, filePath);
         try {
-          const originalContent = fs9__default.existsSync(resolvedPath) ? await fs9__default.promises.readFile(resolvedPath, "utf-8") : "";
+          const originalContent = fs10__default.existsSync(resolvedPath) ? await fs10__default.promises.readFile(resolvedPath, "utf-8") : "";
           let newContent = originalContent;
           if (args.old_string && args.new_string !== void 0) {
             newContent = args.replace_all ? originalContent.split(args.old_string).join(args.new_string) : originalContent.replace(args.old_string, args.new_string);
@@ -24205,11 +24210,11 @@ var init_readonly_filesystem_overlay = __esm({
       async simulateFileDeletion(args) {
         const filePath = args.path || args.file_path || args.filename;
         const resolvedPath = path8__default.resolve(this.config.baseDirectory, filePath);
-        const fileExists = fs9__default.existsSync(resolvedPath);
+        const fileExists = fs10__default.existsSync(resolvedPath);
         let originalSize = 0;
         if (fileExists) {
           try {
-            const stats = await fs9__default.promises.stat(resolvedPath);
+            const stats = await fs10__default.promises.stat(resolvedPath);
             originalSize = stats.size;
           } catch {
           }
@@ -29275,7 +29280,7 @@ var init_package = __esm({
     package_default = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.2.13",
+      version: "1.2.14",
       description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
@@ -31851,14 +31856,14 @@ function useContextInfo(agent) {
 async function getWorkspaceFileCount() {
   try {
     const cwd = process.cwd();
-    const entries = await fs9__default.promises.readdir(cwd, { withFileTypes: true });
+    const entries = await fs10__default.promises.readdir(cwd, { withFileTypes: true });
     let count = 0;
     for (const entry of entries) {
       if (entry.isFile() && !shouldIgnoreFile(entry.name)) {
         count++;
       } else if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
         try {
-          const subEntries = await fs9__default.promises.readdir(path8__default.join(cwd, entry.name), { withFileTypes: true });
+          const subEntries = await fs10__default.promises.readdir(path8__default.join(cwd, entry.name), { withFileTypes: true });
           count += subEntries.filter((sub) => sub.isFile() && !shouldIgnoreFile(sub.name)).length;
         } catch {
         }
@@ -31879,8 +31884,8 @@ function shouldIgnoreDirectory(dirname6) {
 async function getIndexSize() {
   try {
     const indexPath = path8__default.join(process.cwd(), ".grok", "index.json");
-    if (fs9__default.existsSync(indexPath)) {
-      const stats = await fs9__default.promises.stat(indexPath);
+    if (fs10__default.existsSync(indexPath)) {
+      const stats = await fs10__default.promises.stat(indexPath);
       const mb = stats.size / (1024 * 1024);
       return mb > 1 ? `${mb.toFixed(1)} MB` : `${(stats.size / 1024).toFixed(1)} KB`;
     }
@@ -31891,8 +31896,8 @@ async function getIndexSize() {
 async function getSessionFileCount() {
   try {
     const sessionPath = path8__default.join(os__default.homedir(), ".grok", "session.log");
-    if (fs9__default.existsSync(sessionPath)) {
-      const content = await fs9__default.promises.readFile(sessionPath, "utf8");
+    if (fs10__default.existsSync(sessionPath)) {
+      const content = await fs10__default.promises.readFile(sessionPath, "utf8");
       return content.split("\n").filter((line) => line.trim()).length;
     }
   } catch {
@@ -31902,8 +31907,8 @@ async function getSessionFileCount() {
 async function getGitBranch() {
   try {
     const gitPath = path8__default.join(process.cwd(), ".git", "HEAD");
-    if (fs9__default.existsSync(gitPath)) {
-      const content = await fs9__default.promises.readFile(gitPath, "utf8");
+    if (fs10__default.existsSync(gitPath)) {
+      const content = await fs10__default.promises.readFile(gitPath, "utf8");
       const match = content.match(/ref: refs\/heads\/(.+)/);
       return match ? match[1].trim() : "detached";
     }
@@ -31914,8 +31919,8 @@ async function getGitBranch() {
 async function getProjectName() {
   try {
     const packagePath = path8__default.join(process.cwd(), "package.json");
-    if (fs9__default.existsSync(packagePath)) {
-      const content = await fs9__default.promises.readFile(packagePath, "utf8");
+    if (fs10__default.existsSync(packagePath)) {
+      const content = await fs10__default.promises.readFile(packagePath, "utf8");
       const pkg = JSON.parse(content);
       return pkg.name;
     }
@@ -31958,20 +31963,20 @@ function useCLAUDEmd(setChatHistory) {
   useEffect(() => {
     const filesToLoad = [
       { path: "GROK.md", label: "GROK.md", fallback: "CLAUDE.md" },
-      { path: "docs-index.md", label: "Documentation Index" }
+      { path: ".agent/docs-summary.md", label: "Compressed Documentation Summary" }
     ];
     const loadedDocs = [];
     let totalChars = 0;
     for (const file of filesToLoad) {
       let filePath = file.path;
-      let exists = fs9__default.existsSync(filePath);
+      let exists = fs10__default.existsSync(filePath);
       if (!exists && file.fallback) {
         filePath = file.fallback;
-        exists = fs9__default.existsSync(filePath);
+        exists = fs10__default.existsSync(filePath);
       }
       if (exists) {
         try {
-          const content = fs9__default.readFileSync(filePath, "utf8");
+          const content = fs10__default.readFileSync(filePath, "utf8");
           const charCount = content.length;
           totalChars += charCount;
           loadedDocs.push(file.label);
@@ -32345,11 +32350,11 @@ function useSessionLogging(chatHistory) {
       const sessionFile = path8__default.join(os__default.homedir(), ".grok", "session.log");
       try {
         const dir = path8__default.dirname(sessionFile);
-        if (!fs9__default.existsSync(dir)) {
-          fs9__default.mkdirSync(dir, { recursive: true });
+        if (!fs10__default.existsSync(dir)) {
+          fs10__default.mkdirSync(dir, { recursive: true });
         }
         const lines = newEntries.map((entry) => JSON.stringify(entry)).join("\n") + "\n";
-        fs9__default.appendFileSync(sessionFile, lines);
+        fs10__default.appendFileSync(sessionFile, lines);
       } catch {
       }
     }
@@ -32750,10 +32755,10 @@ ${data ? JSON.stringify(data, null, 2) : "No additional data"}
 `;
     const workingDir = process.cwd();
     const logsDir = path8__default.join(workingDir, "logs");
-    const sessionFiles = fs9__default.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
+    const sessionFiles = fs10__default.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
     if (sessionFiles.length > 0) {
       const sessionFile = path8__default.join(logsDir, sessionFiles[sessionFiles.length - 1]);
-      fs9__default.appendFileSync(sessionFile, logEntry);
+      fs10__default.appendFileSync(sessionFile, logEntry);
     } else {
       console.log(`[ColoredDiffRenderer] ${message}`, data);
     }
@@ -32827,10 +32832,10 @@ ${data ? JSON.stringify(data, null, 2) : "No additional data"}
 `;
     const workingDir = process.cwd();
     const logsDir = path8__default.join(workingDir, "logs");
-    const sessionFiles = fs9__default.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
+    const sessionFiles = fs10__default.readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
     if (sessionFiles.length > 0) {
       const sessionFile = path8__default.join(logsDir, sessionFiles[sessionFiles.length - 1]);
-      fs9__default.appendFileSync(sessionFile, logEntry);
+      fs10__default.appendFileSync(sessionFile, logEntry);
     } else {
       console.log(`[MarkdownRenderer] ${message}`, data);
     }
@@ -34779,7 +34784,7 @@ var init_session_logger = __esm({
         this.init();
       }
       init() {
-        fs9__default.mkdirSync(path8__default.dirname(this.logPath), { recursive: true });
+        fs10__default.mkdirSync(path8__default.dirname(this.logPath), { recursive: true });
         const header = `
 =================================================================
 \u{1F9EA} GROK ONE-SHOT TESTING SESSION
@@ -34788,7 +34793,7 @@ Started: ${(/* @__PURE__ */ new Date()).toISOString()}
 =================================================================
 
 `;
-        fs9__default.writeFileSync(this.logPath, header);
+        fs10__default.writeFileSync(this.logPath, header);
       }
       logTerminalState(state) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -34804,7 +34809,7 @@ LAST ENTRY: ${state.chatHistory.length > 0 ? JSON.stringify(state.chatHistory[st
 =====================================
 
 `;
-        fs9__default.appendFileSync(this.logPath, entry);
+        fs10__default.appendFileSync(this.logPath, entry);
       }
       logUserAction(action, details = {}) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -34812,7 +34817,7 @@ LAST ENTRY: ${state.chatHistory.length > 0 ? JSON.stringify(state.chatHistory[st
 Details: ${JSON.stringify(details, null, 2)}
 
 `;
-        fs9__default.appendFileSync(this.logPath, entry);
+        fs10__default.appendFileSync(this.logPath, entry);
       }
       logPasteEvent(event) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -34820,7 +34825,7 @@ Details: ${JSON.stringify(details, null, 2)}
 Data: ${JSON.stringify(event.data, null, 2)}
 
 `;
-        fs9__default.appendFileSync(this.logPath, entry);
+        fs10__default.appendFileSync(this.logPath, entry);
       }
       logTestResult(testName, result, details) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -34831,7 +34836,7 @@ Details: ${details}
 =================================================================
 
 `;
-        fs9__default.appendFileSync(this.logPath, entry);
+        fs10__default.appendFileSync(this.logPath, entry);
       }
       getLogPath() {
         return this.logPath;
@@ -35288,7 +35293,7 @@ var require_package = __commonJS({
     module.exports = {
       type: "module",
       name: "@xagent/one-shot",
-      version: "1.2.13",
+      version: "1.2.14",
       description: "An open-source AI agent that brings advanced AI capabilities directly into your terminal with automatic documentation updates.",
       main: "dist/index.js",
       module: "dist/index.js",
@@ -35442,7 +35447,7 @@ var require_package = __commonJS({
   }
 });
 dotenv.config();
-var logStream = fs9__default.createWriteStream(path8__default.join(process.cwd(), "xcli-startup.log"), { flags: "a" });
+var logStream = fs10__default.createWriteStream(path8__default.join(process.cwd(), "xcli-startup.log"), { flags: "a" });
 var isQuietCommand = process.argv.includes("--version") || process.argv.includes("-V") || process.argv.includes("--help") || process.argv.includes("-h");
 if (isQuietCommand) {
   process.env.GROK_QUIET_MODE = "true";