wave-code 0.14.3 → 0.15.0

package/dist/reducers/questionReducer.js

@@ -189,6 +189,183 @@ export function questionReducer(state, action) {
                 };
             }
         }
+        case "CLEAR_DECISION":
+            return { ...state, decision: null };
+        case "HANDLE_KEY": {
+            const { input, key, currentQuestion, questions } = action;
+            if (!currentQuestion)
+                return state;
+            const options = [...currentQuestion.options, { label: "Other" }];
+            const isMultiSelect = currentQuestion.multiSelect;
+            if (key.return) {
+                const isOtherFocused = state.selectedOptionIndex === options.length - 1;
+                let answer = "";
+                if (isMultiSelect) {
+                    const selectedLabels = Array.from(state.selectedOptionIndices)
+                        .filter((i) => i < currentQuestion.options.length)
+                        .map((i) => currentQuestion.options[i].label);
+                    const isOtherChecked = state.selectedOptionIndices.has(options.length - 1);
+                    if (isOtherChecked && state.otherText.trim()) {
+                        selectedLabels.push(state.otherText.trim());
+                    }
+                    answer = selectedLabels.join(", ");
+                }
+                else {
+                    if (isOtherFocused) {
+                        answer = state.otherText.trim();
+                    }
+                    else {
+                        answer = options[state.selectedOptionIndex].label;
+                    }
+                }
+                if (!answer)
+                    return state;
+                const newAnswers = {
+                    ...state.userAnswers,
+                    [currentQuestion.question]: answer,
+                };
+                if (state.currentQuestionIndex < questions.length - 1) {
+                    const nextIndex = state.currentQuestionIndex + 1;
+                    const savedStates = {
+                        ...state.savedStates,
+                        [state.currentQuestionIndex]: {
+                            selectedOptionIndex: state.selectedOptionIndex,
+                            selectedOptionIndices: state.selectedOptionIndices,
+                            otherText: state.otherText,
+                            otherCursorPosition: state.otherCursorPosition,
+                        },
+                    };
+                    const nextState = savedStates[nextIndex] || {
+                        selectedOptionIndex: 0,
+                        selectedOptionIndices: new Set(),
+                        otherText: "",
+                        otherCursorPosition: 0,
+                    };
+                    return {
+                        ...state,
+                        currentQuestionIndex: nextIndex,
+                        ...nextState,
+                        userAnswers: newAnswers,
+                        savedStates,
+                    };
+                }
+                else {
+                    const finalAnswers = { ...newAnswers };
+                    for (const [idxStr, s] of Object.entries(state.savedStates)) {
+                        const idx = parseInt(idxStr);
+                        const q = questions[idx];
+                        if (q && !finalAnswers[q.question]) {
+                            const a = buildAnswerFromSavedState(q, s);
+                            if (a)
+                                finalAnswers[q.question] = a;
+                        }
+                    }
+                    const allAnswered = questions.every((q) => finalAnswers[q.question]);
+                    if (!allAnswered)
+                        return state;
+                    return {
+                        ...state,
+                        userAnswers: finalAnswers,
+                        decision: {
+                            behavior: "allow",
+                            message: JSON.stringify(finalAnswers),
+                        },
+                    };
+                }
+            }
+            if (input === " ") {
+                const isOtherFocused = state.selectedOptionIndex === options.length - 1;
+                if (isMultiSelect &&
+                    (!isOtherFocused ||
+                        !state.selectedOptionIndices.has(state.selectedOptionIndex))) {
+                    const nextIndices = new Set(state.selectedOptionIndices);
+                    if (nextIndices.has(state.selectedOptionIndex))
+                        nextIndices.delete(state.selectedOptionIndex);
+                    else
+                        nextIndices.add(state.selectedOptionIndex);
+                    return { ...state, selectedOptionIndices: nextIndices };
+                }
+            }
+            if (key.upArrow) {
+                return {
+                    ...state,
+                    selectedOptionIndex: Math.max(0, state.selectedOptionIndex - 1),
+                };
+            }
+            if (key.downArrow) {
+                return {
+                    ...state,
+                    selectedOptionIndex: Math.min(options.length - 1, state.selectedOptionIndex + 1),
+                };
+            }
+            if (key.tab) {
+                const direction = key.shift ? -1 : 1;
+                let nextIndex = state.currentQuestionIndex + direction;
+                if (nextIndex < 0)
+                    nextIndex = questions.length - 1;
+                if (nextIndex >= questions.length)
+                    nextIndex = 0;
+                if (nextIndex === state.currentQuestionIndex)
+                    return state;
+                const savedStates = {
+                    ...state.savedStates,
+                    [state.currentQuestionIndex]: {
+                        selectedOptionIndex: state.selectedOptionIndex,
+                        selectedOptionIndices: state.selectedOptionIndices,
+                        otherText: state.otherText,
+                        otherCursorPosition: state.otherCursorPosition,
+                    },
+                };
+                const nextState = savedStates[nextIndex] || {
+                    selectedOptionIndex: 0,
+                    selectedOptionIndices: new Set(),
+                    otherText: "",
+                    otherCursorPosition: 0,
+                };
+                return {
+                    ...state,
+                    currentQuestionIndex: nextIndex,
+                    ...nextState,
+                    savedStates,
+                };
+            }
+            if (state.selectedOptionIndex === options.length - 1) {
+                if (key.leftArrow) {
+                    return {
+                        ...state,
+                        otherCursorPosition: Math.max(0, state.otherCursorPosition - 1),
+                    };
+                }
+                if (key.rightArrow) {
+                    return {
+                        ...state,
+                        otherCursorPosition: Math.min(state.otherText.length, state.otherCursorPosition + 1),
+                    };
+                }
+                if (key.backspace || key.delete) {
+                    if (state.otherCursorPosition > 0) {
+                        return {
+                            ...state,
+                            otherText: state.otherText.slice(0, state.otherCursorPosition - 1) +
+                                state.otherText.slice(state.otherCursorPosition),
+                            otherCursorPosition: state.otherCursorPosition - 1,
+                        };
+                    }
+                    return state;
+                }
+                if (input && !key.ctrl && !key.meta) {
+                    const newText = state.otherText.slice(0, state.otherCursorPosition) +
+                        input +
+                        state.otherText.slice(state.otherCursorPosition);
+                    return {
+                        ...state,
+                        otherText: newText,
+                        otherCursorPosition: state.otherCursorPosition + input.length,
+                    };
+                }
+            }
+            return state;
+        }
         default:
             return state;
     }

