@bike4mind/cli 0.2.1-quest-file-uploads.17007 → 0.2.3-basic-cli-shortcuts.17058

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-QXGU6KYI.js";
-import "./chunk-LZMRYJ3B.js";
-import "./chunk-F3ETXO5N.js";
+} from "./chunk-GZTILMGE.js";
+import "./chunk-Y4HMTEDH.js";
+import "./chunk-5N4PG5EH.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-NZADYDFG.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -29,6 +29,7 @@ import {
   AuthEvents,
   BFL_IMAGE_MODELS,
   BFL_SAFETY_TOLERANCE,
+  CREDIT_DEDUCT_TRANSACTION_TYPES,
   ChatCompletionCreateInputSchema,
   ChatModels,
   CollectionType,
@@ -78,13 +79,13 @@ import {
 } from "./chunk-PDX44BCA.js";
 
 // src/index.tsx
-import React10, { useState as useState3, useEffect as useEffect3, useCallback } from "react";
-import { render, Box as Box10, Text as Text9, useApp, useInput as useInput2 } from "ink";
+import React12, { useState as useState4, useEffect as useEffect3, useCallback } from "react";
+import { render, Box as Box11, Text as Text11, useApp, useInput as useInput3 } from "ink";
 import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
-import React7 from "react";
-import { Box as Box7, Text as Text6, Static } from "ink";
+import React9 from "react";
+import { Box as Box8, Text as Text8, Static } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
@@ -94,26 +95,327 @@ var StatusBar = React.memo(function StatusBar2({ sessionName, model, tokenUsage
 });
 
 // src/components/InputPrompt.tsx
-import React3, { useState, useMemo, useEffect } from "react";
-import { Box as Box3, Text as Text3, useInput } from "ink";
-import TextInput from "ink-text-input";
+import React5, { useState as useState2, useMemo, useEffect } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput2 } from "ink";
+
+// src/components/CustomTextInput.tsx
+import React2, { useState } from "react";
+import { Text as Text2, useInput } from "ink";
+function CustomTextInput({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  showCursor = true
+}) {
+  const [cursorOffset, setCursorOffset] = useState(value.length);
+  useInput(
+    (input, key) => {
+      if (key.return) {
+        onSubmit(value);
+        return;
+      }
+      if (key.ctrl) {
+        switch (input) {
+          case "u":
+            {
+              const lines = value.split("\n");
+              let currentLineStart = 0;
+              let currentLineIndex = 0;
+              let charCount = 0;
+              for (let i = 0; i < lines.length; i++) {
+                const lineLength = lines[i].length;
+                if (charCount + lineLength >= cursorOffset) {
+                  currentLineIndex = i;
+                  currentLineStart = charCount;
+                  break;
+                }
+                charCount += lineLength + 1;
+              }
+              lines.splice(currentLineIndex, 1);
+              const newValue = lines.join("\n");
+              onChange(newValue);
+              setCursorOffset(Math.min(currentLineStart, newValue.length));
+            }
+            return;
+          case "k":
+            onChange(value.slice(0, cursorOffset));
+            return;
+          case "w":
+            {
+              const beforeCursor2 = value.slice(0, cursorOffset);
+              const afterCursor2 = value.slice(cursorOffset);
+              const trimmed = beforeCursor2.trimEnd();
+              const lastSpace = trimmed.lastIndexOf(" ");
+              const newBefore = lastSpace === -1 ? "" : trimmed.slice(0, lastSpace + 1);
+              const newValue = newBefore + afterCursor2;
+              onChange(newValue);
+              setCursorOffset(newBefore.length);
+            }
+            return;
+          case "a":
+            setCursorOffset(0);
+            return;
+          case "e":
+            setCursorOffset(value.length);
+            return;
+          case "l":
+            onChange("");
+            return;
+        }
+      }
+      if (key.backspace || key.delete) {
+        if (cursorOffset > 0) {
+          const newValue = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
+          onChange(newValue);
+          setCursorOffset(cursorOffset - 1);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursorOffset(Math.max(0, cursorOffset - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursorOffset(Math.min(value.length, cursorOffset + 1));
+        return;
+      }
+      if (!key.ctrl && !key.meta && input.length === 1) {
+        const newValue = value.slice(0, cursorOffset) + input + value.slice(cursorOffset);
+        onChange(newValue);
+        setCursorOffset(cursorOffset + 1);
+      }
+    },
+    { isActive: true }
+  );
+  const hasValue = value.length > 0;
+  if (!hasValue) {
+    return /* @__PURE__ */ React2.createElement(Text2, null, showCursor ? /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Text2, { inverse: true }, " "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, placeholder)) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, placeholder));
+  }
+  const beforeCursor = value.slice(0, cursorOffset);
+  const cursorChar = value[cursorOffset] || " ";
+  const afterCursor = value.slice(cursorOffset + 1);
+  return /* @__PURE__ */ React2.createElement(Text2, null, beforeCursor, showCursor && /* @__PURE__ */ React2.createElement(Text2, { inverse: true }, cursorChar), !showCursor && cursorChar, afterCursor);
+}
 
 // src/components/CommandAutocomplete.tsx
-import React2 from "react";
-import { Box as Box2, Text as Text2 } from "ink";
+import React3 from "react";
+import { Box as Box2, Text as Text3 } from "ink";
 function CommandAutocomplete({ commands, selectedIndex }) {
   if (commands.length === 0) {
-    return /* @__PURE__ */ React2.createElement(Box2, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "No matching commands"));
+    return /* @__PURE__ */ React3.createElement(Box2, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "No matching commands"));
   }
-  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
+  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
     const args = cmd.args ? ` ${cmd.args}` : "";
     const isSelected = index === selectedIndex;
-    return /* @__PURE__ */ React2.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", "/", cmd.name, args, " - ", cmd.description));
+    return /* @__PURE__ */ React3.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", "/", cmd.name, args, " - ", cmd.description));
   }));
 }
 
-// src/utils/fuzzySearch.ts
+// src/components/FileAutocomplete.tsx
+import React4 from "react";
+import { Box as Box3, Text as Text4 } from "ink";
+
+// src/utils/fileSearch.ts
+import * as fs from "fs";
+import * as path from "path";
 import Fuse from "fuse.js";
