wave-code 0.8.1 → 0.8.2

package/src/hooks/useInputManager.ts

@@ -1,284 +1,401 @@
-import { useEffect, useRef, useState, useCallback } from "react";
+import { useEffect, useReducer, useCallback, useRef } from "react";
 import { Key } from "ink";
 import {
-  InputManager,
+  inputReducer,
+  initialState,
   InputManagerCallbacks,
-  AttachedImage,
-} from "../managers/InputManager.js";
-import { FileItem } from "../components/FileSelector.js";
-import { PermissionMode } from "wave-agent-sdk";
-import { logger } from "../utils/logger.js";
+} from "../managers/inputReducer.js";
+import { searchFiles as searchFilesUtil, PermissionMode } from "wave-agent-sdk";
+import * as handlers from "../managers/inputHandlers.js";
 
 export const useInputManager = (
   callbacks: Partial<InputManagerCallbacks> = {},
 ) => {
-  const managerRef = useRef<InputManager | null>(null);
-  const [isManagerReady, setIsManagerReady] = useState(false);
-
-  // React state that mirrors InputManager state
-  const [inputText, setInputText] = useState("");
-  const [cursorPosition, setCursorPosition] = useState(0);
-  const [fileSelectorState, setFileSelectorState] = useState({
-    show: false,
-    files: [] as FileItem[],
-    query: "",
-    position: -1,
-  });
-  const [commandSelectorState, setCommandSelectorState] = useState({
-    show: false,
-    query: "",
-    position: -1,
-  });
-  const [historySearchState, setHistorySearchState] = useState({
-    show: false,
-    query: "",
-  });
-  const [showBackgroundTaskManager, setShowBackgroundTaskManager] =
-    useState(false);
-  const [showMcpManager, setShowMcpManager] = useState(false);
-  const [showRewindManager, setShowRewindManager] = useState(false);
-  const [showHelp, setShowHelp] = useState(false);
-  const [showStatusCommand, setShowStatusCommand] = useState(false);
-  const [permissionMode, setPermissionModeState] =
-    useState<PermissionMode>("default");
-  const [attachedImages, setAttachedImages] = useState<AttachedImage[]>([]);
-
-  // Create InputManager on mount and update callbacks when they change
+  const [state, dispatch] = useReducer(inputReducer, initialState);
+  const callbacksRef = useRef(callbacks);
+  const stateRef = useRef(state);
+
+  // Update refs when they change
   useEffect(() => {
-    if (!managerRef.current) {
-      // Create InputManager on first mount
-      const manager = new InputManager({
-        logger,
-        onInputTextChange: setInputText,
-        onCursorPositionChange: setCursorPosition,
-        onFileSelectorStateChange: (show, files, query, position) => {
-          setFileSelectorState({ show, files, query, position });
-        },
-        onCommandSelectorStateChange: (show, query, position) => {
-          setCommandSelectorState({ show, query, position });
-        },
-        onHistorySearchStateChange: (show, query) => {
-          setHistorySearchState({ show, query });
-        },
-        onBackgroundTaskManagerStateChange: (show) => {
-          setShowBackgroundTaskManager(show);
-        },
-        onMcpManagerStateChange: (show) => {
-          setShowMcpManager(show);
-        },
-        onRewindManagerStateChange: (show) => {
-          setShowRewindManager(show);
-        },
-        onHelpStateChange: (show) => {
-          setShowHelp(show);
-        },
-        onStatusCommandStateChange: (show) => {
-          setShowStatusCommand(show);
-        },
-        onPermissionModeChange: (mode) => {
-          setPermissionModeState(mode);
-          callbacks.onPermissionModeChange?.(mode);
-        },
-        onImagesStateChange: setAttachedImages,
-        ...callbacks,
-      });
-
-      managerRef.current = manager;
-      setIsManagerReady(true);
-    } else {
-      // Update callbacks on existing manager
-      managerRef.current.updateCallbacks({
-        logger,
-        onInputTextChange: setInputText,
-        onCursorPositionChange: setCursorPosition,
-        onFileSelectorStateChange: (show, files, query, position) => {
-          setFileSelectorState({ show, files, query, position });
-        },
-        onCommandSelectorStateChange: (show, query, position) => {
-          setCommandSelectorState({ show, query, position });
-        },
-        onHistorySearchStateChange: (show, query) => {
-          setHistorySearchState({ show, query });
-        },
-        onBackgroundTaskManagerStateChange: (show) => {
-          setShowBackgroundTaskManager(show);
-        },
-        onMcpManagerStateChange: (show) => {
-          setShowMcpManager(show);
-        },
-        onRewindManagerStateChange: (show) => {
-          setShowRewindManager(show);
-        },
-        onHelpStateChange: (show) => {
-          setShowHelp(show);
-        },
-        onStatusCommandStateChange: (show) => {
-          setShowStatusCommand(show);
-        },
-        onPermissionModeChange: (mode) => {
-          setPermissionModeState(mode);
-          callbacks.onPermissionModeChange?.(mode);
-        },
-        onImagesStateChange: setAttachedImages,
-        ...callbacks,
-      });
-    }
+    callbacksRef.current = callbacks;
   }, [callbacks]);
 
-  // Cleanup on unmount
   useEffect(() => {
-    return () => {
-      if (managerRef.current) {
-        managerRef.current.destroy();
-      }
-    };
-  }, []);
+    stateRef.current = state;
+  }, [state]);
 