package/dist/reducers/rewindSelectorReducer.d.ts

@@ -0,0 +1,22 @@
+import { Key } from "ink";
+export interface SelectorState {
+    selectedIndex: number;
+    pendingDecision: "select" | "cancel" | null;
+}
+export type SelectorAction = {
+    type: "MOVE_UP";
+} | {
+    type: "MOVE_DOWN";
+    maxIndex: number;
+} | {
+    type: "RESET_INDEX";
+    index: number;
+} | {
+    type: "HANDLE_KEY";
+    key: Key;
+    maxIndex: number;
+} | {
+    type: "CLEAR_DECISION";
+};
+export declare function rewindSelectorReducer(state: SelectorState, action: SelectorAction): SelectorState;
+//# sourceMappingURL=rewindSelectorReducer.d.ts.map

package/dist/reducers/rewindSelectorReducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewindSelectorReducer.d.ts","sourceRoot":"","sources":["../../src/reducers/rewindSelectorReducer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE/B,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,cAAc,GACrB,aAAa,CAoCf"}

package/dist/reducers/rewindSelectorReducer.js

@@ -0,0 +1,37 @@
+export function rewindSelectorReducer(state, action) {
+    switch (action.type) {
+        case "MOVE_UP":
+            return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
+        case "MOVE_DOWN":
+            return {
+                ...state,
+                selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+            };
+        case "RESET_INDEX":
+            return { ...state, selectedIndex: action.index };
+        case "HANDLE_KEY":
+            if (action.key.upArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.max(0, state.selectedIndex - 1),
+                };
+            }
+            if (action.key.downArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+                };
+            }
+            if (action.key.return) {
+                return { ...state, pendingDecision: "select" };
+            }
+            if (action.key.escape) {
+                return { ...state, pendingDecision: "cancel" };
+            }
+            return state;
+        case "CLEAR_DECISION":
+            return { ...state, pendingDecision: null };
+        default:
+            return state;
+    }
+}

