wave-code 1.0.10 → 1.1.1

package/src/managers/inputReducer.ts

@@ -138,6 +138,7 @@ export interface InputState {
   showPluginManager: boolean;
   showModelSelector: boolean;
   showWorkflowManager: boolean;
+  showSkillsManager: boolean;
   permissionMode: PermissionMode;
   selectorJustUsed: boolean;
   history: PromptEntry[];
@@ -176,6 +177,7 @@ export const initialState: InputState = {
   showPluginManager: false,
   showModelSelector: false,
   showWorkflowManager: false,
+  showSkillsManager: false,
   permissionMode: "default",
   selectorJustUsed: false,
   history: [],
@@ -255,6 +257,53 @@ function insertTextWithPlaceholder(
   return newState;
 }
 
+/**
+ * Delete a placeholder token ([LongText#N] / [Image #N]) as a whole block
+ * when the cursor sits at the token's end, aligned with Claude Code's
+ * Cursor.deleteTokenBefore (Cursor.ts:937-969): the token must be preceded
+ * by start-of-input or whitespace and followed by whitespace or EOL, so a
+ * mid-token cursor or a token glued to following text falls back to
+ * one-character deletion. Also drops the deleted token's longTextMap entry.
+ * Returns null when no token is at the cursor position.
+ */
+function deleteTokenBefore(
+  inputText: string,
+  cursorPosition: number,
+  longTextMap: Record<string, string>,
+): {
+  inputText: string;
+  cursorPosition: number;
+  longTextMap: Record<string, string>;
+} | null {
+  if (cursorPosition <= 0) {
+    return null;
+  }
+
+  // Word-boundary guard (aligned with CC): only trigger when the char after
+  // the cursor is whitespace or the end of the string.
+  const charAfter = inputText[cursorPosition];
+  if (charAfter !== undefined && !/\s/.test(charAfter)) {
+    return null;
+  }
+
+  const textBefore = inputText.slice(0, cursorPosition);
+  const tokenMatch = textBefore.match(/(^|\s)\[(LongText#\d+|Image #\d+)\]$/);
+  if (!tokenMatch) {
+    return null;
+  }
+
+  const tokenStart = tokenMatch.index! + tokenMatch[1]!.length;
+  const token = tokenMatch[0].slice(tokenMatch[1]!.length);
+  const newLongTextMap = { ...longTextMap };
+  delete newLongTextMap[token];
+
+  return {
+    inputText: inputText.slice(0, tokenStart) + inputText.slice(cursorPosition),
+    cursorPosition: tokenStart,
+    longTextMap: newLongTextMap,
+  };
+}
+
 /**
  * Submit the current input text: extract [Image #N] references, route /btw
  * and CLI-internal slash commands, otherwise send as a message. Returns null
@@ -410,6 +459,7 @@ export type InputAction =
   | { type: "SET_SHOW_PLUGIN_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MODEL_SELECTOR"; payload: boolean }
   | { type: "SET_SHOW_WORKFLOW_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_SKILLS_MANAGER"; payload: boolean }
   | { type: "SET_PERMISSION_MODE"; payload: PermissionMode }
   | { type: "SET_SELECTOR_JUST_USED"; payload: boolean }
   | { type: "INSERT_TEXT_WITH_PLACEHOLDER"; payload: string }
@@ -640,6 +690,12 @@ export function inputReducer(
         showWorkflowManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_SKILLS_MANAGER":
+      return {
+        ...state,
+        showSkillsManager: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_PERMISSION_MODE":
       return { ...state, permissionMode: action.payload };
     case "SET_SELECTOR_JUST_USED":
@@ -823,7 +879,9 @@ export function inputReducer(
       // chunk (e.g. "\x7f\x7f") that ink cannot parse into a key event, so it
       // arrives as raw input and would otherwise be treated as a paste and
       // inserted literally. Treat each DEL as a synchronous backspace instead
-      // (aligned with Claude Code Issue #1853).
+      // (aligned with Claude Code Issue #1853). Each DEL deletes a placeholder
+      // token as a whole block first, falling back to one character (aligned
+      // with Claude Code's useTextInput.ts:442-465).
       if (!key.backspace && !key.delete && input.includes("\x7f")) {
         const delCount = (input.match(/\x7f/g) || []).length;
 
@@ -834,74 +892,92 @@ export function inputReducer(
           };
         }
 
-        if (state.cursorPosition > 0) {
-          const newCursorPosition = Math.max(
-            0,
-            state.cursorPosition - delCount,
-          );
-          const newInputText =
-            state.inputText.substring(0, newCursorPosition) +
-            state.inputText.substring(state.cursorPosition);
-
-          const newState = {
-            ...state,
-            inputText: newInputText,
-            cursorPosition: newCursorPosition,
-            historyIndex: -1,
-          };
-
-          // Deactivate selectors if their trigger character was deleted
-          if (
-            newState.showFileSelector &&
-            newCursorPosition <= newState.atPosition
-          ) {
-            newState.showFileSelector = false;
-            newState.atPosition = -1;
-            newState.fileSearchQuery = "";
-            newState.isFileSearching = false;
-          }
-          if (
-            newState.showCommandSelector &&
-            newCursorPosition <= newState.slashPosition
-          ) {
-            newState.showCommandSelector = false;
-            newState.slashPosition = -1;
-            newState.commandSearchQuery = "";
-          }
-
-          // Reactivate selectors if cursor is within a trigger word
-          const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
-          if (atPos !== -1 && !state.showFileSelector) {
-            newState.showFileSelector = true;
-            newState.atPosition = atPos;
-            newState.isFileSearching = true;
-          }
-          const slashPos = getSlashSelectorPosition(
+        let newInputText = state.inputText;
+        let newCursorPosition = state.cursorPosition;
+        let newLongTextMap = state.longTextMap;
+        for (let i = 0; i < delCount; i++) {
+          const tokenDeletion = deleteTokenBefore(
             newInputText,
             newCursorPosition,
+            newLongTextMap,
           );
-          if (slashPos !== -1 && !state.showCommandSelector) {
-            newState.showCommandSelector = true;
-            newState.slashPosition = slashPos;
+          if (tokenDeletion) {
+            newInputText = tokenDeletion.inputText;
+            newCursorPosition = tokenDeletion.cursorPosition;
+            newLongTextMap = tokenDeletion.longTextMap;
+          } else if (newCursorPosition > 0) {
+            newInputText =
+              newInputText.substring(0, newCursorPosition - 1) +
+              newInputText.substring(newCursorPosition);
+            newCursorPosition -= 1;
           }
+        }
 
-          // Update queries
-          if (newState.showFileSelector && newState.atPosition >= 0) {
-            newState.fileSearchQuery = newInputText.substring(
-              newState.atPosition + 1,
-              newCursorPosition,
-            );
-          }
-          if (newState.showCommandSelector && newState.slashPosition >= 0) {
-            newState.commandSearchQuery = newInputText.substring(
-              newState.slashPosition + 1,
-              newCursorPosition,
-            );
-          }
+        if (
+          newInputText === state.inputText &&
+          newCursorPosition === state.cursorPosition
+        ) {
+          return state;
+        }
 
-          return newState;
+        const newState = {
+          ...state,
+          inputText: newInputText,
+          cursorPosition: newCursorPosition,
+          longTextMap: newLongTextMap,
+          historyIndex: -1,
+        };
+
+        // Deactivate selectors if their trigger character was deleted
+        if (
+          newState.showFileSelector &&
+          newCursorPosition <= newState.atPosition
+        ) {
+          newState.showFileSelector = false;
+          newState.atPosition = -1;
+          newState.fileSearchQuery = "";
+          newState.isFileSearching = false;
         }
-        return state;
+        if (
+          newState.showCommandSelector &&
+          newCursorPosition <= newState.slashPosition
+        ) {
+          newState.showCommandSelector = false;
+          newState.slashPosition = -1;
+          newState.commandSearchQuery = "";
+        }
+
+        // Reactivate selectors if cursor is within a trigger word
+        const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+        if (atPos !== -1 && !state.showFileSelector) {
+          newState.showFileSelector = true;
+          newState.atPosition = atPos;
+          newState.isFileSearching = true;
+        }
+        const slashPos = getSlashSelectorPosition(
+          newInputText,
+          newCursorPosition,
+        );
+        if (slashPos !== -1 && !state.showCommandSelector) {
+          newState.showCommandSelector = true;
+          newState.slashPosition = slashPos;
+        }
+
+        // Update queries
+        if (newState.showFileSelector && newState.atPosition >= 0) {
+          newState.fileSearchQuery = newInputText.substring(
+            newState.atPosition + 1,
+            newCursorPosition,
+          );
+        }
+        if (newState.showCommandSelector && newState.slashPosition >= 0) {
+          newState.commandSearchQuery = newInputText.substring(
+            newState.slashPosition + 1,
+            newCursorPosition,
+          );
+        }
+
+        return newState;
       }
 
       // 1. /btw overlay handling (active while a question is displayed, or
@@ -1425,54 +1501,69 @@ export function inputReducer(
 
       // 8. Backspace / Delete (Normal Mode)
       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;
+        // Placeholder token deletion first (aligned with Claude Code's
+        // deleteTokenBefore, Cursor.ts:937-969): backspace at the end of a
+        // [LongText#N] / [Image #N] token removes the whole token in one
+        // press (and drops its longTextMap entry); otherwise delete one
+        // character. Selector backspace (section 5) stays character-wise —
+        // @mention and /command words are intentionally not tokenized.
+        const tokenDeletion = deleteTokenBefore(
+          state.inputText,
+          state.cursorPosition,
+          state.longTextMap,
+        );
+        if (!tokenDeletion && state.cursorPosition <= 0) {
+          return state;
+        }
+        const newInputText = tokenDeletion
+          ? tokenDeletion.inputText
+          : state.inputText.substring(0, state.cursorPosition - 1) +
+            state.inputText.substring(state.cursorPosition);
+        const newCursorPosition = tokenDeletion
+          ? tokenDeletion.cursorPosition
+          : state.cursorPosition - 1;
 
-          const newState = {
-            ...state,
-            inputText: newInputText,
-            cursorPosition: newCursorPosition,
-            historyIndex: -1,
-          };
+        const newState = {
+          ...state,
+          inputText: newInputText,
+          cursorPosition: newCursorPosition,
+          longTextMap: tokenDeletion
+            ? tokenDeletion.longTextMap
+            : state.longTextMap,
+          historyIndex: -1,
+        };
 
-          // Reactivate selectors if cursor is within word
-          const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
-          if (atPos !== -1 && !state.showFileSelector) {
-            newState.showFileSelector = true;
-            newState.atPosition = atPos;
-            newState.isFileSearching = true;
-          }
+        // Reactivate selectors if cursor is within word
+        const atPos = getAtSelectorPosition(newInputText, newCursorPosition);
+        if (atPos !== -1 && !state.showFileSelector) {
+          newState.showFileSelector = true;
+          newState.atPosition = atPos;
+          newState.isFileSearching = true;
+        }
 
-          const slashPos = getSlashSelectorPosition(
-            newInputText,
+        const slashPos = getSlashSelectorPosition(
+          newInputText,
+          newCursorPosition,
+        );
+        if (slashPos !== -1 && !state.showCommandSelector) {
+          newState.showCommandSelector = true;
+          newState.slashPosition = slashPos;
+        }
+
+        // Update queries
+        if (newState.showFileSelector && newState.atPosition >= 0) {
+          newState.fileSearchQuery = newInputText.substring(
+            newState.atPosition + 1,
+            newCursorPosition,
+          );
+        }
+        if (newState.showCommandSelector && newState.slashPosition >= 0) {
+          newState.commandSearchQuery = newInputText.substring(
+            newState.slashPosition + 1,
             newCursorPosition,
           );
-          if (slashPos !== -1 && !state.showCommandSelector) {
-            newState.showCommandSelector = true;
-            newState.slashPosition = slashPos;
-          }
-
-          // Update queries
-          if (newState.showFileSelector && newState.atPosition >= 0) {
-            newState.fileSearchQuery = newInputText.substring(
-              newState.atPosition + 1,
-              newCursorPosition,
-            );
-          }
-          if (newState.showCommandSelector && newState.slashPosition >= 0) {
-            newState.commandSearchQuery = newInputText.substring(
-              newState.slashPosition + 1,
-              newCursorPosition,
-            );
-          }
-          return newState;
         }
+        return newState;
       }
 
       // 9. Cursor Movement (Normal Mode)

package/src/print-cli.ts

@@ -147,6 +147,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
         worktreeName: worktreeSession.name,
         isNew: worktreeSession.isNew,
         repoRoot: worktreeSession.repoRoot,
+        hookBased: worktreeSession.hookBased,
       };
       agent.setWorktreeSession(session);
     }
@@ -186,8 +187,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     // Display timing information
     displayTimingInfo(startTime, showStats);
 
-    // Trigger WorktreeRemove hook (before destroy — it needs a live agent) and
-    // decide whether the worktree is clean enough to remove
+    // Decide whether the worktree is clean enough to remove
     let cleanWorktree = false;
     if (worktreeSession) {
       const cwd = workdir || worktreeSession.path;
@@ -196,9 +196,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       const hasCommits = hasNewCommits(cwd, baseBranch);
       cleanWorktree = !hasChanges && !hasCommits;
 
-      if (cleanWorktree) {
-        await agent.triggerWorktreeRemoveHook(worktreeSession.path);
-      } else {
+      if (!cleanWorktree) {
         process.stdout.write(
           `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
         );
@@ -211,11 +209,17 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     // Handle worktree cleanup for print mode (git removal stays after destroy)
     if (worktreeSession && cleanWorktree) {
       try {
-        validateWorktreeRemovalPath(
-          worktreeSession.path,
-          worktreeSession.repoRoot,
-        );
+        // Hook-based worktrees are owned by the hook; the git-root
+        // containment check does not apply to them
+        if (!worktreeSession.hookBased) {
+          validateWorktreeRemovalPath(
+            worktreeSession.path,
+            worktreeSession.repoRoot,
+          );
+        }
+        process.stdout.write("\nDeleting worktree ...\n");
         await removeWorktree(worktreeSession);
+        process.stdout.write("Done.\n");
       } catch (error) {
         // Never block print-mode exit on worktree cleanup failures
         process.stdout.write(
@@ -242,7 +246,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       // Display timing information even on error
       displayTimingInfo(startTime, showStats);
 
-      // Trigger WorktreeRemove hook (before destroy) when the worktree is clean
+      // Decide whether the worktree is clean enough to remove
       let cleanWorktree = false;
       if (worktreeSession) {
         const cwd = workdir || worktreeSession.path;
@@ -251,9 +255,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
         const hasCommits = hasNewCommits(cwd, baseBranch);
         cleanWorktree = !hasChanges && !hasCommits;
 
-        if (cleanWorktree) {
-          await agent.triggerWorktreeRemoveHook(worktreeSession.path);
-        } else {
+        if (!cleanWorktree) {
           process.stdout.write(
             `\n⚠️ Worktree '${worktreeSession.name}' has changes or commits. Keeping it at: ${worktreeSession.path}\n`,
           );
@@ -265,11 +267,17 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       // Handle worktree cleanup for print mode even on error
       if (worktreeSession && cleanWorktree) {
         try {
-          validateWorktreeRemovalPath(
-            worktreeSession.path,
-            worktreeSession.repoRoot,
-          );
+          // Hook-based worktrees are owned by the hook; the git-root
+          // containment check does not apply to them
+          if (!worktreeSession.hookBased) {
+            validateWorktreeRemovalPath(
+              worktreeSession.path,
+              worktreeSession.repoRoot,
+            );
+          }
+          process.stdout.write("\nDeleting worktree ...\n");
           await removeWorktree(worktreeSession);
+          process.stdout.write("Done.\n");
         } catch (error) {
           process.stdout.write(
             `\n⚠️ Skipping worktree removal: ${(error as Error).message}\n`,

package/src/reducers/selectorReducer.ts

@@ -4,6 +4,10 @@ export interface SelectorState<T = unknown> {
   selectedIndex: number;
   pendingDecision: "select" | "insert" | "cancel" | null;
   items: T[];
+  /** View state: show sessions from all projects (Ctrl+A toggle). */
+  showAllProjects?: boolean;
+  /** View state: show sessions from all same-repo worktrees (Ctrl+W toggle). */
+  showAllWorktrees?: boolean;
 }
 
 export type SelectorAction<T = unknown> =
@@ -12,6 +16,8 @@ export type SelectorAction<T = unknown> =
   | { type: "RESET_INDEX" }
   | { type: "SET_ITEMS"; items: T[] }
   | { type: "HANDLE_KEY"; key: Key; hasInsert: boolean }
+  | { type: "TOGGLE_ALL_PROJECTS" }
+  | { type: "TOGGLE_ALL_WORKTREES" }
   | { type: "CLEAR_DECISION" };
 
 export function selectorReducer<T = unknown>(
@@ -33,6 +39,10 @@ export function selectorReducer<T = unknown>(
       return { ...state, selectedIndex: 0 };
     case "SET_ITEMS":
       return { ...state, items: action.items, selectedIndex: 0 };
+    case "TOGGLE_ALL_PROJECTS":
+      return { ...state, showAllProjects: !state.showAllProjects };
+    case "TOGGLE_ALL_WORKTREES":
+      return { ...state, showAllWorktrees: !state.showAllWorktrees };
     case "HANDLE_KEY":
       if (action.key.upArrow) {
         return {

package/src/reducers/skillsManagerReducer.ts

@@ -0,0 +1,91 @@
+import { Key } from "ink";
+
+export type PendingEffect = { type: "CANCEL" };
+
+export interface SkillsManagerState {
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+  pendingEffect: PendingEffect | null;
+}
+
+export type SkillsManagerAction =
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN"; itemCount: number }
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      itemCount: number;
+    }
+  | { type: "CLEAR_PENDING_EFFECT" };
+
+export function skillsManagerReducer(
+  state: SkillsManagerState,
+  action: SkillsManagerAction,
+): SkillsManagerState {
+  switch (action.type) {
+    case "MOVE_UP":
+      return {
+        ...state,
+        selectedIndex: Math.max(0, state.selectedIndex - 1),
+      };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          Math.max(0, action.itemCount - 1),
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.viewMode };
+    case "HANDLE_KEY": {
+      const { key, itemCount } = action;
+
+      if (key.return) {
+        if (state.viewMode === "list") {
+          return { ...state, viewMode: "detail" };
+        }
+        // Aligned with AgentsManager detail view: Enter returns to the list.
+        return { ...state, viewMode: "list" };
+      }
+
+      if (key.escape) {
+        if (state.viewMode === "detail") {
+          return { ...state, viewMode: "list" };
+        }
+        return { ...state, pendingEffect: { type: "CANCEL" } };
+      }
+
+      // Detail view does not respond to arrow keys (aligned with
+      // AgentsManager, which only Esc/Enter back to the list).
+      if (state.viewMode === "detail") {
+        return state;
+      }
+
+      if (key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+
+      if (key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(
+            Math.max(0, itemCount - 1),
+            state.selectedIndex + 1,
+          ),
+        };
+      }
+
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
+    default:
+      return state;
+  }
+}