-  // Expose manager methods
-  const insertTextAtCursor = useCallback(
-    (
-      text: string,
-      callback?: (newText: string, newCursorPosition: number) => void,
-    ) => {
-      managerRef.current?.insertTextAtCursor(text, callback);
-    },
-    [],
-  );
+  // Handle selectorJustUsed reset
+  useEffect(() => {
+    if (state.selectorJustUsed) {
+      const timer = setTimeout(() => {
+        dispatch({ type: "SET_SELECTOR_JUST_USED", payload: false });
+      }, 0);
+      return () => clearTimeout(timer);
+    }
+  }, [state.selectorJustUsed]);
 
-  const deleteCharAtCursor = useCallback(
-    (callback?: (newText: string, newCursorPosition: number) => void) => {
-      managerRef.current?.deleteCharAtCursor(callback);
-    },
-    [],
-  );
+  // Handle debounced file search
+  useEffect(() => {
+    if (state.showFileSelector) {
+      const debounceDelay = parseInt(
+        process.env.FILE_SELECTOR_DEBOUNCE_MS || "300",
+        10,
+      );
+      const timer = setTimeout(async () => {
+        try {
+          const fileItems = await searchFilesUtil(state.fileSearchQuery);
+          dispatch({ type: "SET_FILTERED_FILES", payload: fileItems });
+        } catch (error) {
+          console.error("File search error:", error);
+          dispatch({ type: "SET_FILTERED_FILES", payload: [] });
+        }
+      }, debounceDelay);
+      return () => clearTimeout(timer);
+    }
+  }, [state.showFileSelector, state.fileSearchQuery]);
+
+  // Handle paste debouncing
+  useEffect(() => {
+    if (state.isPasting) {
+      const pasteDebounceDelay = parseInt(
+        process.env.PASTE_DEBOUNCE_MS || "30",
+        10,
+      );
+      const timer = setTimeout(() => {
+        const processedInput = stateRef.current.pasteBuffer.replace(
+          /\r/g,
+          "\n",
+        );
+        dispatch({ type: "COMPRESS_AND_INSERT_TEXT", payload: processedInput });
+        dispatch({ type: "END_PASTE" });
+        callbacksRef.current.onResetHistoryNavigation?.();
+      }, pasteDebounceDelay);
+      return () => clearTimeout(timer);
+    }
+  }, [state.isPasting, state.pasteBuffer]);
+
+  // Sync state changes with callbacks
+  useEffect(() => {
+    callbacksRef.current.onInputTextChange?.(state.inputText);
+  }, [state.inputText]);
+
+  useEffect(() => {
+    callbacksRef.current.onCursorPositionChange?.(state.cursorPosition);
+  }, [state.cursorPosition]);
+
+  useEffect(() => {
+    callbacksRef.current.onFileSelectorStateChange?.(
+      state.showFileSelector,
+      state.filteredFiles,
+      state.fileSearchQuery,
+      state.atPosition,
+    );
+  }, [
+    state.showFileSelector,
+    state.filteredFiles,
+    state.fileSearchQuery,
+    state.atPosition,
+  ]);
+
+  useEffect(() => {
+    callbacksRef.current.onCommandSelectorStateChange?.(
+      state.showCommandSelector,
+      state.commandSearchQuery,
+      state.slashPosition,
+    );
+  }, [
+    state.showCommandSelector,
+    state.commandSearchQuery,
+    state.slashPosition,
+  ]);
+
+  useEffect(() => {
+    callbacksRef.current.onHistorySearchStateChange?.(
+      state.showHistorySearch,
+      state.historySearchQuery,
+    );
+  }, [state.showHistorySearch, state.historySearchQuery]);
+
+  useEffect(() => {
+    callbacksRef.current.onBackgroundTaskManagerStateChange?.(
+      state.showBackgroundTaskManager,
+    );
+  }, [state.showBackgroundTaskManager]);
+
+  useEffect(() => {
+    callbacksRef.current.onMcpManagerStateChange?.(state.showMcpManager);
+  }, [state.showMcpManager]);
+
+  useEffect(() => {
+    callbacksRef.current.onRewindManagerStateChange?.(state.showRewindManager);
+  }, [state.showRewindManager]);
+
+  useEffect(() => {
+    callbacksRef.current.onHelpStateChange?.(state.showHelp);
+  }, [state.showHelp]);
+
+  useEffect(() => {
+    callbacksRef.current.onStatusCommandStateChange?.(state.showStatusCommand);
+  }, [state.showStatusCommand]);
+
+  useEffect(() => {
+    callbacksRef.current.onImagesStateChange?.(state.attachedImages);
+  }, [state.attachedImages]);
+
+  // Methods
+  const insertTextAtCursor = useCallback((text: string) => {
+    dispatch({ type: "INSERT_TEXT", payload: text });
+  }, []);
+
+  const deleteCharAtCursor = useCallback(() => {
+    dispatch({ type: "DELETE_CHAR" });
+  }, []);
 
   const clearInput = useCallback(() => {
-    managerRef.current?.clearInput();
+    dispatch({ type: "CLEAR_INPUT" });
   }, []);
 
   const moveCursorLeft = useCallback(() => {
-    managerRef.current?.moveCursorLeft();
+    dispatch({ type: "MOVE_CURSOR", payload: -1 });
   }, []);
 
   const moveCursorRight = useCallback(() => {
-    managerRef.current?.moveCursorRight();
+    dispatch({ type: "MOVE_CURSOR", payload: 1 });
   }, []);
 