package/dist/reducers/selectorReducer.d.ts

@@ -0,0 +1,22 @@
+import { Key } from "ink";
+export interface SelectorState {
+    selectedIndex: number;
+    pendingDecision: "select" | "insert" | "cancel" | null;
+}
+export type SelectorAction = {
+    type: "MOVE_UP";
+} | {
+    type: "MOVE_DOWN";
+    maxIndex: number;
+} | {
+    type: "RESET_INDEX";
+} | {
+    type: "HANDLE_KEY";
+    key: Key;
+    maxIndex: number;
+    hasInsert: boolean;
+} | {
+    type: "CLEAR_DECISION";
+};
+export declare function selectorReducer(state: SelectorState, action: SelectorAction): SelectorState;
+//# sourceMappingURL=selectorReducer.d.ts.map

package/dist/reducers/selectorReducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectorReducer.d.ts","sourceRoot":"","sources":["../../src/reducers/selectorReducer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;CACxD;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GACtE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE/B,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,cAAc,GACrB,aAAa,CAuCf"}

package/dist/reducers/selectorReducer.js

@@ -0,0 +1,40 @@
+export function selectorReducer(state, action) {
+    switch (action.type) {
+        case "MOVE_UP":
+            return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
+        case "MOVE_DOWN":
+            return {
+                ...state,
+                selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+            };
+        case "RESET_INDEX":
+            return { ...state, selectedIndex: 0 };
+        case "HANDLE_KEY":
+            if (action.key.upArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.max(0, state.selectedIndex - 1),
+                };
+            }
+            if (action.key.downArrow) {
+                return {
+                    ...state,
+                    selectedIndex: Math.min(action.maxIndex, state.selectedIndex + 1),
+                };
+            }
+            if (action.key.return) {
+                return { ...state, pendingDecision: "select" };
+            }
+            if (action.key.tab && action.hasInsert) {
+                return { ...state, pendingDecision: "insert" };
+            }
+            if (action.key.escape) {
+                return { ...state, pendingDecision: "cancel" };
+            }
+            return state;
+        case "CLEAR_DECISION":
+            return { ...state, pendingDecision: null };
+        default:
+            return state;
+    }
+}

package/dist/utils/inputUtils.d.ts

@@ -0,0 +1,18 @@
+export declare const expandLongTextPlaceholders: (text: string, longTextMap: Record<string, string>) => string;
+export declare const getAtSelectorPosition: (text: string, cursorPosition: number) => number;
+export declare const getSlashSelectorPosition: (text: string, cursorPosition: number) => number;
+export declare const getWordEnd: (text: string, startPos: number) => number;
+export declare const SELECTOR_TRIGGERS: readonly [{
+    readonly char: "@";
+    readonly type: "ACTIVATE_FILE_SELECTOR";
+    readonly shouldActivate: (char: string, pos: number, text: string) => boolean;
+}, {
+    readonly char: "/";
+    readonly type: "ACTIVATE_COMMAND_SELECTOR";
+    readonly shouldActivate: (char: string, pos: number, text: string, showFileSelector: boolean) => boolean;
+}];
+export declare const getProjectedState: (inputText: string, cursorPosition: number, char: string) => {
+    newInputText: string;
+    newCursorPosition: number;
+};
+//# sourceMappingURL=inputUtils.d.ts.map