+var DEFAULT_IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  ".cache",
+  "coverage",
+  ".DS_Store",
+  ".env",
+  ".env.local",
+  ".env.secrets"
+];
+function walkDirectory(basePath = process.cwd(), maxDepth = 5, ignorePatterns = DEFAULT_IGNORE_PATTERNS) {
+  const results = [];
+  const normalizedBase = path.resolve(basePath);
+  function walk(currentPath, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (ignorePatterns.some((pattern) => entry.name === pattern || entry.name.startsWith(pattern))) {
+          continue;
+        }
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(normalizedBase, fullPath);
+        if (entry.isDirectory()) {
+          results.push({
+            path: relativePath,
+            isDirectory: true
+          });
+          walk(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          try {
+            const stats = fs.statSync(fullPath);
+            results.push({
+              path: relativePath,
+              isDirectory: false,
+              size: stats.size
+            });
+          } catch {
+            results.push({
+              path: relativePath,
+              isDirectory: false
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  walk(normalizedBase, 0);
+  return results;
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+var cachedFiles = null;
+var cacheTimestamp = 0;
+var CACHE_TTL_MS = 3e4;
+function getCachedFiles() {
+  const now = Date.now();
+  if (!cachedFiles || now - cacheTimestamp > CACHE_TTL_MS) {
+    cachedFiles = walkDirectory();
+    cacheTimestamp = now;
+  }
+  return cachedFiles;
+}
+function searchFiles(query) {
+  const files = getCachedFiles();
+  if (!query || query.trim() === "") {
+    return files.filter((f) => !f.path.includes(path.sep)).slice(0, 20);
+  }
+  const queryDir = path.dirname(query);
+  let searchPool = files;
+  if (queryDir && queryDir !== ".") {
+    const normalizedDir = queryDir.replace(/\\/g, "/");
+    searchPool = files.filter((f) => {
+      const normalizedPath = f.path.replace(/\\/g, "/");
+      return normalizedPath.startsWith(normalizedDir + "/") || normalizedPath === normalizedDir;
+    });
+    if (searchPool.length === 0) {
+      searchPool = files;
+    }
+  }
+  const fuse2 = new Fuse(searchPool, {
+    keys: [{ name: "path", weight: 1 }],
+    threshold: 0.4,
+    // Allow some fuzzy matching
+    includeScore: true,
+    minMatchCharLength: 1,
+    // Use extended search for better path matching
+    useExtendedSearch: false
+  });
+  const results = fuse2.search(query);
+  return results.slice(0, 20).map((result) => result.item);
+}
+function isPathWithinCwd(filePath) {
+  const cwd = path.resolve(process.cwd());
+  const absolutePath = path.resolve(cwd, filePath);
+  let resolvedCwd = cwd;
+  let resolvedPath = absolutePath;
+  try {
+    const realCwd = fs.realpathSync.native(cwd);
+    if (realCwd) {
+      resolvedCwd = realCwd;
+    }
+  } catch {
+  }
+  try {
+    const realPath = fs.realpathSync.native(absolutePath);
+    if (realPath) {
+      resolvedPath = realPath;
+    }
+  } catch {
+    const relativePath2 = path.relative(cwd, absolutePath);
+    resolvedPath = path.resolve(resolvedCwd, relativePath2);
+  }
+  const normalizedCwd = resolvedCwd.toLowerCase();
+  const normalizedPath = resolvedPath.toLowerCase();
+  const isWithin = normalizedPath === normalizedCwd || normalizedPath.startsWith(normalizedCwd + path.sep);
+  if (!isWithin) {
+    return false;
+  }
+  const relativePath = path.relative(resolvedCwd, resolvedPath);
+  return !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function isBinaryFile(filePath) {
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".ico",
+    ".webp",
+    // Note: .svg is NOT included because SVG is XML text format that can be safely read
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".rar",
+    ".7z",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".dat",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".avi",
+    ".mov",
+    ".mkv",
+    ".ttf",
+    ".otf",
+    ".woff",
+    ".woff2",
+    ".eot",
+    ".class",
+    ".pyc",
+    ".o",
+    ".obj"
+  ];
+  const ext = path.extname(filePath).toLowerCase();
+  return binaryExtensions.includes(ext);
+}
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+// src/components/FileAutocomplete.tsx
+function FileAutocomplete({ files, selectedIndex, query }) {
+  if (files.length === 0) {
+    return /* @__PURE__ */ React4.createElement(Box3, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "No matching files", query ? ` for "${query}"` : ""));
+  }
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React4.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, files.length === 1 ? "1 match" : `${files.length} matches`, " - Use up/down to navigate, Tab to select")), files.map((file, index) => {
+    const isSelected = index === selectedIndex;
+    const icon = file.isDirectory ? "[folder]" : "[file]  ";
+    const sizeDisplay = file.isDirectory ? "" : file.size !== void 0 ? ` (${formatFileSize(file.size)})` : "";
+    const pathDisplay = file.isDirectory ? `${file.path}/` : file.path;
+    return /* @__PURE__ */ React4.createElement(Box3, { key: file.path, marginLeft: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "> " : "  "), /* @__PURE__ */ React4.createElement(Text4, { color: file.isDirectory ? "yellow" : isSelected ? "cyan" : void 0, bold: isSelected }, icon), /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0, bold: isSelected }, " ", pathDisplay), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, sizeDisplay));
+  }));
+}
+
+// src/utils/fuzzySearch.ts
+import Fuse2 from "fuse.js";
 
 // src/config/commands.ts
 var COMMANDS = [
@@ -177,11 +479,15 @@ var COMMANDS = [
   {
     name: "trusted",
     description: "List all trusted tools"
+  },
+  {
+    name: "usage",
+    description: "Show credit usage and balance"
   }
 ];
 
 // src/utils/fuzzySearch.ts
-var fuse = new Fuse(COMMANDS, {
+var fuse = new Fuse2(COMMANDS, {
   keys: [
     { name: "name", weight: 0.7 },
     // Prioritize command name
@@ -202,23 +508,64 @@ function searchCommands(query) {
 }
 
 // src/components/InputPrompt.tsx
+function findAtTrigger(value) {
+  for (let i = value.length - 1; i >= 0; i--) {
+    if (value[i] === "@") {
+      const isValid = i === 0 || value[i - 1] === " ";
+      if (isValid) {
+        const query = value.slice(i + 1);
+        if (query.includes(" ")) {
+          return null;
+        }
+        return { startIndex: i, query };
+      }
+    }
+  }
+  return null;
+}
 function InputPrompt({ onSubmit, disabled = false, history = [] }) {
-  const [value, setValue] = useState("");
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [historyIndex, setHistoryIndex] = useState(-1);
-  const [tempInput, setTempInput] = useState("");
-  const [inputKey, setInputKey] = useState(0);
-  const shouldShowAutocomplete = value.startsWith("/") && !disabled;
-  const query = shouldShowAutocomplete ? value.slice(1) : "";
+  const [value, setValue] = useState2("");
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [historyIndex, setHistoryIndex] = useState2(-1);
+  const [tempInput, setTempInput] = useState2("");
+  const [fileAutocomplete, setFileAutocomplete] = useState2(null);
+  const [fileSelectedIndex, setFileSelectedIndex] = useState2(0);
+  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
+  const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
   const filteredCommands = useMemo(() => {
-    if (!shouldShowAutocomplete) return [];
-    return searchCommands(query);
-  }, [shouldShowAutocomplete, query]);
+    if (!shouldShowCommandAutocomplete) return [];
+    return searchCommands(commandQuery);
+  }, [shouldShowCommandAutocomplete, commandQuery]);
+  const filteredFiles = useMemo(() => {
+    if (!fileAutocomplete?.active) return [];
+    return searchFiles(fileAutocomplete.query);
+  }, [fileAutocomplete?.active, fileAutocomplete?.query]);
   useEffect(() => {
     setSelectedIndex(0);
   }, [filteredCommands]);
-  useInput((input, key) => {
-    if (shouldShowAutocomplete && filteredCommands.length > 0) {
+  useEffect(() => {
+    setFileSelectedIndex(0);
+  }, [filteredFiles]);
+  useInput2((_input, key) => {
+    if (fileAutocomplete?.active && filteredFiles.length > 0) {
+      if (key.upArrow) {
+        setFileSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredFiles.length - 1);
+        return;
+      } else if (key.downArrow) {
+        setFileSelectedIndex((prev) => prev < filteredFiles.length - 1 ? prev + 1 : 0);
+        return;
+      } else if (key.tab) {
+        const selectedFile = filteredFiles[fileSelectedIndex];
+        if (selectedFile) {
+          insertSelectedFile(selectedFile);
+        }
+        return;
+      } else if (key.escape) {
+        setFileAutocomplete(null);
+        return;
+      }
+    }
+    if (shouldShowCommandAutocomplete && filteredCommands.length > 0) {
       if (key.upArrow) {
         setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredCommands.length - 1);
       } else if (key.downArrow) {
@@ -226,7 +573,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       }
       return;
     }
-    if (!shouldShowAutocomplete && history.length > 0) {
+    if (!shouldShowCommandAutocomplete && !fileAutocomplete?.active && history.length > 0) {
       if (key.upArrow) {
         if (historyIndex === -1) {
           setTempInput(value);
@@ -249,15 +596,39 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       }
     }
   });
+  const insertSelectedFile = (file) => {
+    if (!fileAutocomplete) return;
+    const beforeAt = value.slice(0, fileAutocomplete.startIndex);
+    const afterQuery = value.slice(fileAutocomplete.startIndex + 1 + fileAutocomplete.query.length);
+    const pathToInsert = file.isDirectory ? `@${file.path}/` : `@${file.path}`;
+    const newValue = beforeAt + pathToInsert + afterQuery;
+    setValue(newValue);
+    if (file.isDirectory) {
+      setFileAutocomplete({
+        active: true,
+        startIndex: fileAutocomplete.startIndex,
+        query: file.path + "/"
+      });
+      setFileSelectedIndex(0);
+    } else {
+      setFileAutocomplete(null);
+    }
+  };
   const handleSubmit = (input) => {
     if (disabled || !input.trim()) return;
-    if (shouldShowAutocomplete && filteredCommands.length > 0) {
+    if (fileAutocomplete?.active && filteredFiles.length > 0) {
+      const selectedFile = filteredFiles[fileSelectedIndex];
+      if (selectedFile) {
+        insertSelectedFile(selectedFile);
+      }
+      return;
+    }
+    if (shouldShowCommandAutocomplete && filteredCommands.length > 0) {
       const selectedCommand = filteredCommands[selectedIndex];
       const commandText = `/${selectedCommand.name}`;
       if (selectedCommand.args) {
         setValue(commandText + " ");
         setHistoryIndex(-1);
-        setInputKey((prev) => prev + 1);
         return;
       }
       setValue("");
@@ -268,6 +639,7 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     onSubmit(input);
     setValue("");
     setHistoryIndex(-1);
+    setFileAutocomplete(null);
   };
   const handleChange = (newValue) => {
     setValue(newValue);
@@ -275,30 +647,39 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
       setHistoryIndex(-1);
       setTempInput("");
     }
+    const atTrigger = findAtTrigger(newValue);
+    if (atTrigger) {
+      setFileAutocomplete({
+        active: true,
+        startIndex: atTrigger.startIndex,
+        query: atTrigger.query
+      });
+    } else {
+      setFileAutocomplete(null);
+    }
   };
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React3.createElement(
-    TextInput,
+  return /* @__PURE__ */ React5.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text5, { bold: true, color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(
+    CustomTextInput,
     {
-      key: inputKey,
       value,
       onChange: handleChange,
       onSubmit: handleSubmit,
-      placeholder: disabled ? "Thinking..." : "Type your message or /help for commands",
+      placeholder: disabled ? "Thinking..." : "Type your message, /help for commands, or @file to reference",
       showCursor: !disabled
     }
-  )), shouldShowAutocomplete && /* @__PURE__ */ React3.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }));
+  )), shouldShowCommandAutocomplete && /* @__PURE__ */ React5.createElement(CommandAutocomplete, { commands: filteredCommands, selectedIndex }), fileAutocomplete?.active && /* @__PURE__ */ React5.createElement(FileAutocomplete, { files: filteredFiles, selectedIndex: fileSelectedIndex, query: fileAutocomplete.query }));
 }
 
 // src/components/AgentThinking.tsx
-import React5 from "react";
-import { Box as Box5 } from "ink";
+import React7 from "react";
+import { Box as Box6 } from "ink";
 
 // src/components/ThoughtStream.tsx
-import React4 from "react";
-import { Box as Box4, Text as Text4 } from "ink";
+import React6 from "react";
+import { Box as Box5, Text as Text6 } from "ink";
 import Spinner from "ink-spinner";
-var ThoughtStream = React4.memo(function ThoughtStream2({ steps }) {
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, steps.map((step, index) => /* @__PURE__ */ React4.createElement(Box4, { key: index, flexDirection: "column" }, step.type === "thought" && /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "magenta" }, "\u{1F914} Thought: "), /* @__PURE__ */ React4.createElement(Text4, null, step.content)), step.type === "action" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "\u26A1 Action: "), /* @__PURE__ */ React4.createElement(Text4, { bold: true }, step.metadata?.toolName || "unknown")), step.metadata?.toolInput && /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, JSON.stringify(step.metadata.toolInput, null, 2)))), step.type === "observation" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "blue" }, "\u{1F4CA} Observation: ")), /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, null, step.content))), step.type === "final_answer" && /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, "\u2705 Final Answer:", " ")), /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, null, step.content)), step.metadata?.tokenUsage && /* @__PURE__ */ React4.createElement(Box4, { paddingLeft: 2 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "(", step.metadata.tokenUsage.total, " tokens)"))))), !steps.some((s) => s.type === "final_answer") && /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, /* @__PURE__ */ React4.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React4.createElement(Text4, null, " ", steps.length === 0 ? "Thinking..." : "Processing...")));
+var ThoughtStream = React6.memo(function ThoughtStream2({ steps }) {
+  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", gap: 1 }, steps.map((step, index) => /* @__PURE__ */ React6.createElement(Box5, { key: index, flexDirection: "column" }, step.type === "thought" && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, "\u{1F914} Thought: "), /* @__PURE__ */ React6.createElement(Text6, null, step.content)), step.type === "action" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, "\u26A1 Action: "), /* @__PURE__ */ React6.createElement(Text6, { bold: true }, step.metadata?.toolName || "unknown")), step.metadata?.toolInput && /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, JSON.stringify(step.metadata.toolInput, null, 2)))), step.type === "observation" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, "\u{1F4CA} Observation: ")), /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, null, step.content))), step.type === "final_answer" && /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green", bold: true }, "\u2705 Final Answer:", " ")), /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, null, step.content)), step.metadata?.tokenUsage && /* @__PURE__ */ React6.createElement(Box5, { paddingLeft: 2 }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "(", step.metadata.tokenUsage.total, " tokens)"))))), !steps.some((s) => s.type === "final_answer") && /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, /* @__PURE__ */ React6.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React6.createElement(Text6, null, " ", steps.length === 0 ? "Thinking..." : "Processing...")));
 });
 
 // src/store/index.ts