-  // File selector methods
   const activateFileSelector = useCallback((position: number) => {
-    managerRef.current?.activateFileSelector(position);
+    dispatch({ type: "ACTIVATE_FILE_SELECTOR", payload: position });
   }, []);
 
-  const handleFileSelect = useCallback(
-    (filePath: string) => {
-      return (
-        managerRef.current?.handleFileSelect(filePath) || {
-          newInput: inputText,
-          newCursorPosition: cursorPosition,
-        }
-      );
-    },
-    [inputText, cursorPosition],
-  );
+  const handleFileSelect = useCallback((filePath: string) => {
+    return handlers.handleFileSelect(
+      stateRef.current,
+      dispatch,
+      callbacksRef.current,
+      filePath,
+    );
+  }, []);
 
   const handleCancelFileSelect = useCallback(() => {
-    managerRef.current?.handleCancelFileSelect();
+    dispatch({ type: "CANCEL_FILE_SELECTOR" });
   }, []);
 
   const updateFileSearchQuery = useCallback((query: string) => {
-    managerRef.current?.updateFileSearchQuery(query);
+    dispatch({ type: "SET_FILE_SEARCH_QUERY", payload: query });
   }, []);
 
   const checkForAtDeletion = useCallback((cursorPos: number) => {
-    return managerRef.current?.checkForAtDeletion(cursorPos) || false;
+    return handlers.checkForAtDeletion(stateRef.current, dispatch, cursorPos);
   }, []);
 