package/dist/utils/inputUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputUtils.d.ts","sourceRoot":"","sources":["../../src/utils/inputUtils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,GACrC,MAAM,MAAM,EACZ,aAAa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAClC,MAcF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,gBAAgB,MAAM,KACrB,MAYF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,MAAM,MAAM,EACZ,gBAAgB,MAAM,KACrB,MAYF,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,UAAU,MAAM,KAAG,MAM3D,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;oCAIH,MAAM,OAAO,MAAM,QAAQ,MAAM;;;;oCAOhD,MAAM,OACP,MAAM,QACL,MAAM,oBACM,OAAO;EAMrB,CAAC;AAEX,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,MAAM,MAAM;;;CAOb,CAAC"}

package/dist/utils/inputUtils.js

@@ -0,0 +1,67 @@
+export const expandLongTextPlaceholders = (text, longTextMap) => {
+    let expandedText = text;
+    const longTextRegex = /\[LongText#(\d+)\]/g;
+    const matches = [...text.matchAll(longTextRegex)];
+    for (const match of matches) {
+        const placeholder = match[0];
+        const originalText = longTextMap[placeholder];
+        if (originalText) {
+            expandedText = expandedText.replace(placeholder, originalText);
+        }
+    }
+    return expandedText;
+};
+export const getAtSelectorPosition = (text, cursorPosition) => {
+    let i = cursorPosition - 1;
+    while (i >= 0 && !/\s/.test(text[i])) {
+        if (text[i] === "@") {
+            if (i === 0 || /\s/.test(text[i - 1])) {
+                return i;
+            }
+            break;
+        }
+        i--;
+    }
+    return -1;
+};
+export const getSlashSelectorPosition = (text, cursorPosition) => {
+    let i = cursorPosition - 1;
+    while (i >= 0 && !/\s/.test(text[i])) {
+        if (text[i] === "/") {
+            if (i === 0 || /\s/.test(text[i - 1])) {
+                return i;
+            }
+            break;
+        }
+        i--;
+    }
+    return -1;
+};
+export const getWordEnd = (text, startPos) => {
+    let i = startPos;
+    while (i < text.length && !/\s/.test(text[i])) {
+        i++;
+    }
+    return i;
+};
+export const SELECTOR_TRIGGERS = [
+    {
+        char: "@",
+        type: "ACTIVATE_FILE_SELECTOR",
+        shouldActivate: (char, pos, text) => char === "@" && (pos === 1 || /\s/.test(text[pos - 2])),
+    },
+    {
+        char: "/",
+        type: "ACTIVATE_COMMAND_SELECTOR",
+        shouldActivate: (char, pos, text, showFileSelector) => char === "/" &&
+            !showFileSelector &&
+            (pos === 1 || /\s/.test(text[pos - 2])),
+    },
+];
+export const getProjectedState = (inputText, cursorPosition, char) => {
+    const beforeCursor = inputText.substring(0, cursorPosition);
+    const afterCursor = inputText.substring(cursorPosition);
+    const newInputText = beforeCursor + char + afterCursor;
+    const newCursorPosition = cursorPosition + char.length;
+    return { newInputText, newCursorPosition };
+};

package/dist/utils/worktree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/utils/worktree.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CA+EzE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CA6D7D"}
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/utils/worktree.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAyEzE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CA6D7D"}

package/dist/utils/worktree.js

@@ -10,8 +10,7 @@ import { getDefaultRemoteBranch, getGitMainRepoRoot } from "wave-agent-sdk";
  */
 export function createWorktree(name, cwd) {
     const repoRoot = getGitMainRepoRoot(cwd);
-    const projectName = path.basename(repoRoot);
-    const worktreePath = path.join(repoRoot, "..", `${projectName}.worktrees`, name);
+    const worktreePath = path.join(repoRoot, ".wave", "worktrees", name);
     const branchName = `worktree-${name}`;
     const baseBranch = getDefaultRemoteBranch(cwd);
     // Ensure parent directory exists

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.14.3",
+  "version": "0.15.0",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -42,7 +42,7 @@
     "semver": "^7.7.4",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "0.14.3"
+    "wave-agent-sdk": "0.15.0"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/acp/agent.ts

@@ -201,6 +201,7 @@ export class WaveAcpAgent implements AcpAgent {
         onPermissionModeChange: (mode) =>
           callbacks.onPermissionModeChange?.(mode),
         onModelChange: (model) => callbacks.onModelChange?.(model),
+        onUserMessageAdded: (params) => callbacks.onUserMessageAdded?.(params),
       },
     });
 