@@ -307,6 +688,12 @@ var useCliStore = create((set) => ({
   // Session state
   session: null,
   setSession: (session) => set({ session }),
+  clearMessages: () => set((state) => ({
+    session: state.session ? {
+      ...state.session,
+      messages: []
+    } : null
+  })),
   // UI state
   isThinking: false,
   setIsThinking: (thinking) => set({ isThinking: thinking }),
@@ -324,32 +711,32 @@ var useCliStore = create((set) => ({
 }));
 
 // src/components/AgentThinking.tsx
-var AgentThinking = React5.memo(function AgentThinking2() {
+var AgentThinking = React7.memo(function AgentThinking2() {
   const isThinking = useCliStore((state) => state.isThinking);
   const agentSteps = useCliStore((state) => state.agentSteps);
   if (!isThinking) {
     return null;
   }
-  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React5.createElement(ThoughtStream, { steps: agentSteps }));
+  return /* @__PURE__ */ React7.createElement(Box6, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React7.createElement(ThoughtStream, { steps: agentSteps }));
 });
 
 // src/components/PermissionPrompt.tsx
-import React6 from "react";
-import { Box as Box6, Text as Text5 } from "ink";
+import React8 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
 import SelectInput from "ink-select-input";
 function renderDiffPreview(preview) {
   const lines = preview.split("\n");
   return lines.map((line, index) => {
     if (line.startsWith("+")) {
-      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "green" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "green" }, line);
     }
     if (line.startsWith("-")) {
-      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "red" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "red" }, line);
     }
     if (line.startsWith("@@")) {
-      return /* @__PURE__ */ React6.createElement(Text5, { key: index, color: "cyan" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "cyan" }, line);
     }
-    return /* @__PURE__ */ React6.createElement(Text5, { key: index, dimColor: true }, line);
+    return /* @__PURE__ */ React8.createElement(Text7, { key: index, dimColor: true }, line);
   });
 }
 function PermissionPrompt({
@@ -369,7 +756,121 @@ function PermissionPrompt({
     { label: "\u2717 Deny", value: "deny" }
   ];
   const argsString = typeof args === "string" ? args : JSON.stringify(args, null, 2);
-  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Tool: "), /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "Action: "), /* @__PURE__ */ React6.createElement(Text5, null, toolDescription)), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Arguments:"), /* @__PURE__ */ React6.createElement(Box6, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { bold: true }, "Preview:"), /* @__PURE__ */ React6.createElement(Box6, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(Text5, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
+  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Tool: "), /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Action: "), /* @__PURE__ */ React8.createElement(Text7, null, toolDescription)), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Arguments:"), /* @__PURE__ */ React8.createElement(Box7, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Preview:"), /* @__PURE__ */ React8.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
+}
+
+// src/utils/processFileReferences.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/utils/constants.ts
+var NAME_SUFFIXES = ["jr", "sr", "ii", "iii", "iv", "v", "phd", "md", "esq"];
+function isNameSuffix(value) {
+  return NAME_SUFFIXES.includes(value);
+}
+
+// src/utils/processFileReferences.ts
+var FILE_REFERENCE_REGEX = /(?:^|\s)@([^\s@]+)/g;
+function looksLikeFilePath(ref) {
+  if (ref.includes("/") || ref.includes(path2.sep)) {
+    return true;
+  }
+  const extensionMatch = /\.(\w+)$/.exec(ref);
+  if (extensionMatch) {
+    const ext = extensionMatch[1].toLowerCase();
+    if (isNameSuffix(ext)) {
+      return false;
+    }
+    if (ext.length > 10) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function extractFileReferences(message) {
+  const references = [];
+  const regex = /(?:^|\s)@([^\s@]+)/g;
+  let match;
+  while ((match = regex.exec(message)) !== null) {
+    const ref = match[1];
+    if (looksLikeFilePath(ref)) {
+      references.push(ref);
+    }
+  }
+  return references;
+}
+function readFileContents(filePath) {
+  const cwd = process.cwd();
+  const absolutePath = path2.resolve(cwd, filePath);
+  if (!isPathWithinCwd(filePath)) {
+    return { error: `Security: Path "${filePath}" is outside the current working directory` };
+  }
+  if (!fs2.existsSync(absolutePath)) {
+    return { error: `File not found: "${filePath}"` };
+  }
+  const stats = fs2.statSync(absolutePath);
+  if (stats.isDirectory()) {
+    try {
+      const entries = fs2.readdirSync(absolutePath);
+      const fileCount = entries.length;
+      return {
+        content: `(Directory with ${fileCount} items. Use file tools to explore if needed.)`,
+        size: 0
+      };
+    } catch (err) {
+      return { error: `Cannot read directory "${filePath}": ${err instanceof Error ? err.message : "Unknown error"}` };
+    }
+  }
+  if (stats.size > MAX_FILE_SIZE) {
+    return {
+      error: `File too large: "${filePath}" is ${formatFileSize(stats.size)} (max ${formatFileSize(MAX_FILE_SIZE)})`
+    };
+  }
+  if (isBinaryFile(filePath)) {
+    return { error: `Binary file: "${filePath}" cannot be included as text content` };
+  }
+  try {
+    const content = fs2.readFileSync(absolutePath, "utf-8");
+    return { content, size: stats.size };
+  } catch (err) {
+    return { error: `Cannot read file "${filePath}": ${err instanceof Error ? err.message : "Unknown error"}` };
+  }
+}
+function formatFileBlock(filePath, content, size, isDirectory) {
+  if (isDirectory) {
+    return `
+--- Directory Reference: ${filePath} ---
+${content}
+--- End of ${filePath} ---`;
+  }
+  return `
+--- Referenced File: ${filePath} (${formatFileSize(size)}) ---
+${content}
+--- End of ${filePath} ---`;
+}
+async function processFileReferences(message) {
+  const references = extractFileReferences(message);
+  const errors = [];
+  const fileBlocks = [];
+  for (const ref of references) {
+    const result = readFileContents(ref);
+    if ("error" in result) {
+      errors.push(result.error);
+      continue;
+    }
+    const isDirectory = result.size === 0 && result.content.startsWith("(Directory");
+    fileBlocks.push(formatFileBlock(ref, result.content, result.size, isDirectory));
+  }
+  if (fileBlocks.length === 0) {
+    return { content: message, errors };
+  }
+  const processedContent = message + "\n" + fileBlocks.join("\n");
+  return { content: processedContent, errors };
+}
+function hasFileReferences(message) {
+  FILE_REFERENCE_REGEX.lastIndex = 0;
+  return FILE_REFERENCE_REGEX.test(message);
 }
 
 // src/components/App.tsx
@@ -382,7 +883,7 @@ function App({ onMessage, onCommand, onPermissionResponse, commandHistory = [] }
   const permissionPrompt = useCliStore((state) => state.permissionPrompt);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
-  const handleSubmit = React7.useCallback(
+  const handleSubmit = React9.useCallback(
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
@@ -393,14 +894,25 @@ function App({ onMessage, onCommand, onPermissionResponse, commandHistory = [] }
       }
       setIsThinking(true);
       try {
-        await onMessage(trimmed);
+        let messageToSend = trimmed;
+        if (hasFileReferences(trimmed)) {
+          const processed = await processFileReferences(trimmed);
+          messageToSend = processed.content;
+          if (processed.errors.length > 0) {
+            const errorBlock = processed.errors.map((e) => `[Warning: ${e}]`).join("\n");
+            messageToSend = `${messageToSend}
+
+${errorBlock}`;
+          }
+        }
+        await onMessage(messageToSend);
       } finally {
         setIsThinking(false);
       }
     },
     [onMessage, onCommand, setIsThinking]
   );
-  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), permissionPrompt ? /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React7.createElement(
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens }), permissionPrompt ? /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -409,39 +921,39 @@ function App({ onMessage, onCommand, onPermissionResponse, commandHistory = [] }
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )) : /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React7.createElement(Box7, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React7.createElement(MessageItem, { message }))), /* @__PURE__ */ React7.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React7.createElement(Box7, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "yellow", bold: true }, "\u26A0\uFE0F Press Ctrl+C again to exit")), /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React7.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
+  )) : /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React9.createElement(Box8, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(MessageItem, { message }))), /* @__PURE__ */ React9.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React9.createElement(Box8, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, "\u26A0\uFE0F Press Ctrl+C again to exit")), /* @__PURE__ */ React9.createElement(Box8, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React9.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
 }
 function MessageItem({ message }) {
-  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text6, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React7.createElement(Text6, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React9.createElement(Text8, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
     if (step.type === "thought") {
-      return /* @__PURE__ */ React7.createElement(Box7, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   ${step.content.slice(0, 200)}${step.content.length > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React9.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `   ${step.content.slice(0, 200)}${step.content.length > 200 ? "..." : ""}`));
     }
     if (step.type === "action") {
       const toolName = step.metadata?.toolName || "unknown";
       const toolInput = step.metadata?.toolInput;
       const observationStep = message.metadata.steps[idx + 1];
       const result = observationStep?.type === "observation" ? observationStep.content : null;
-      return /* @__PURE__ */ React7.createElement(Box7, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+      return /* @__PURE__ */ React9.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
     }
     return null;
-  }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React7.createElement(Box7, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
+  }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
 }
 
 // src/components/MessageList.tsx
-import React8 from "react";
-import { Box as Box8, Text as Text7 } from "ink";
+import React10 from "react";
+import { Box as Box9, Text as Text9 } from "ink";
 function stripThinkingTags(content) {
   return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-var MessageList = React8.memo(
+var MessageList = React10.memo(
   function MessageList2({ messages }) {
     if (messages.length === 0) {
-      return /* @__PURE__ */ React8.createElement(Box8, { paddingY: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "No messages yet. Type a message to start!"));
+      return /* @__PURE__ */ React10.createElement(Box9, { paddingY: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No messages yet. Type a message to start!"));
     }
-    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React8.createElement(Box8, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React8.createElement(Text7, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+    return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React10.createElement(Box9, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React10.createElement(Text9, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
       if (step.type === "thought") {
-        return /* @__PURE__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React8.createElement(
-          Text7,
+        return /* @__PURE__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React10.createElement(
+          Text9,
           {
             dimColor: true
           },
@@ -453,10 +965,10 @@ var MessageList = React8.memo(
         const toolInput = step.metadata?.toolInput;
         const observationStep = message.metadata.steps[idx + 1];
         const result = observationStep?.type === "observation" ? observationStep.content : null;
-        return /* @__PURE__ */ React8.createElement(Box8, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+        return /* @__PURE__ */ React10.createElement(Box9, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
       }
       return null;
-    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React8.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
+    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
   },
   (prevProps, nextProps) => {
     if (prevProps.messages.length !== nextProps.messages.length) {
@@ -467,8 +979,8 @@ var MessageList = React8.memo(
 );
 
 // src/components/LoginFlow.tsx
-import React9, { useState as useState2, useEffect as useEffect2 } from "react";
-import { Box as Box9, Text as Text8 } from "ink";
+import React11, { useState as useState3, useEffect as useEffect2 } from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
 import open from "open";
@@ -578,16 +1090,16 @@ var OAuthClient = class {
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
 };
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState2("initiating");
-  const [deviceFlow, setDeviceFlow] = useState2(null);
-  const [statusMessage, setStatusMessage] = useState2("Initiating device authorization...");
-  const [error, setError] = useState2(null);
+  const [status, setStatus] = useState3("initiating");
+  const [deviceFlow, setDeviceFlow] = useState3(null);
+  const [statusMessage, setStatusMessage] = useState3("Initiating device authorization...");
+  const [error, setError] = useState3(null);
   useEffect2(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
@@ -631,31 +1143,31 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     }
   }, [deviceFlow, status]);
   if (status === "initiating") {
-    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, /* @__PURE__ */ React9.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, /* @__PURE__ */ React11.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
   if (status === "error") {
-    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { color: "red" }, error)));
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { color: "red" }, error)));
   }
   if (status === "success") {
-    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "You can now use B4M CLI with your account.")));
+    return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, null, "And enter this code when prompted:")), /* @__PURE__ */ React9.createElement(Box9, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, /* @__PURE__ */ React9.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React9.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, null, "And enter this code when prompted:")), /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "cyan" }, /* @__PURE__ */ React11.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
-import { promises as fs } from "fs";
-import path from "path";
+import { promises as fs3 } from "fs";
+import path3 from "path";
 import { homedir } from "os";
 var SessionStore = class {
   constructor(basePath) {
-    this.basePath = basePath || path.join(homedir(), ".bike4mind", "sessions");
+    this.basePath = basePath || path3.join(homedir(), ".bike4mind", "sessions");
   }
   /**
    * Initialize storage directory
    */
   async init() {
     try {
-      await fs.mkdir(this.basePath, { recursive: true });
+      await fs3.mkdir(this.basePath, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize session storage:", error);
       throw error;
@@ -666,9 +1178,9 @@ var SessionStore = class {
    */
   async save(session) {
     await this.init();
-    const filePath = path.join(this.basePath, `${session.id}.json`);
+    const filePath = path3.join(this.basePath, `${session.id}.json`);
     try {
-      await fs.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
+      await fs3.writeFile(filePath, JSON.stringify(session, null, 2), "utf-8");
     } catch (error) {
       console.error("Failed to save session:", error);
       throw error;
@@ -678,9 +1190,9 @@ var SessionStore = class {
    * Load a session from disk by ID
    */
   async load(id) {
-    const filePath = path.join(this.basePath, `${id}.json`);
+    const filePath = path3.join(this.basePath, `${id}.json`);
     try {
-      const data = await fs.readFile(filePath, "utf-8");
+      const data = await fs3.readFile(filePath, "utf-8");
       return JSON.parse(data);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -704,12 +1216,12 @@ var SessionStore = class {
   async list() {
     await this.init();
     try {
-      const files = await fs.readdir(this.basePath);
+      const files = await fs3.readdir(this.basePath);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       const sessions = await Promise.all(
         jsonFiles.map(async (file) => {
-          const filePath = path.join(this.basePath, file);
-          const data = await fs.readFile(filePath, "utf-8");
+          const filePath = path3.join(this.basePath, file);
+          const data = await fs3.readFile(filePath, "utf-8");
           return JSON.parse(data);
         })
       );
@@ -723,9 +1235,9 @@ var SessionStore = class {
    * Delete a session
    */
   async delete(id) {
-    const filePath = path.join(this.basePath, `${id}.json`);
+    const filePath = path3.join(this.basePath, `${id}.json`);
     try {
-      await fs.unlink(filePath);
+      await fs3.unlink(filePath);
       return true;
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -761,8 +1273,8 @@ var SessionStore = class {
 };
 
 // src/storage/ConfigStore.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
+import { promises as fs4 } from "fs";
+import path4 from "path";
 import { homedir as homedir2 } from "os";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";
@@ -836,15 +1348,15 @@ var DEFAULT_CONFIG = {
 var ConfigStore = class {
   constructor(configPath) {
     this.config = null;
-    this.configPath = configPath || path2.join(homedir2(), ".bike4mind", "config.json");
+    this.configPath = configPath || path4.join(homedir2(), ".bike4mind", "config.json");
   }
   /**
    * Initialize config directory
    */
   async init() {
-    const dir = path2.dirname(this.configPath);
+    const dir = path4.dirname(this.configPath);
     try {
-      await fs2.mkdir(dir, { recursive: true });
+      await fs4.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize config directory:", error);
       throw error;
@@ -859,15 +1371,15 @@ var ConfigStore = class {
     }
     try {
       try {
-        const stats = await fs2.stat(this.configPath);
+        const stats = await fs4.stat(this.configPath);
         const mode = stats.mode & 511;
         if (mode !== 384) {
           console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
-          await fs2.chmod(this.configPath, 384);
+          await fs4.chmod(this.configPath, 384);
         }
       } catch (statError) {
       }
-      const data = await fs2.readFile(this.configPath, "utf-8");
+      const data = await fs4.readFile(this.configPath, "utf-8");
       const rawConfig = JSON.parse(data);
       if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
         const oldApiConfig = rawConfig.apiConfig;
@@ -940,8 +1452,8 @@ var ConfigStore = class {
       throw new Error("No configuration to save");
     }
     try {
-      await fs2.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-      await fs2.chmod(this.configPath, 384);
+      await fs4.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+      await fs4.chmod(this.configPath, 384);
     } catch (error) {
       console.error("Failed to save config:", error);
       throw error;
@@ -1088,22 +1600,22 @@ var ConfigStore = class {
 };
 
 // src/storage/CommandHistoryStore.ts
-import { promises as fs3 } from "fs";
-import path3 from "path";
+import { promises as fs5 } from "fs";
+import path5 from "path";
 import { homedir as homedir3 } from "os";
 var MAX_HISTORY_ENTRIES = 1e3;
 var CommandHistoryStore = class {
   constructor(historyPath) {
     this.history = null;
-    this.historyPath = historyPath || path3.join(homedir3(), ".bike4mind", "history.jsonl");
+    this.historyPath = historyPath || path5.join(homedir3(), ".bike4mind", "history.jsonl");
   }
   /**
    * Initialize history directory
    */
   async init() {
-    const dir = path3.dirname(this.historyPath);
+    const dir = path5.dirname(this.historyPath);
     try {
-      await fs3.mkdir(dir, { recursive: true });
+      await fs5.mkdir(dir, { recursive: true });
     } catch (error) {
       console.error("Failed to initialize history directory:", error);
       throw error;
@@ -1118,7 +1630,7 @@ var CommandHistoryStore = class {
       return this.history;
     }
     try {
-      const data = await fs3.readFile(this.historyPath, "utf-8");
+      const data = await fs5.readFile(this.historyPath, "utf-8");
       const lines = data.trim().split("\n").filter((line) => line.length > 0);
       const entries = lines.map((line) => {
         try {
@@ -1155,7 +1667,7 @@ var CommandHistoryStore = class {
     };
     await this.init();
     const line = JSON.stringify(entry) + "\n";
-    await fs3.appendFile(this.historyPath, line, "utf-8");
+    await fs5.appendFile(this.historyPath, line, "utf-8");
     this.history = [command, ...this.history || []];
     if (this.history.length > MAX_HISTORY_ENTRIES) {
       await this.trim();
@@ -1178,7 +1690,7 @@ var CommandHistoryStore = class {
       };
       return JSON.stringify(entry);
     }).join("\n");
-    await fs3.writeFile(this.historyPath, lines + "\n", "utf-8");
+    await fs5.writeFile(this.historyPath, lines + "\n", "utf-8");
     this.history = trimmedCommands;
   }
   /**
@@ -1186,7 +1698,7 @@ var CommandHistoryStore = class {
    */
   async clear() {
     try {
-      await fs3.unlink(this.historyPath);
+      await fs5.unlink(this.historyPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -1960,7 +2472,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs4, { unlinkSync } from "fs";
+import fs6, { unlinkSync } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -3646,8 +4158,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path11;
+    const path13 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path13;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -4831,8 +5343,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path11 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path11;
+  const path13 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path13;
 }
 async function updateQuestAndReturnMarkdown2(storedImagePath, context) {
   await context.onFinish?.("edit_image", storedImagePath);
@@ -6669,33 +7181,33 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs5 } from "fs";
-import { existsSync, statSync } from "fs";
-import path4 from "path";
-var MAX_FILE_SIZE = 10 * 1024 * 1024;
+import { promises as fs7 } from "fs";
+import { existsSync as existsSync2, statSync as statSync3 } from "fs";
+import path6 from "path";
+var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", maxLines } = params;
-  const normalizedPath = path4.normalize(filePath);
-  const resolvedPath = path4.resolve(process.cwd(), normalizedPath);
-  const cwd = path4.resolve(process.cwd());
+  const normalizedPath = path6.normalize(filePath);
+  const resolvedPath = path6.resolve(process.cwd(), normalizedPath);
+  const cwd = path6.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync(resolvedPath)) {
+  if (!existsSync2(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const stats = statSync(resolvedPath);
+  const stats = statSync3(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
-  if (stats.size > MAX_FILE_SIZE) {
-    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE / 1024 / 1024}MB)`);
+  if (stats.size > MAX_FILE_SIZE2) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE2 / 1024 / 1024}MB)`);
   }
   const isBinary = await checkIfBinary(resolvedPath);
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs5.readFile(resolvedPath, encoding);
+  const content = await fs7.readFile(resolvedPath, encoding);
   if (maxLines && typeof content === "string") {
     const lines = content.split("\n");
     if (lines.length > maxLines) {
@@ -6710,7 +7222,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs5.open(filePath, "r");
+  const fd = await fs7.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -6727,7 +7239,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync(path4.resolve(process.cwd(), path4.normalize(params.path)));
+        const stats = statSync3(path6.resolve(process.cwd(), path6.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -6766,25 +7278,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs6 } from "fs";
-import { existsSync as existsSync2 } from "fs";
-import path5 from "path";
+import { promises as fs8 } from "fs";
+import { existsSync as existsSync3 } from "fs";
+import path7 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path5.normalize(filePath);
-  const resolvedPath = path5.resolve(process.cwd(), normalizedPath);
-  const cwd = path5.resolve(process.cwd());
+  const normalizedPath = path7.normalize(filePath);
+  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
+  const cwd = path7.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync2(resolvedPath);
+  const fileExists = existsSync3(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path5.dirname(resolvedPath);
-    await fs6.mkdir(dir, { recursive: true });
+    const dir = path7.dirname(resolvedPath);
+    await fs8.mkdir(dir, { recursive: true });
   }
-  await fs6.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs6.stat(resolvedPath);
+  await fs8.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs8.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -6795,7 +7307,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync2(path5.resolve(process.cwd(), path5.normalize(params.path)));
+      const fileExists = existsSync3(path7.resolve(process.cwd(), path7.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -6836,8 +7348,8 @@ var createFileTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { readdir } from "fs/promises";
-import { statSync as statSync2 } from "fs";
-import path6 from "path";
+import { statSync as statSync4 } from "fs";
+import path8 from "path";
 function matchGlob(filePath, pattern) {
   let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
   regexPattern = regexPattern.replace(/\{\{GLOBSTAR\}\}\//g, "(.*/)?").replace(/\/\{\{GLOBSTAR\}\}/g, "(/.*)?").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -6855,8 +7367,8 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
       if (!includeHidden && entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path6.join(basePath, entry.name) : entry.name;
-      const fullPath = path6.join(dir, entry.name);
+      const relativePath = basePath ? path8.join(basePath, entry.name) : entry.name;
+      const fullPath = path8.join(dir, entry.name);
       if (matchGlob(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -6872,7 +7384,7 @@ async function walkDir(dir, pattern, includeHidden, maxResults, basePath = "") {
 async function listFiles(params) {
   const { pattern, cwd: relativeCwd, includeHidden = false, maxResults = 1e3 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path6.resolve(baseCwd, path6.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path8.resolve(baseCwd, path8.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot list files outside of current working directory`);
   }
@@ -6883,8 +7395,8 @@ async function listFiles(params) {
   const filesInfo = [];
   for (const match of matches) {
     try {
-      const fullPath = path6.join(targetCwd, match);
-      const stats = statSync2(fullPath);
+      const fullPath = path8.join(targetCwd, match);
+      const stats = statSync4(fullPath);
       filesInfo.push({
         path: match,
         size: stats.size,
@@ -6965,9 +7477,9 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { readdir as readdir2 } from "fs/promises";
-import { readFileSync, statSync as statSync3 } from "fs";
-import path7 from "path";
-var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+import { readFileSync as readFileSync2, statSync as statSync5 } from "fs";
+import path9 from "path";
+var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 function matchGlob2(filePath, pattern) {
   const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
   const regex = new RegExp(`^${regexPattern}$`);
@@ -6984,8 +7496,8 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const relativePath = basePath ? path7.join(basePath, entry.name) : entry.name;
-      const fullPath = path7.join(dir, entry.name);
+      const relativePath = basePath ? path9.join(basePath, entry.name) : entry.name;
+      const fullPath = path9.join(dir, entry.name);
       if (matchGlob2(relativePath, pattern)) {
         matches.push(relativePath);
       }
@@ -6998,10 +7510,10 @@ async function walkDir2(dir, pattern, maxResults, basePath = "") {
   }
   return matches;
 }
-async function searchFiles(params) {
+async function searchFiles2(params) {
   const { pattern, filePattern = "**/*", cwd: relativeCwd, caseSensitive = false, maxResults = 100, contextLines = 0 } = params;
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path7.resolve(baseCwd, path7.normalize(relativeCwd)) : baseCwd;
+  const targetCwd = relativeCwd ? path9.resolve(baseCwd, path9.normalize(relativeCwd)) : baseCwd;
   if (!targetCwd.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search files outside of current working directory`);
   }
@@ -7015,13 +7527,13 @@ async function searchFiles(params) {
   const filesToSearch = await walkDir2(targetCwd, filePattern, 1e4);
   const filteredFiles = [];
   for (const match of filesToSearch) {
-    const fullPath = path7.join(targetCwd, match);
+    const fullPath = path9.join(targetCwd, match);
     try {
-      const stats = statSync3(fullPath);
-      if (stats.isDirectory() || stats.size > MAX_FILE_SIZE2) {
+      const stats = statSync5(fullPath);
+      if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
         continue;
       }
-      if (isBinaryFile(fullPath)) {
+      if (isBinaryFile2(fullPath)) {
         continue;
       }
       filteredFiles.push(match);
@@ -7039,9 +7551,9 @@ async function searchFiles(params) {
       break;
     }
     filesSearched++;
-    const fullPath = path7.join(targetCwd, file);
+    const fullPath = path9.join(targetCwd, file);
     try {
-      const content = readFileSync(fullPath, "utf-8");
+      const content = readFileSync2(fullPath, "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (matches.length >= maxResults) {
@@ -7105,7 +7617,7 @@ ${match.context.after.map((l) => `     ${l}`).join("\n")}`;
   }).join("\n");
   return `${summary}${patternInfo}${cwdInfo}${matchesList}`;
 }
-function isBinaryFile(filePath) {
+function isBinaryFile2(filePath) {
   try {
     const buffer = Buffer.alloc(8192);
     const fd = __require("fs").openSync(filePath, "r");
@@ -7128,7 +7640,7 @@ var grepSearchTool = {
         cwd: params.cwd || "."
       });
       try {
-        const result = await searchFiles(params);
+        const result = await searchFiles2(params);
         context.logger.info("\u2705 GrepSearch: Success");
         return result;
       } catch (error) {
@@ -7174,31 +7686,31 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs7 } from "fs";
-import { existsSync as existsSync3, statSync as statSync4 } from "fs";
-import path8 from "path";
+import { promises as fs9 } from "fs";
+import { existsSync as existsSync4, statSync as statSync6 } from "fs";
+import path10 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path8.normalize(filePath);
-  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
-  const cwd = path8.resolve(process.cwd());
+  const normalizedPath = path10.normalize(filePath);
+  const resolvedPath = path10.resolve(process.cwd(), normalizedPath);
+  const cwd = path10.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync3(resolvedPath)) {
+  if (!existsSync4(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
-  const stats = statSync4(resolvedPath);
+  const stats = statSync6(resolvedPath);
   const isDirectory = stats.isDirectory();
   const size = stats.size;
   if (isDirectory && !recursive) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs7.rm(resolvedPath, { recursive: true, force: true });
+    await fs9.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs7.unlink(resolvedPath);
+    await fs9.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -7208,8 +7720,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path8.resolve(process.cwd(), path8.normalize(params.path));
-      const isDirectory = existsSync3(resolvedPath) && statSync4(resolvedPath).isDirectory();
+      const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
+      const isDirectory = existsSync4(resolvedPath) && statSync6(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -7499,10 +8011,10 @@ import jwt2 from "jsonwebtoken";
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync4(args.path)) {
+    if (!existsSync5(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -7532,10 +8044,10 @@ ${preview}${hasMore ? `
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync4(args.path)) {
+    if (!existsSync5(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs9) => fs9.stat(args.path));
+    const stats = await import("fs/promises").then((fs11) => fs11.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -7551,21 +8063,21 @@ var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path11) {
+  async download(path13) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path11) {
+  async delete(path13) {
   }
-  async getSignedUrl(path11) {
-    return `/tmp/${path11}`;
+  async getSignedUrl(path13) {
+    return `/tmp/${path13}`;
   }
-  getPublicUrl(path11) {
-    return `/tmp/${path11}`;
+  getPublicUrl(path13) {
+    return `/tmp/${path13}`;
   }
-  async getPreview(path11) {
-    return `/tmp/${path11}`;
+  async getPreview(path13) {
+    return `/tmp/${path13}`;
   }
-  async getMetadata(path11) {
+  async getMetadata(path13) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -7891,8 +8403,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/Logger.ts
-import fs8 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path11 from "path";
 import os from "os";
 var Logger2 = class _Logger {
   constructor() {
@@ -7915,9 +8427,9 @@ var Logger2 = class _Logger {
    */
   async initialize(sessionId) {
     this.sessionId = sessionId;
-    const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
-    await fs8.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path9.join(debugDir, `${sessionId}.txt`);
+    const debugDir = path11.join(os.homedir(), ".bike4mind", "debug");
+    await fs10.mkdir(debugDir, { recursive: true });
+    this.logFilePath = path11.join(debugDir, `${sessionId}.txt`);
     await this.writeToFile("INFO", "=== CLI SESSION START ===");
   }
   /**
@@ -7981,7 +8493,7 @@ var Logger2 = class _Logger {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
       const logEntry = `[${timestamp}] [${level}] ${message}
 `;
-      await fs8.appendFile(this.logFilePath, logEntry, "utf-8");
+      await fs10.appendFile(this.logFilePath, logEntry, "utf-8");
     } catch (error) {
       console.error("File logging failed:", error);
     }
@@ -8127,15 +8639,15 @@ var Logger2 = class _Logger {
   async cleanupOldLogs() {
     if (!this.fileLoggingEnabled) return;
     try {
-      const debugDir = path9.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs8.readdir(debugDir);
+      const debugDir = path11.join(os.homedir(), ".bike4mind", "debug");
+      const files = await fs10.readdir(debugDir);
       const now = Date.now();
       const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
       for (const file of files) {
-        const filePath = path9.join(debugDir, file);
-        const stats = await fs8.stat(filePath);
+        const filePath = path11.join(debugDir, file);
+        const stats = await fs10.stat(filePath);
         if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs8.unlink(filePath);
+          await fs10.unlink(filePath);
         }
       }
     } catch (error) {
@@ -8148,8 +8660,8 @@ var logger = Logger2.getInstance();
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path10 from "path";
-import { existsSync as existsSync5, readdirSync } from "fs";
+import path12 from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -8174,20 +8686,20 @@ var MCPClient = class {
       const root = process.env.INIT_CWD || process.cwd();
       const candidatePaths = [
         // When running from SST Lambda with node_modules structure (copyFiles)
-        path10.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+        path12.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda deployed environment (/var/task)
-        path10.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path12.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-        path10.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path12.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-        path10.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path12.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
         // Original paths (backward compatibility)
-        path10.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-        path10.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+        path12.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+        path12.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
       ];
-      const serverScriptPath = candidatePaths.find((p) => existsSync5(p));
+      const serverScriptPath = candidatePaths.find((p) => existsSync6(p));
       if (!serverScriptPath) {
-        const getDirectories = (source) => readdirSync(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+        const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
         console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
         console.error(`[MCP] Available directories in ${root}:`, getDirectories(root));
         throw new Error(`MCP Server script path not found for ${this.serverName}. Root: ${root}, Available dirs: ${getDirectories(root).join(", ")}`);
@@ -8216,7 +8728,7 @@ var MCPClient = class {
         }
       };
       await this.mcp.connect(this.transport);
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, 100));
       const toolsResult = await this.mcp.listTools();
       this.tools = toolsResult.tools.map((tool) => {
         return {
@@ -8399,7 +8911,7 @@ var ServerLlmBackend = class {
    */
   async complete(model, messages, options, callback) {
     logger.debug(`[ServerLlmBackend] Starting complete() with model: ${model}`);
-    return new Promise(async (resolve, reject) => {
+    return new Promise(async (resolve3, reject) => {
       try {
         logger.debug("[ServerLlmBackend] Making streaming request...");
         const response = await this.makeStreamingRequest(model, messages, options);
@@ -8429,15 +8941,15 @@ var ServerLlmBackend = class {
                   reject(err);
                 }).then(() => {
                   logger.debug("[ServerLlmBackend] Callback completed, resolving");
-                  resolve();
+                  resolve3();
                 });
               } else if (cleanedText) {
                 callback([cleanedText], lastUsageInfo).catch((err) => {
                   logger.error("[ServerLlmBackend] Callback error:", err);
                   reject(err);
-                }).then(() => resolve());
+                }).then(() => resolve3());
               } else {
-                resolve();
+                resolve3();
               }
               return;
             }
@@ -8497,7 +9009,7 @@ var ServerLlmBackend = class {
         response.data.on("end", () => {
           if (!receivedDone) {
             logger.debug("[ServerLlmBackend] Stream ended without [DONE], resolving anyway");
-            resolve();
+            resolve3();
           } else {
             logger.debug("[ServerLlmBackend] Stream ended, [DONE] handler will resolve");
           }
@@ -8761,10 +9273,13 @@ var ApiClient = class {
   }
 };
 
+// src/index.tsx
+import { isAxiosError as isAxiosError2 } from "axios";
+
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.1-quest-file-uploads.17007+7890a35e3",
+  version: "0.2.3-basic-cli-shortcuts.17058+9fe0019f0",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -8775,6 +9290,9 @@ var package_default = {
   },
   homepage: "https://github.com/bike4mind/lumina5#readme",
   bugs: "https://github.com/bike4mind/lumina5/issues",
+  publishConfig: {
+    access: "public"
+  },
   keywords: [
     "cli",
     "ai",
@@ -8795,6 +9313,8 @@ var package_default = {
     dev: "tsx src/index.tsx",
     build: "tsup",
     typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
     start: "node dist/index.js",
     prepublishOnly: "pnpm build"
   },
@@ -8861,10 +9381,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.36.1-quest-file-uploads.17007+7890a35e3",
-    "@bike4mind/mcp": "1.19.4-quest-file-uploads.17007+7890a35e3",
-    "@bike4mind/services": "2.29.1-quest-file-uploads.17007+7890a35e3",
-    "@bike4mind/utils": "2.0.3-quest-file-uploads.17007+7890a35e3",
+    "@bike4mind/common": "2.37.1-basic-cli-shortcuts.17058+9fe0019f0",
+    "@bike4mind/mcp": "1.19.5-basic-cli-shortcuts.17058+9fe0019f0",
+    "@bike4mind/services": "2.31.1-basic-cli-shortcuts.17058+9fe0019f0",
+    "@bike4mind/utils": "2.0.4-basic-cli-shortcuts.17058+9fe0019f0",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -8873,11 +9393,17 @@ var package_default = {
     "@types/yargs": "^17.0.32",
     tsup: "^8.5.1",
     tsx: "^4.21.0",
-    typescript: "^5.9.3"
+    typescript: "^5.9.3",
+    vitest: "^3.2.4"
   },
-  gitHead: "7890a35e398acb5486db66d00e5f4173ded0e74e"
+  gitHead: "9fe0019f0bca23b4ffe22a4d9504a0e02054f48d"
 };
 
+// src/config/constants.ts
+var USAGE_DAYS = 30;
+var MODEL_NAME_COLUMN_WIDTH = 18;
+var USAGE_CACHE_TTL = 5 * 60 * 1e3;
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -8888,9 +9414,10 @@ process.on("warning", (warning) => {
 });
 var exitTimestamp = null;
 var EXIT_TIMEOUT_MS = 2e3;
+var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
-  const [state, setState] = useState3({
+  const [state, setState] = useState4({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
@@ -8900,9 +9427,9 @@ function CliApp() {
     permissionManager: null,
     permissionPrompt: null
   });
-  const [isInitialized, setIsInitialized] = useState3(false);
-  const [initError, setInitError] = useState3(null);
-  const [commandHistory, setCommandHistory] = useState3([]);
+  const [isInitialized, setIsInitialized] = useState4(false);
+  const [initError, setInitError] = useState4(null);
+  const [commandHistory, setCommandHistory] = useState4([]);
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setExitRequested = useCliStore((state2) => state2.setExitRequested);
@@ -8927,14 +9454,14 @@ function CliApp() {
     }
     await Promise.race([
       Promise.all(cleanupTasks),
-      new Promise((resolve) => setTimeout(resolve, 500))
+      new Promise((resolve3) => setTimeout(resolve3, 500))
       // 500ms timeout
     ]);
     setTimeout(() => {
       process.exit(0);
     }, 100);
   }, [state.session, state.sessionStore, state.mcpManager, state.agent]);
-  useInput2((input, key) => {
+  useInput3((input, key) => {
     if (key.ctrl && input === "c") {
       const now = Date.now();
       if (exitTimestamp && now - exitTimestamp < EXIT_TIMEOUT_MS) {
@@ -9061,9 +9588,9 @@ function CliApp() {
       };
       const permissionManager = new PermissionManager(config.trustedTools || []);
       const promptFn = (toolName, args, preview) => {
-        return new Promise((resolve) => {
+        return new Promise((resolve3) => {
           const canBeTrusted = permissionManager.canBeTrusted(toolName);
-          const prompt = { toolName, args, preview, canBeTrusted, resolve };
+          const prompt = { toolName, args, preview, canBeTrusted, resolve: resolve3 };
           setState((prev) => ({
             ...prev,
             permissionManager,
@@ -9137,7 +9664,7 @@ Remember: Use context from previous messages to understand follow-up questions.`
         llm,
         model: modelInfo.id,
         tools: allTools,
-        maxIterations: 3,
+        maxIterations: 10,
         maxTokens: config.preferences.maxTokens,
         temperature: config.preferences.temperature,
         systemPrompt: cliSystemPrompt
@@ -9252,6 +9779,7 @@ Available commands:
   /login - Authenticate with your B4M account
   /logout - Clear authentication and sign out
   /whoami - Show current authenticated user
+  /usage - Show credit usage and balance
   /save <name> - Save current session
   /sessions - List saved sessions
   /config - Show configuration
@@ -9422,17 +9950,114 @@ Tool Permissions:
         console.log(`Expires: ${new Date(authTokens.expiresAt).toLocaleString()}`);
         console.log("");
         break;
+      case "usage": {
+        const usageAuthTokens = await state.configStore.getAuthTokens();
+        if (!usageAuthTokens || new Date(usageAuthTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
+          console.log("\nNot authenticated. Run /login to authenticate.\n");
+          return;
+        }
+        console.log("\nFetching usage data...");
+        const now = Date.now();
+        let currentCredits;
+        let transactions;
+        if (usageCache && now - usageCache.timestamp < USAGE_CACHE_TTL) {
+          currentCredits = usageCache.data.currentCredits;
+          transactions = usageCache.data.transactions;
+          console.log("(using cached data)\n");
+        } else {
+          try {
+            const config = await state.configStore.get();
+            const apiBaseURL = getApiUrl(config.apiConfig);
+            const apiClient = new ApiClient(apiBaseURL, state.configStore);
+            const [identifyResponse, transactionsResponse] = await Promise.all([
+              apiClient.get("/api/identify"),
+              apiClient.get(`/api/credits/transactions?days=${USAGE_DAYS}`)
+            ]);
+            currentCredits = identifyResponse.user.currentCredits;
+            transactions = transactionsResponse || [];
+            usageCache = {
+              data: { currentCredits, transactions },
+              timestamp: now
+            };
+          } catch (error) {
+            if (isAxiosError2(error)) {
+              if (error.response?.status === 401) {
+                console.log("\n\u274C Authentication failed. Run /login to re-authenticate.\n");
+              } else if (error.response?.status === 403) {
+                console.log("\n\u274C Access denied. You may not have permission to view usage data.\n");
+              } else if (error.response?.status === 404) {
+                console.log("\n\u274C Usage endpoint not available on this server.\n");
+              } else if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+                console.log("\n\u274C Cannot connect to server. Check your API configuration with /api-info\n");
+              } else {
+                console.log(`
+\u274C Error fetching usage data: ${error.message}
+`);
+              }
+            } else if (error instanceof Error) {
+              console.log(`
+\u274C Error: ${error.message}
+`);
+            } else {
+              console.log("\n\u274C Unexpected error fetching usage data. Please try again.\n");
+            }
+            break;
+          }
+        }
+        const deductTransactions = transactions.filter(
+          (t) => CREDIT_DEDUCT_TRANSACTION_TYPES.includes(t.type)
+        );
+        const totalCreditsUsed = deductTransactions.reduce((sum2, t) => sum2 + Math.abs(t.credits), 0);
+        const dailyBurnRate = Math.round(totalCreditsUsed / USAGE_DAYS);
+        let daysRemainingStr;
+        if (dailyBurnRate === 0) {
+          daysRemainingStr = "N/A (no usage)";
+        } else {
+          const daysRemaining = Math.floor(currentCredits / dailyBurnRate);
+          daysRemainingStr = `~${daysRemaining.toLocaleString()} days`;
+        }
+        const usageByModel = {};
+        for (const t of deductTransactions) {
+          const modelName = t.metadata?.modelName || ("model" in t ? t.model : null) || "Unknown";
+          usageByModel[modelName] = (usageByModel[modelName] || 0) + Math.abs(t.credits);
+        }
+        const sortedModels = Object.entries(usageByModel).sort((a, b) => b[1] - a[1]);
+        console.log("\n Credit Usage Summary");
+        console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+        console.log(`Credits Balance:    ${currentCredits.toLocaleString()}`);
+        console.log(`Daily Burn Rate:    ${dailyBurnRate.toLocaleString()} credits/day`);
+        console.log(`Days Remaining:     ${daysRemainingStr}`);
+        if (currentCredits === 0) {
+          console.log("\n\u26A0\uFE0F  You have no credits remaining.");
+          console.log("\u{1F4A1} Visit bike4mind.io to purchase more credits.\n");
+          break;
+        }
+        if (sortedModels.length > 0) {
+          console.log(`
+Usage by Model (Last ${USAGE_DAYS} days):`);
+          for (const [model, credits] of sortedModels) {
+            const percentage = totalCreditsUsed > 0 ? Math.round(credits / totalCreditsUsed * 100) : 0;
+            const paddedModel = model.padEnd(MODEL_NAME_COLUMN_WIDTH);
+            console.log(`  ${paddedModel}${credits.toLocaleString()} credits (${percentage}%)`);
+          }
+        } else {
+          console.log(`
+No usage data available for the last ${USAGE_DAYS} days.`);
+        }
+        console.log("");
+        break;
+      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
     }
   };
   if (initError) {
-    return /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React10.createElement(Text9, null, initError), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
+    return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React12.createElement(Text11, null, initError), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
   }
   if (state.showLoginFlow) {
     const loginApiUrl = getApiUrl(state.config?.apiConfig);
-    return /* @__PURE__ */ React10.createElement(
+    return /* @__PURE__ */ React12.createElement(
       LoginFlow,
       {
         apiUrl: loginApiUrl,
@@ -9455,9 +10080,9 @@ Tool Permissions:
     );
   }
   if (!isInitialized) {
-    return /* @__PURE__ */ React10.createElement(Box10, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React10.createElement(Text9, null, "\u{1F680} Initializing..."));
+    return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Text11, null, "\u{1F680} Initializing..."));
   }
-  return /* @__PURE__ */ React10.createElement(
+  return /* @__PURE__ */ React12.createElement(
     App,
     {
       onMessage: handleMessage,
@@ -9488,6 +10113,6 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   console.log("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
-render(/* @__PURE__ */ React10.createElement(CliApp, null), {
+render(/* @__PURE__ */ React12.createElement(CliApp, null), {
   exitOnCtrlC: false
 });