-  // Command selector methods
   const activateCommandSelector = useCallback((position: number) => {
-    managerRef.current?.activateCommandSelector(position);
+    dispatch({ type: "ACTIVATE_COMMAND_SELECTOR", payload: position });
   }, []);
 
-  const handleCommandSelect = useCallback(
-    (command: string) => {
-      return (
-        managerRef.current?.handleCommandSelect(command) || {
-          newInput: inputText,
-          newCursorPosition: cursorPosition,
-        }
-      );
-    },
-    [inputText, cursorPosition],
-  );
+  const handleCommandSelect = useCallback((command: string) => {
+    return handlers.handleCommandSelect(
+      stateRef.current,
+      dispatch,
+      callbacksRef.current,
+      command,
+    );
+  }, []);
 
-  const handleCommandInsert = useCallback(
-    (command: string) => {
-      return (
-        managerRef.current?.handleCommandInsert(command) || {
-          newInput: inputText,
-          newCursorPosition: cursorPosition,
-        }
+  const handleCommandInsert = useCallback((command: string) => {
+    const currentState = stateRef.current;
+    if (currentState.slashPosition >= 0) {
+      const beforeSlash = currentState.inputText.substring(
+        0,
+        currentState.slashPosition,
       );
-    },
-    [inputText, cursorPosition],
-  );
+      const afterQuery = currentState.inputText.substring(
+        currentState.cursorPosition,
+      );
+      const newInput = beforeSlash + `/${command} ` + afterQuery;
+      const newCursorPosition = beforeSlash.length + command.length + 2;
+
+      dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
+      dispatch({ type: "SET_CURSOR_POSITION", payload: newCursorPosition });
+      dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
+
+      callbacksRef.current.onInputTextChange?.(newInput);
+      callbacksRef.current.onCursorPositionChange?.(newCursorPosition);
+
+      return { newInput, newCursorPosition };
+    }
+    return {
+      newInput: currentState.inputText,
+      newCursorPosition: currentState.cursorPosition,
+    };
+  }, []);
 
   const handleCancelCommandSelect = useCallback(() => {
-    managerRef.current?.handleCancelCommandSelect();
+    dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
   }, []);
 
   const updateCommandSearchQuery = useCallback((query: string) => {
-    managerRef.current?.updateCommandSearchQuery(query);
+    dispatch({ type: "SET_COMMAND_SEARCH_QUERY", payload: query });
   }, []);
 
   const checkForSlashDeletion = useCallback((cursorPos: number) => {
-    return managerRef.current?.checkForSlashDeletion(cursorPos) || false;
+    return handlers.checkForSlashDeletion(
+      stateRef.current,
+      dispatch,
+      cursorPos,
+    );
   }, []);
 
-  // History search methods
   const handleHistorySearchSelect = useCallback((prompt: string) => {
-    managerRef.current?.handleHistorySearchSelect(prompt);
+    dispatch({ type: "SET_INPUT_TEXT", payload: prompt });
+    dispatch({ type: "SET_CURSOR_POSITION", payload: prompt.length });
+    dispatch({ type: "CANCEL_HISTORY_SEARCH" });
   }, []);
 
   const handleCancelHistorySearch = useCallback(() => {
-    managerRef.current?.handleCancelHistorySearch();
+    dispatch({ type: "CANCEL_HISTORY_SEARCH" });
   }, []);
 
-  // Special character handling
   const handleSpecialCharInput = useCallback((char: string) => {
-    managerRef.current?.handleSpecialCharInput(char);
+    handlers.handleSpecialCharInput(
+      stateRef.current,
+      dispatch,
+      char,
+      stateRef.current.cursorPosition,
+      stateRef.current.inputText,
+    );
+  }, []);
+
+  const setInputText = useCallback((text: string) => {
+    dispatch({ type: "SET_INPUT_TEXT", payload: text });
+  }, []);
+
+  const setCursorPosition = useCallback((position: number) => {
+    dispatch({ type: "SET_CURSOR_POSITION", payload: position });
+  }, []);
+
+  const setShowBackgroundTaskManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_BACKGROUND_TASK_MANAGER", payload: show });
+  }, []);
+
+  const setShowMcpManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
+  }, []);
+
+  const setShowRewindManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
+  }, []);
+
+  const setShowHelp = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_HELP", payload: show });
+  }, []);
+
+  const setShowStatusCommand = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: show });
+  }, []);
+
+  const setPermissionMode = useCallback((mode: PermissionMode) => {
+    dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
+    callbacksRef.current.onPermissionModeChange?.(mode);
+  }, []);
+
+  const addImage = useCallback((imagePath: string, mimeType: string) => {
+    dispatch({ type: "ADD_IMAGE", payload: { path: imagePath, mimeType } });
+  }, []);
+
+  const removeImage = useCallback((imageId: number) => {
+    dispatch({ type: "REMOVE_IMAGE", payload: imageId });
   }, []);
 