@@ -992,6 +993,15 @@ export class WaveAcpAgent implements AcpAgent {
           });
         }
       },
+      onUserMessageAdded: (params) => {
+        this.connection.sessionUpdate({
+          sessionId: sessionId as AcpSessionId,
+          update: {
+            sessionUpdate: "user_message_chunk",
+            content: { type: "text", text: params.content },
+          },
+        });
+      },
     };
   }
 }

package/src/components/BackgroundTaskManager.tsx

@@ -24,8 +24,26 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
     viewMode: "list",
     detailTaskId: null,
     detailOutput: null,
+    pendingEffect: null,
   } as BackgroundTaskManagerState);
 
+  // Handle pending effects
+  useEffect(() => {
+    if (!state.pendingEffect) return;
+
+    const effect = state.pendingEffect;
+    dispatch({ type: "CLEAR_PENDING_EFFECT" });
+
+    switch (effect.type) {
+      case "CANCEL":
+        onCancel();
+        break;
+      case "STOP_TASK":
+        stopBackgroundTask(effect.taskId);
+        break;
+    }
+  }, [state.pendingEffect, onCancel, stopBackgroundTask]);
+
   const { tasks, selectedIndex, viewMode, detailTaskId, detailOutput } = state;
 
   // Convert backgroundTasks to local Task format
@@ -65,10 +83,6 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
     return new Date(timestamp).toLocaleTimeString();
   };
 
-  const stopTask = (taskId: string) => {
-    stopBackgroundTask(taskId);
-  };
-
   // Calculate visible window
   const startIndex = Math.max(
     0,
@@ -80,60 +94,7 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
   const visibleTasks = tasks.slice(startIndex, startIndex + MAX_VISIBLE_ITEMS);
 
   useInput((input, key) => {
-    if (viewMode === "list") {
-      // List mode navigation
-      if (key.return) {
-        if (tasks.length > 0 && selectedIndex < tasks.length) {
-          const selectedTask = tasks[selectedIndex];
-          dispatch({ type: "SET_DETAIL_TASK_ID", id: selectedTask.id });
-          dispatch({ type: "SET_VIEW_MODE", mode: "detail" });
-        }
-        return;
-      }
-
-      if (key.escape) {
-        onCancel();
-        return;
-      }
-
-      if (key.upArrow) {
-        dispatch({
-          type: "SELECT_INDEX",
-          index: Math.max(0, selectedIndex - 1),
-        });
-        return;
-      }
-
-      if (key.downArrow) {
-        dispatch({
-          type: "SELECT_INDEX",
-          index: Math.min(tasks.length - 1, selectedIndex + 1),
-        });
-        return;
-      }
-
-      if (input === "k" && tasks.length > 0 && selectedIndex < tasks.length) {
-        const selectedTask = tasks[selectedIndex];
-        if (selectedTask.status === "running") {
-          stopTask(selectedTask.id);
-        }
-        return;
-      }
-    } else if (viewMode === "detail") {
-      // Detail mode navigation
-      if (key.escape) {
-        dispatch({ type: "RESET_DETAIL" });
-        return;
-      }
-
-      if (input === "k" && detailTaskId) {
-        const task = tasks.find((t) => t.id === detailTaskId);
-        if (task && task.status === "running") {
-          stopTask(detailTaskId);
-        }
-        return;
-      }
-    }
+    dispatch({ type: "HANDLE_KEY", input, key });
   });
 
   if (viewMode === "detail" && detailTaskId && detailOutput) {