wave-code 1.0.0 → 1.0.1

package/src/hooks/useInputManager.ts

@@ -1,11 +1,13 @@
-import { useEffect, useReducer, useCallback } from "react";
+import { useEffect, useReducer, useCallback, useRef } from "react";
 import { Key } from "ink";
 import {
   inputReducer,
   initialState,
   InputManagerCallbacks,
   ESC_DOUBLE_PRESS_TIMEOUT_MS,
+  btwOverlayActiveRef,
 } from "../managers/inputReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 import {
   searchFiles as searchFilesUtil,
   PermissionMode,
@@ -19,6 +21,17 @@ export const useInputManager = (
 ) => {
   const [state, dispatch] = useReducer(inputReducer, initialState);
 
+  // Detects bracketed paste (DECSET 2004) markers so pasted text is inserted
+  // without triggering submit — a pasted trailing \r must not be treated as
+  // Enter (see utils/bracketedPaste.ts).
+  const pasteDetectorRef = useRef(createBracketedPasteDetector());
+
+  // Abort plumbing for the /btw side question: ABORT_BTW (set when the overlay
+  // is dismissed while loading) aborts the in-flight onAskBtw call; the
+  // dismissed ref suppresses the late SET_BTW_STATE dispatch / error logging.
+  const btwAbortRef = useRef<AbortController | null>(null);
+  const btwDismissedRef = useRef(false);
+
   const {
     onInputTextChange,
     onCursorPositionChange,
@@ -48,7 +61,6 @@ export const useInputManager = (
     onRecallQueuedMessage,
     onClearMessages,
     onCompact,
-    onGoalCommand,
     isIdle: isIdleProp,
   } = callbacks;
 
@@ -132,25 +144,53 @@ export const useInputManager = (
           case "BACKGROUND_CURRENT_TASK":
             onBackgroundCurrentTask?.();
             break;
-          case "ASK_BTW":
+          case "ASK_BTW": {
+            const controller = new AbortController();
+            btwAbortRef.current = controller;
+            btwDismissedRef.current = false;
             try {
-              const answer = await onAskBtw?.(effect.question);
-              dispatch({
-                type: "SET_BTW_STATE",
-                payload: { answer, isLoading: false },
-              });
-            } catch (error) {
-              console.error("Failed to ask side question:", error);
-              dispatch({
-                type: "SET_BTW_STATE",
-                payload: {
-                  answer:
-                    "Error: Failed to get an answer for your side question.",
-                  isLoading: false,
+              const answer = await onAskBtw?.(
+                effect.question,
+                controller.signal,
+                (content: string) => {
+                  // Stream partial answers into the overlay so the user sees
+                  // the response grow in real time (same visual language as
+                  // assistant text / thinking blocks) instead of a static
+                  // "Answering..." indicator.
+                  if (!btwDismissedRef.current) {
+                    dispatch({
+                      type: "SET_BTW_STATE",
+                      payload: { answer: content, isLoading: true },
+                    });
+                  }
                 },
-              });
+              );
+              if (!btwDismissedRef.current) {
+                dispatch({
+                  type: "SET_BTW_STATE",
+                  payload: { answer, isLoading: false },
+                });
+              }
+            } catch (error) {
+              if (!btwDismissedRef.current) {
+                console.error("Failed to ask side question:", error);
+                dispatch({
+                  type: "SET_BTW_STATE",
+                  payload: {
+                    answer:
+                      "Error: Failed to get an answer for your side question.",
+                    isLoading: false,
+                  },
+                });
+              }
             }
             break;
+          }
+          case "ABORT_BTW":
+            btwDismissedRef.current = true;
+            btwAbortRef.current?.abort();
+            btwAbortRef.current = null;
+            break;
           case "PERMISSION_MODE_CHANGE":
             onPermissionModeChange?.(effect.mode);
             break;
@@ -211,6 +251,17 @@ export const useInputManager = (
                 dispatch({ type: "SET_SHOW_LOGIN_COMMAND", payload: true });
               } else if (command === "logout") {
                 dispatch({ type: "SET_SHOW_LOGIN_COMMAND", payload: true });
+              } else if (command === "btw") {
+                // Bare /btw executed via the command selector — show usage
+                // (aligned with Claude Code's empty-args message).
+                dispatch({
+                  type: "SET_BTW_STATE",
+                  payload: {
+                    question: "",
+                    isLoading: false,
+                    answer: "Usage: /btw <your question>",
+                  },
+                });
               } else if (command === "plugin") {
                 dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
               } else if (command === "model") {
@@ -221,8 +272,6 @@ export const useInputManager = (
                 await onClearMessages?.();
               } else if (command === "compact") {
                 await onCompact?.(effect.args);
-              } else if (command === "goal") {
-                await onGoalCommand?.(effect.args);
               }
             }
             break;
@@ -251,7 +300,6 @@ export const useInputManager = (
     onRecallQueuedMessage,
     onClearMessages,
     onCompact,
-    onGoalCommand,
   ]);
 
   useEffect(() => {
@@ -329,7 +377,13 @@ export const useInputManager = (
     onImagesStateChange?.(state.attachedImages);
   }, [state.attachedImages, onImagesStateChange]);
 
-  // /btw side question is handled via pendingEffect "ASK_BTW" above
+  // Keep the shared overlay-active flag in sync so App's Ctrl+C exit handler
+  // can defer to the /btw overlay (ink runs ALL useInput handlers per keypress
+  // with no propagation control).
+  useEffect(() => {
+    btwOverlayActiveRef.current =
+      state.btwState.question !== "" || state.btwState.answer !== undefined;
+  }, [state.btwState.question, state.btwState.answer]);
 
   // Methods
   const insertTextAtCursor = useCallback((text: string) => {
@@ -536,10 +590,42 @@ export const useInputManager = (
 
   const handleInput = useCallback(
     async (input: string, key: Key) => {
+      const result = pasteDetectorRef.current.process(input);
+
+      if (result.kind === "consume") {
+        // Content of an in-flight bracketed paste (or an empty paste):
+        // hold it, never submit or insert prematurely.
+        return true;
+      }
+
+      if (result.kind === "paste") {
+        if (result.leadingInput) {
+          dispatch({
+            type: "HANDLE_KEY",
+            payload: {
+              input: result.leadingInput,
+              key,
+              hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
+              hasQueuedMessages: hasQueuedMessagesProp ?? false,
+              isIdle: isIdleProp ?? false,
+            },
+          });
+        }
+        if (result.text !== "") {
+          // Insert-only: \r → \n normalizes CRLF terminals, matching the
+          // canonical paste path (inputHandlers.handlePasteInput).
+          dispatch({
+            type: "INSERT_TEXT_WITH_PLACEHOLDER",
+            payload: result.text.replace(/\r/g, "\n"),
+          });
+        }
+        return true;
+      }
+
       dispatch({
         type: "HANDLE_KEY",
         payload: {
-          input,
+          input: result.input,
           key,
           hasSlashCommand: (cmd) => !!onHasSlashCommand?.(cmd),
           hasQueuedMessages: hasQueuedMessagesProp ?? false,

package/src/index.ts

@@ -53,6 +53,12 @@ export async function main() {
         default: false,
         global: false,
       })
+      .option("daemon", {
+        description:
+          "Start as a background daemon (JSON-RPC over a unix socket at PATH)",
+        type: "string",
+        global: false,
+      })
       .option("show-stats", {
         description: "Show timing and usage statistics in print mode",
         type: "boolean",
@@ -402,6 +408,12 @@ export async function main() {
       return startStdioCli();
     }
 
+    // Handle daemon mode (remote background sessions)
+    if (typeof argv.daemon === "string") {
+      const { startDaemonCli } = await import("./daemon-cli.js");
+      return startDaemonCli(argv.daemon);
+    }
+
     await startCli({
       restoreSessionId: argv.restore as string | undefined,
       continueLastSession: argv.continue as boolean | undefined,

package/src/managers/inputHandlers.ts

@@ -63,16 +63,26 @@ export const handleSubmit = async (
         ? contentWithPlaceholders.substring(5).trim()
         : "";
 
-      const payload = {
-        isActive: true,
-        question,
-        isLoading: question !== "",
-      };
-
-      dispatch({
-        type: "SET_BTW_STATE",
-        payload,
-      });
+      if (question) {
+        dispatch({
+          type: "SET_BTW_STATE",
+          payload: {
+            question,
+            isLoading: true,
+            answer: undefined,
+          },
+        });
+      } else {
+        // Bare /btw — show usage (aligned with Claude Code)
+        dispatch({
+          type: "SET_BTW_STATE",
+          payload: {
+            question: "",
+            isLoading: false,
+            answer: "Usage: /btw <your question>",
+          },
+        });
+      }
       dispatch({ type: "CLEAR_INPUT" });
       dispatch({ type: "RESET_HISTORY_NAVIGATION" });
       dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
@@ -363,6 +373,17 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_HELP", payload: true });
         } else if (command === "status") {
           dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: true });
+        } else if (command === "btw") {
+          // Bare /btw executed via the command selector — show usage
+          // (aligned with Claude Code's empty-args message).
+          dispatch({
+            type: "SET_BTW_STATE",
+            payload: {
+              question: "",
+              isLoading: false,
+              answer: "Usage: /btw <your question>",
+            },
+          });
         } else if (command === "plugin") {
           dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
         } else if (command === "model") {
@@ -373,8 +394,6 @@ export const handleCommandSelect = (
           await callbacks.onClearMessages?.();
         } else if (command === "compact") {
           await callbacks.onCompact?.();
-        } else if (command === "goal") {
-          await callbacks.onGoalCommand?.();
         }
       }
     })();
@@ -698,16 +717,24 @@ export const handleInput = async (
   key: Key,
   clearImages?: () => void,
 ): Promise<boolean> => {
-  // Handle ESC to dismiss btw answer
-  if (key.escape && state.btwState.question && !state.btwState.isLoading) {
-    dispatch({
-      type: "SET_BTW_STATE",
-      payload: {
-        question: "",
-        answer: undefined,
-        isLoading: false,
-      },
-    });
+  // /btw overlay handling (mirrors inputReducer's HANDLE_KEY block; this
+  // handler is not wired, kept in sync for consistency). Active while a
+  // question is displayed, or the bare-/btw usage message shows. Only
+  // Escape dismisses; every other key is ignored.
+  if (state.btwState.question || state.btwState.answer) {
+    if (key.escape) {
+      dispatch({
+        type: "SET_BTW_STATE",
+        payload: {
+          question: "",
+          answer: undefined,
+          isLoading: false,
+        },
+      });
+      return true;
+    }
+
+    // Any other key while the overlay is up is ignored
     return true;
   }
 

package/src/managers/inputReducer.ts

@@ -27,6 +27,14 @@ export interface BtwState {
   isLoading: boolean;
 }
 
+/**
+ * True while the /btw overlay is up (a question is on display, loading or
+ * answered). App's Ctrl+C exit handler checks this so Ctrl+C does not quit
+ * the app while the overlay owns the keys. Synced from useInputManager via
+ * an effect.
+ */
+export const btwOverlayActiveRef: { current: boolean } = { current: false };
+
 export const ESC_DOUBLE_PRESS_TIMEOUT_MS = 1000;
 
 export type PendingEffect =
@@ -44,6 +52,7 @@ export type PendingEffect =
   | { type: "ABORT_MESSAGE" }
   | { type: "BACKGROUND_CURRENT_TASK" }
   | { type: "ASK_BTW"; question: string }
+  | { type: "ABORT_BTW" }
   | { type: "PERMISSION_MODE_CHANGE"; mode: PermissionMode }
   | { type: "FETCH_HISTORY" }
   | { type: "PASTE_IMAGE" }
@@ -83,10 +92,13 @@ export interface InputManagerCallbacks {
   onAbortMessage?: () => void;
   onBackgroundCurrentTask?: () => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
-  onAskBtw?: (question: string) => Promise<string>;
+  onAskBtw?: (
+    question: string,
+    abortSignal?: AbortSignal,
+    onContent?: (content: string) => void,
+  ) => Promise<string>;
   onClearMessages?: () => Promise<void>;
   onCompact?: (instructions?: string) => Promise<void>;
-  onGoalCommand?: (args?: string) => Promise<void>;
   sessionId?: string;
   workdir?: string;
   getFullMessageThread?: () => Promise<{
@@ -243,7 +255,7 @@ function insertTextWithPlaceholder(
 /**
  * Submit the current input text: extract [Image #N] references, route /btw
  * and CLI-internal slash commands, otherwise send as a message. Returns null
- * when there is nothing to submit (empty text, bare /btw).
+ * when there is nothing to submit (empty text).
  */
 function submitInput(state: InputState): InputState | null {
   if (!state.inputText.trim()) {
@@ -266,8 +278,20 @@ function submitInput(state: InputState): InputState | null {
   if (contentWithPlaceholders.startsWith("/btw ")) {
     const question = contentWithPlaceholders.substring(5).trim();
     if (!question) {
-      // Bare /btw with no question text — ignore
-      return null;
+      // "/btw " with no question text — show usage (aligned with Claude Code)
+      return {
+        ...state,
+        inputText: "",
+        cursorPosition: 0,
+        historyIndex: -1,
+        longTextMap: {},
+        attachedImages: [],
+        btwState: {
+          question: "",
+          isLoading: false,
+          answer: "Usage: /btw <your question>",
+        },
+      };
     }
 
     return {
@@ -287,8 +311,20 @@ function submitInput(state: InputState): InputState | null {
   }
 
   if (contentWithPlaceholders === "/btw") {
-    // Bare /btw — ignore
-    return null;
+    // Bare /btw — show usage (aligned with Claude Code)
+    return {
+      ...state,
+      inputText: "",
+      cursorPosition: 0,
+      historyIndex: -1,
+      longTextMap: {},
+      attachedImages: [],
+      btwState: {
+        question: "",
+        isLoading: false,
+        answer: "Usage: /btw <your question>",
+      },
+    };
   }
 
   // Check if the content is a CLI-internal slash command (help, tasks,
@@ -858,10 +894,22 @@ export function inputReducer(
         return state;
       }
 
-      // 1. Escape Handling
-      if (key.escape) {
-        // Dismiss btw answer
-        if (state.btwState.question && !state.btwState.isLoading) {
+      // 1. /btw overlay handling (active while a question is displayed, or
+      // the bare-/btw usage message). Only Escape dismisses (or aborts the
+      // in-flight side question while loading); every other key is ignored.
+      if (state.btwState.question || state.btwState.answer) {
+        if (key.escape) {
+          if (state.btwState.isLoading) {
+            return {
+              ...state,
+              btwState: {
+                question: "",
+                answer: undefined,
+                isLoading: false,
+              },
+              pendingEffect: { type: "ABORT_BTW" },
+            };
+          }
           return {
             ...state,
             btwState: {
@@ -871,6 +919,13 @@ export function inputReducer(
             },
           };
         }
+
+        // Any other key while the overlay is up is ignored
+        return state;
+      }
+
+      // 1. Escape Handling
+      if (key.escape) {
         if (state.showFileSelector) {
           return {
             ...state,