-  // Direct state access methods (for compatibility with existing code)
-  const setInputTextDirect = useCallback((text: string) => {
-    managerRef.current?.setInputText(text);
+  const clearImages = useCallback(() => {
+    dispatch({ type: "CLEAR_IMAGES" });
   }, []);
 
-  const setCursorPositionDirect = useCallback((position: number) => {
-    managerRef.current?.setCursorPosition(position);
+  const handlePasteImage = useCallback(async () => {
+    return await handlers.handlePasteImage(dispatch);
   }, []);
 
-  // Complex handlers that combine multiple operations
+  const handlePasteInput = useCallback((input: string) => {
+    handlers.handlePasteInput(
+      stateRef.current,
+      dispatch,
+      callbacksRef.current,
+      input,
+    );
+  }, []);
+
+  const handleSubmit = useCallback(
+    async (
+      attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+      isLoading: boolean = false,
+      isCommandRunning: boolean = false,
+    ) => {
+      await handlers.handleSubmit(
+        stateRef.current,
+        dispatch,
+        callbacksRef.current,
+        isLoading,
+        isCommandRunning,
+        attachedImages,
+      );
+    },
+    [],
+  );
+
+  const expandLongTextPlaceholders = useCallback((text: string) => {
+    return handlers.expandLongTextPlaceholders(
+      text,
+      stateRef.current.longTextMap,
+    );
+  }, []);
+
+  const clearLongTextMap = useCallback(() => {
+    dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
+  }, []);
+
+  const handleInput = useCallback(
+    async (
+      input: string,
+      key: Key,
+      attachedImages: Array<{ id: number; path: string; mimeType: string }>,
+      isLoading: boolean = false,
+      isCommandRunning: boolean = false,
+      clearImages?: () => void,
+    ) => {
+      return await handlers.handleInput(
+        stateRef.current,
+        dispatch,
+        callbacksRef.current,
+        input,
+        key,
+        isLoading,
+        isCommandRunning,
+        clearImages,
+      );
+    },
+    [],
+  );
+
   return {
     // State
-    inputText,
-    cursorPosition,
-    showFileSelector: fileSelectorState.show,
-    filteredFiles: fileSelectorState.files,
-    fileSearchQuery: fileSelectorState.query,
-    atPosition: fileSelectorState.position,
-    showCommandSelector: commandSelectorState.show,
-    commandSearchQuery: commandSelectorState.query,
-    slashPosition: commandSelectorState.position,
-    showHistorySearch: historySearchState.show,
-    historySearchQuery: historySearchState.query,
-    showBackgroundTaskManager,
-    showMcpManager,
-    showRewindManager,
-    showHelp,
-    showStatusCommand,
-    permissionMode,
-    attachedImages,
-    isManagerReady,
+    inputText: state.inputText,
+    cursorPosition: state.cursorPosition,
+    showFileSelector: state.showFileSelector,
+    filteredFiles: state.filteredFiles,
+    fileSearchQuery: state.fileSearchQuery,
+    atPosition: state.atPosition,
+    showCommandSelector: state.showCommandSelector,
+    commandSearchQuery: state.commandSearchQuery,
+    slashPosition: state.slashPosition,
+    showHistorySearch: state.showHistorySearch,
+    historySearchQuery: state.historySearchQuery,
+    showBackgroundTaskManager: state.showBackgroundTaskManager,
+    showMcpManager: state.showMcpManager,
+    showRewindManager: state.showRewindManager,
+    showHelp: state.showHelp,
+    showStatusCommand: state.showStatusCommand,
+    permissionMode: state.permissionMode,
+    attachedImages: state.attachedImages,
+    isManagerReady: true,
 
     // Methods
     insertTextAtCursor,
@@ -310,97 +427,33 @@ export const useInputManager = (
     handleSpecialCharInput,
 
     // Bash/MCP Manager
-    setShowBackgroundTaskManager: useCallback((show: boolean) => {
-      managerRef.current?.setShowBackgroundTaskManager(show);
-    }, []),
-    setShowMcpManager: useCallback((show: boolean) => {
-      managerRef.current?.setShowMcpManager(show);
-    }, []),
-    setShowRewindManager: useCallback((show: boolean) => {
-      managerRef.current?.setShowRewindManager(show);
-      setShowRewindManager(show);
-    }, []),
-    setShowHelp: useCallback((show: boolean) => {
-      managerRef.current?.setShowHelp(show);
-      setShowHelp(show);
-    }, []),
-    setShowStatusCommand: useCallback((show: boolean) => {
-      managerRef.current?.setShowStatusCommand(show);
-      setShowStatusCommand(show);
-    }, []),
-    setPermissionMode: useCallback((mode: PermissionMode) => {
-      setPermissionModeState(mode);
-      managerRef.current?.setPermissionMode(mode);
-    }, []),
+    setShowBackgroundTaskManager,
+    setShowMcpManager,
+    setShowRewindManager,
+    setShowHelp,
+    setShowStatusCommand,
+    setPermissionMode,
 
     // Image management
-    addImage: useCallback((imagePath: string, mimeType: string) => {
-      return managerRef.current?.addImage(imagePath, mimeType);
-    }, []),
-    removeImage: useCallback((imageId: number) => {
-      managerRef.current?.removeImage(imageId);
-    }, []),
-    clearImages: useCallback(() => {
-      managerRef.current?.clearImages();
-    }, []),
-    handlePasteImage: useCallback(async () => {
-      return (await managerRef.current?.handlePasteImage()) || false;
-    }, []),
+    addImage,
+    removeImage,
+    clearImages,
+    handlePasteImage,
 
     // Paste and text handling
-    handlePasteInput: useCallback((input: string) => {
-      managerRef.current?.handlePasteInput(input);
-    }, []),
-    handleSubmit: useCallback(
-      async (
-        attachedImages: Array<{ id: number; path: string; mimeType: string }>,
-        isLoading: boolean = false,
-        isCommandRunning: boolean = false,
-      ) => {
-        await managerRef.current?.handleSubmit(
-          attachedImages,
-          isLoading,
-          isCommandRunning,
-        );
-      },
-      [],
-    ),
-    expandLongTextPlaceholders: useCallback((text: string) => {
-      return managerRef.current?.expandLongTextPlaceholders(text) || text;
-    }, []),
-    clearLongTextMap: useCallback(() => {
-      managerRef.current?.clearLongTextMap();
-    }, []),
+    handlePasteInput,
+    handleSubmit,
+    expandLongTextPlaceholders,
+    clearLongTextMap,
 
     // Main input handler
-    handleInput: useCallback(
-      async (
-        input: string,
-        key: Key,
-        attachedImages: Array<{ id: number; path: string; mimeType: string }>,
-        isLoading: boolean = false,
-        isCommandRunning: boolean = false,
-        clearImages?: () => void,
-      ) => {
-        return (
-          (await managerRef.current?.handleInput(
-            input,
-            key,
-            attachedImages,
-            isLoading,
-            isCommandRunning,
-            clearImages,
-          )) || false
-        );
-      },
-      [],
-    ),
+    handleInput,
 
-    // Direct state setters (for React compatibility)
-    setInputText: setInputTextDirect,
-    setCursorPosition: setCursorPositionDirect,
+    // Direct state setters
+    setInputText,
+    setCursorPosition,
 
-    // Manager reference for advanced usage
-    manager: managerRef.current,
+    // Manager reference (for compatibility, though it's null now)
+    manager: null,
   };
 };