wave-code 0.8.4 → 0.9.1

package/src/managers/inputHandlers.ts

@@ -30,18 +30,12 @@ export const handleSubmit = async (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
   callbacks: Partial<InputManagerCallbacks>,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   attachedImagesOverride?: Array<{
     id: number;
     path: string;
     mimeType: string;
   }>,
 ): Promise<void> => {
-  if (isLoading || isCommandRunning) {
-    return;
-  }
-
   if (state.inputText.trim()) {
     const imageRegex = /\[Image #(\d+)\]/g;
     const matches = [...state.inputText.matchAll(imageRegex)];
@@ -60,7 +54,11 @@ export const handleSubmit = async (
     let cleanContent = state.inputText.replace(imageRegex, "").trim();
     cleanContent = expandLongTextPlaceholders(cleanContent, state.longTextMap);
 
-    PromptHistoryManager.addEntry(cleanContent).catch((err: unknown) => {
+    PromptHistoryManager.addEntry(
+      cleanContent,
+      callbacks.sessionId,
+      state.longTextMap,
+    ).catch((err: unknown) => {
       callbacks.logger?.error("Failed to save prompt history", err);
     });
 
@@ -69,7 +67,7 @@ export const handleSubmit = async (
       referencedImages.length > 0 ? referencedImages : undefined,
     );
     dispatch({ type: "CLEAR_INPUT" });
-    callbacks.onResetHistoryNavigation?.();
+    dispatch({ type: "RESET_HISTORY_NAVIGATION" });
     dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
   }
 };
@@ -114,6 +112,72 @@ export const cyclePermissionMode = (
   callbacks.onPermissionModeChange?.(nextMode);
 };
 
+const SELECTOR_TRIGGERS = [
+  {
+    char: "@",
+    type: "ACTIVATE_FILE_SELECTOR",
+    shouldActivate: (char: string, pos: number, text: string) =>
+      char === "@" && (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+  {
+    char: "/",
+    type: "ACTIVATE_COMMAND_SELECTOR",
+    shouldActivate: (
+      char: string,
+      pos: number,
+      text: string,
+      state: InputState,
+    ) =>
+      char === "/" &&
+      !state.showFileSelector &&
+      (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+] as const;
+
+const getProjectedState = (state: InputState, char: string) => {
+  const beforeCursor = state.inputText.substring(0, state.cursorPosition);
+  const afterCursor = state.inputText.substring(state.cursorPosition);
+  const newInputText = beforeCursor + char + afterCursor;
+  const newCursorPosition = state.cursorPosition + char.length;
+  return { newInputText, newCursorPosition };
+};
+
+export const getAtSelectorPosition = (
+  text: string,
+  cursorPosition: number,
+): number => {
+  let i = cursorPosition - 1;
+  while (i >= 0 && !/\s/.test(text[i])) {
+    if (text[i] === "@") {
+      // Check if this @ is at the start or preceded by whitespace
+      if (i === 0 || /\s/.test(text[i - 1])) {
+        return i;
+      }
+      break;
+    }
+    i--;
+  }
+  return -1;
+};
+
+export const getSlashSelectorPosition = (
+  text: string,
+  cursorPosition: number,
+): number => {
+  let i = cursorPosition - 1;
+  while (i >= 0 && !/\s/.test(text[i])) {
+    if (text[i] === "/") {
+      // Check if this / is at the start or preceded by whitespace
+      if (i === 0 || /\s/.test(text[i - 1])) {
+        return i;
+      }
+      break;
+    }
+    i--;
+  }
+  return -1;
+};
+
 export const updateSearchQueriesForActiveSelectors = (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
@@ -133,26 +197,58 @@ export const updateSearchQueriesForActiveSelectors = (
   }
 };
 
-export const handleSpecialCharInput = (
+export const processSelectorInput = (
   state: InputState,
   dispatch: React.Dispatch<InputAction>,
   char: string,
-  cursorPosition: number,
-  inputText: string,
 ): void => {
-  if (char === "@") {
-    dispatch({ type: "ACTIVATE_FILE_SELECTOR", payload: cursorPosition - 1 });
-  } else if (char === "/" && !state.showFileSelector && cursorPosition === 1) {
+  const { newInputText, newCursorPosition } = getProjectedState(state, char);
+
+  const trigger = SELECTOR_TRIGGERS.find((t) =>
+    t.shouldActivate(char, newCursorPosition, newInputText, state),
+  );
+
+  if (trigger) {
     dispatch({
-      type: "ACTIVATE_COMMAND_SELECTOR",
-      payload: cursorPosition - 1,
-    });
+      type: trigger.type,
+      payload: newCursorPosition - 1,
+    } as InputAction);
   } else {
+    const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+    let showFileSelector = state.showFileSelector;
+    let atPosition = state.atPosition;
+    if (atPos !== -1 && !state.showFileSelector) {
+      dispatch({
+        type: "ACTIVATE_FILE_SELECTOR",
+        payload: atPos,
+      });
+      showFileSelector = true;
+      atPosition = atPos;
+    }
+
+    const slashPos = getSlashSelectorPosition(newInputText, newCursorPosition);
+    let showCommandSelector = state.showCommandSelector;
+    let slashPosition = state.slashPosition;
+    if (slashPos !== -1 && !state.showCommandSelector) {
+      dispatch({
+        type: "ACTIVATE_COMMAND_SELECTOR",
+        payload: slashPos,
+      });
+      showCommandSelector = true;
+      slashPosition = slashPos;
+    }
+
     updateSearchQueriesForActiveSelectors(
-      state,
+      {
+        ...state,
+        showFileSelector,
+        atPosition,
+        showCommandSelector,
+        slashPosition,
+      },
       dispatch,
-      inputText,
-      cursorPosition,
+      newInputText,
+      newCursorPosition,
     );
   }
 };
@@ -184,23 +280,19 @@ export const handlePasteInput = (
       char = "!";
     }
 
-    callbacks.onResetHistoryNavigation?.();
+    dispatch({ type: "RESET_HISTORY_NAVIGATION" });
     dispatch({ type: "INSERT_TEXT", payload: char });
 
-    // Calculate new state for special char handling
-    const newCursorPosition = state.cursorPosition + char.length;
-    const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-    const afterCursor = state.inputText.substring(state.cursorPosition);
-    const newInputText = beforeCursor + char + afterCursor;
+    processSelectorInput(state, dispatch, char);
+  }
+};
 
-    handleSpecialCharInput(
-      state,
-      dispatch,
-      char,
-      newCursorPosition,
-      newInputText,
-    );
+export const getWordEnd = (text: string, startPos: number): number => {
+  let i = startPos;
+  while (i < text.length && !/\s/.test(text[i])) {
+    i++;
   }
+  return i;
 };
 
 export const handleCommandSelect = (
@@ -210,9 +302,10 @@ export const handleCommandSelect = (
   command: string,
 ) => {
   if (state.slashPosition >= 0) {
+    const wordEnd = getWordEnd(state.inputText, state.slashPosition);
     const beforeSlash = state.inputText.substring(0, state.slashPosition);
-    const afterQuery = state.inputText.substring(state.cursorPosition);
-    const newInput = beforeSlash + afterQuery;
+    const afterWord = state.inputText.substring(wordEnd);
+    const newInput = beforeSlash + afterWord;
     const newCursorPosition = beforeSlash.length;
 
     dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
@@ -264,10 +357,11 @@ export const handleFileSelect = (
   filePath: string,
 ) => {
   if (state.atPosition >= 0) {
+    const wordEnd = getWordEnd(state.inputText, state.atPosition);
     const beforeAt = state.inputText.substring(0, state.atPosition);
-    const afterQuery = state.inputText.substring(state.cursorPosition);
-    const newInput = beforeAt + `${filePath} ` + afterQuery;
-    const newCursorPosition = beforeAt.length + filePath.length + 1;
+    const afterWord = state.inputText.substring(wordEnd);
+    const newInput = beforeAt + `@${filePath} ` + afterWord;
+    const newCursorPosition = beforeAt.length + filePath.length + 2;
 
     dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
     dispatch({ type: "SET_CURSOR_POSITION", payload: newCursorPosition });
@@ -343,6 +437,26 @@ export const handleSelectorInput = (
     return true;
   }
 
+  if (key.leftArrow) {
+    const newCursorPosition = state.cursorPosition - 1;
+    dispatch({ type: "MOVE_CURSOR", payload: -1 });
+    checkForAtDeletion(state, dispatch, newCursorPosition);
+    checkForSlashDeletion(state, dispatch, newCursorPosition);
+    return true;
+  }
+
+  if (key.rightArrow) {
+    const newCursorPosition = state.cursorPosition + 1;
+    dispatch({ type: "MOVE_CURSOR", payload: 1 });
+    checkForAtDeletion(state, dispatch, newCursorPosition);
+    checkForSlashDeletion(state, dispatch, newCursorPosition);
+    return true;
+  }
+
+  if (input === " " && state.showFileSelector) {
+    dispatch({ type: "CANCEL_FILE_SELECTOR" });
+  }
+
   if (
     input &&
     !key.ctrl &&
@@ -358,19 +472,7 @@ export const handleSelectorInput = (
   ) {
     dispatch({ type: "INSERT_TEXT", payload: input });
 
-    // Calculate new state for special char handling
-    const newCursorPosition = state.cursorPosition + input.length;
-    const beforeCursor = state.inputText.substring(0, state.cursorPosition);
-    const afterCursor = state.inputText.substring(state.cursorPosition);
-    const newInputText = beforeCursor + input + afterCursor;
-
-    handleSpecialCharInput(
-      state,
-      dispatch,
-      input,
-      newCursorPosition,
-      newInputText,
-    );
+    processSelectorInput(state, dispatch, input);
     return true;
   }
 
@@ -383,12 +485,10 @@ export const handleNormalInput = async (
   callbacks: Partial<InputManagerCallbacks>,
   input: string,
   key: Key,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   clearImages?: () => void,
 ): Promise<boolean> => {
   if (key.return) {
-    await handleSubmit(state, dispatch, callbacks, isLoading, isCommandRunning);
+    await handleSubmit(state, dispatch, callbacks);
     clearImages?.();
     return true;
   }
@@ -398,18 +498,86 @@ export const handleNormalInput = async (
       dispatch({ type: "CANCEL_FILE_SELECTOR" });
     } else if (state.showCommandSelector) {
       dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
+    } else if (state.historyIndex !== -1) {
+      dispatch({ type: "RESET_HISTORY_NAVIGATION" });
+    }
+    return true;
+  }
+
+  if (key.upArrow) {
+    if (state.history.length === 0) {
+      const history = await PromptHistoryManager.getHistory(
+        callbacks.sessionId,
+      );
+      dispatch({ type: "SET_HISTORY_ENTRIES", payload: history });
     }
+    dispatch({ type: "NAVIGATE_HISTORY", payload: "up" });
+    return true;
+  }
+
+  if (key.downArrow) {
+    dispatch({ type: "NAVIGATE_HISTORY", payload: "down" });
     return true;
   }
 
   if (key.backspace || key.delete) {
     if (state.cursorPosition > 0) {
       const newCursorPosition = state.cursorPosition - 1;
+      const beforeCursor = state.inputText.substring(
+        0,
+        state.cursorPosition - 1,
+      );
+      const afterCursor = state.inputText.substring(state.cursorPosition);
+      const newInputText = beforeCursor + afterCursor;
+
       dispatch({ type: "DELETE_CHAR" });
-      callbacks.onResetHistoryNavigation?.();
+      dispatch({ type: "RESET_HISTORY_NAVIGATION" });
 
       checkForAtDeletion(state, dispatch, newCursorPosition);
       checkForSlashDeletion(state, dispatch, newCursorPosition);
+
+      // Reactivate file selector if cursor is now within an @word
+      const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+      let showFileSelector = state.showFileSelector;
+      let atPosition = state.atPosition;
+      if (atPos !== -1 && !state.showFileSelector) {
+        dispatch({
+          type: "ACTIVATE_FILE_SELECTOR",
+          payload: atPos,
+        });
+        showFileSelector = true;
+        atPosition = atPos;
+      }
+
+      const slashPos = getSlashSelectorPosition(
+        newInputText,
+        newCursorPosition,
+      );
+      let showCommandSelector = state.showCommandSelector;
+      let slashPosition = state.slashPosition;
+      if (slashPos !== -1 && !state.showCommandSelector) {
+        dispatch({
+          type: "ACTIVATE_COMMAND_SELECTOR",
+          payload: slashPos,
+        });
+        showCommandSelector = true;
+        slashPosition = slashPos;
+      }
+
+      updateSearchQueriesForActiveSelectors(
+        {
+          ...state,
+          inputText: newInputText,
+          cursorPosition: newCursorPosition,
+          showFileSelector,
+          atPosition,
+          showCommandSelector,
+          slashPosition,
+        },
+        dispatch,
+        newInputText,
+        newCursorPosition,
+      );
     }
     return true;
   }
@@ -468,8 +636,6 @@ export const handleInput = async (
   callbacks: Partial<InputManagerCallbacks>,
   input: string,
   key: Key,
-  isLoading: boolean = false,
-  isCommandRunning: boolean = false,
   clearImages?: () => void,
 ): Promise<boolean> => {
   if (state.selectorJustUsed) {
@@ -478,7 +644,6 @@ export const handleInput = async (
 
   if (key.escape) {
     if (
-      (isLoading || isCommandRunning) &&
       !(
         state.showFileSelector ||
         state.showCommandSelector ||
@@ -552,8 +717,6 @@ export const handleInput = async (
       callbacks,
       input,
       key,
-      isLoading,
-      isCommandRunning,
       clearImages,
     );
   }

package/src/managers/inputReducer.ts

@@ -1,4 +1,4 @@
-import { FileItem, PermissionMode, Logger } from "wave-agent-sdk";
+import { FileItem, PermissionMode, Logger, PromptEntry } from "wave-agent-sdk";
 
 export interface AttachedImage {
   id: number;
@@ -35,8 +35,8 @@ export interface InputManagerCallbacks {
   onAbortMessage?: () => void;
   onClearMessages?: () => void;
   onBackgroundCurrentTask?: () => void;
-  onResetHistoryNavigation?: () => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
+  sessionId?: string;
   logger?: Logger;
 }
 
@@ -66,6 +66,11 @@ export interface InputState {
   isPasting: boolean;
   pasteBuffer: string;
   initialPasteCursorPosition: number;
+  history: PromptEntry[];
+  historyIndex: number;
+  originalInputText: string;
+  originalLongTextMap: Record<string, string>;
+  isFileSearching: boolean;
 }
 
 export const initialState: InputState = {
@@ -94,6 +99,11 @@ export const initialState: InputState = {
   isPasting: false,
   pasteBuffer: "",
   initialPasteCursorPosition: 0,
+  history: [],
+  historyIndex: -1,
+  originalInputText: "",
+  originalLongTextMap: {},
+  isFileSearching: false,
 };
 
 export type InputAction =
@@ -131,7 +141,11 @@ export type InputAction =
   | {
       type: "ADD_IMAGE_AND_INSERT_PLACEHOLDER";
       payload: { path: string; mimeType: string };
-    };
+    }
+  | { type: "SET_HISTORY_ENTRIES"; payload: PromptEntry[] }
+  | { type: "NAVIGATE_HISTORY"; payload: "up" | "down" }
+  | { type: "RESET_HISTORY_NAVIGATION" }
+  | { type: "SELECT_HISTORY_ENTRY"; payload: PromptEntry };
 
 export function inputReducer(
   state: InputState,
@@ -139,7 +153,11 @@ export function inputReducer(
 ): InputState {
   switch (action.type) {
     case "SET_INPUT_TEXT":
-      return { ...state, inputText: action.payload };
+      return {
+        ...state,
+        inputText: action.payload,
+        historyIndex: -1,
+      };
     case "SET_CURSOR_POSITION":
       return {
         ...state,
@@ -157,6 +175,7 @@ export function inputReducer(
         ...state,
         inputText: newText,
         cursorPosition: newCursorPosition,
+        historyIndex: -1,
       };
     }
     case "DELETE_CHAR": {
@@ -172,6 +191,7 @@ export function inputReducer(
           ...state,
           inputText: newText,
           cursorPosition: newCursorPosition,
+          historyIndex: -1,
         };
       }
       return state;
@@ -190,11 +210,20 @@ export function inputReducer(
         atPosition: action.payload,
         fileSearchQuery: "",
         filteredFiles: [],
+        isFileSearching: true,
       };
     case "SET_FILE_SEARCH_QUERY":
-      return { ...state, fileSearchQuery: action.payload };
+      return {
+        ...state,
+        fileSearchQuery: action.payload,
+        isFileSearching: true,
+      };
     case "SET_FILTERED_FILES":
-      return { ...state, filteredFiles: action.payload };
+      return {
+        ...state,
+        filteredFiles: action.payload,
+        isFileSearching: false,
+      };
     case "CANCEL_FILE_SELECTOR":
       return {
         ...state,
@@ -203,6 +232,7 @@ export function inputReducer(
         fileSearchQuery: "",
         filteredFiles: [],
         selectorJustUsed: true,
+        isFileSearching: false,
       };
     case "ACTIVATE_COMMAND_SELECTOR":
       return {
@@ -314,6 +344,7 @@ export function inputReducer(
         cursorPosition: newCursorPosition,
         longTextCounter: newLongTextCounter,
         longTextMap: newLongTextMap,
+        historyIndex: -1,
       };
     }
     case "CLEAR_LONG_TEXT_MAP":
@@ -323,6 +354,7 @@ export function inputReducer(
         ...state,
         inputText: "",
         cursorPosition: 0,
+        historyIndex: -1,
       };
     case "START_PASTE":
       return {
@@ -359,8 +391,74 @@ export function inputReducer(
         imageIdCounter: state.imageIdCounter + 1,
         inputText: newText,
         cursorPosition: newCursorPosition,
+        historyIndex: -1,
       };
     }
+    case "SET_HISTORY_ENTRIES":
+      return { ...state, history: action.payload };
+    case "NAVIGATE_HISTORY": {
+      const direction = action.payload;
+      let newIndex = state.historyIndex;
+      let newOriginalInputText = state.originalInputText;
+      let newOriginalLongTextMap = state.originalLongTextMap;
+
+      if (direction === "up") {
+        if (newIndex === -1) {
+          newOriginalInputText = state.inputText;
+          newOriginalLongTextMap = state.longTextMap;
+        }
+        newIndex = Math.min(state.history.length - 1, newIndex + 1);
+      } else {
+        newIndex = Math.max(-1, newIndex - 1);
+      }
+
+      if (newIndex === -1) {
+        return {
+          ...state,
+          historyIndex: newIndex,
+          inputText: newOriginalInputText,
+          longTextMap: newOriginalLongTextMap,
+          cursorPosition: newOriginalInputText.length,
+          originalInputText: newOriginalInputText,
+          originalLongTextMap: newOriginalLongTextMap,
+        };
+      } else {
+        const entry = state.history[newIndex];
+        return {
+          ...state,
+          historyIndex: newIndex,
+          inputText: entry.prompt,
+          longTextMap: entry.longTextMap || {},
+          cursorPosition: entry.prompt.length,
+          originalInputText: newOriginalInputText,
+          originalLongTextMap: newOriginalLongTextMap,
+        };
+      }
+    }
+    case "SELECT_HISTORY_ENTRY": {
+      const entry = action.payload;
+      return {
+        ...state,
+        inputText: entry.prompt,
+        longTextMap: entry.longTextMap || {},
+        cursorPosition: entry.prompt.length,
+        historyIndex: -1,
+        history: [],
+        originalInputText: "",
+        originalLongTextMap: {},
+        showHistorySearch: false,
+        historySearchQuery: "",
+        selectorJustUsed: true,
+      };
+    }
+    case "RESET_HISTORY_NAVIGATION":
+      return {
+        ...state,
+        historyIndex: -1,
+        history: [],
+        originalInputText: "",
+        originalLongTextMap: {},
+      };
     default:
       return state;
   }

package/src/utils/logger.ts

@@ -9,8 +9,11 @@
  */
 
 import * as fs from "fs";
+import { Chalk } from "chalk";
 import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
 
+const chalk = new Chalk({ level: 3 });
+
 const logFile = process.env.LOG_FILE || LOG_FILE;
 
 /**
@@ -33,6 +36,16 @@ const LOG_LEVEL_NAMES = {
   [LogLevel.ERROR]: "ERROR",
 };
 
+/**
+ * Log level color mapping
+ */
+const LEVEL_COLORS = {
+  [LogLevel.DEBUG]: chalk.gray,
+  [LogLevel.INFO]: chalk.blue,
+  [LogLevel.WARN]: chalk.yellow,
+  [LogLevel.ERROR]: chalk.red,
+};
+
 /**
  * Log configuration interface
  */
@@ -146,7 +159,8 @@ const logMessage = (level: LogLevel, ...args: unknown[]): void => {
 
   const levelName = LOG_LEVEL_NAMES[level];
   const timestamp = new Date().toISOString();
-  const formattedMessage = `[${timestamp}] [${levelName}] ${messageText}\n`;
+  const color = LEVEL_COLORS[level] || ((s: string) => s);
+  const formattedMessage = `[${chalk.gray(timestamp)}] [${color(levelName)}] ${messageText}\n`;
 
   try {
     // Ensure directory exists