wave-code 0.14.4 → 0.15.1

package/src/reducers/questionReducer.ts

@@ -1,3 +1,4 @@
+import { Key } from "ink";
 import type { PermissionDecision } from "wave-agent-sdk";
 
 export interface QuestionSavedState {
@@ -45,6 +46,22 @@ export type QuestionAction =
         options: Array<{ label: string }>;
         multiSelect?: boolean;
       }>;
+    }
+  | { type: "CLEAR_DECISION" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      currentQuestion: {
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      };
+      questions: Array<{
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      }>;
     };
 
 function buildAnswerFromSavedState(
@@ -245,6 +262,193 @@ export function questionReducer(
         };
       }
     }
+    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<number>(),
+            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<number>(),
+          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/src/reducers/rewindSelectorReducer.ts

@@ -0,0 +1,54 @@
+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 function rewindSelectorReducer(
+  state: SelectorState,
+  action: SelectorAction,
+): SelectorState {
+  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/src/reducers/selectorReducer.ts

@@ -0,0 +1,57 @@
+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 function selectorReducer(
+  state: SelectorState,
+  action: SelectorAction,
+): SelectorState {
+  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/src/utils/inputUtils.ts

@@ -0,0 +1,94 @@
+export const expandLongTextPlaceholders = (
+  text: string,
+  longTextMap: Record<string, string>,
+): string => {
+  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: string,
+  cursorPosition: number,
+): number => {
+  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: string,
+  cursorPosition: number,
+): number => {
+  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: string, startPos: number): number => {
+  let i = startPos;
+  while (i < text.length && !/\s/.test(text[i])) {
+    i++;
+  }
+  return i;
+};
+
+export const SELECTOR_TRIGGERS = [
+  {
+    char: "@",
+    type: "ACTIVATE_FILE_SELECTOR" as const,
+    shouldActivate: (char: string, pos: number, text: string) =>
+      char === "@" && (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+  {
+    char: "/",
+    type: "ACTIVATE_COMMAND_SELECTOR" as const,
+    shouldActivate: (
+      char: string,
+      pos: number,
+      text: string,
+      showFileSelector: boolean,
+    ) =>
+      char === "/" &&
+      !showFileSelector &&
+      (pos === 1 || /\s/.test(text[pos - 2])),
+  },
+] as const;
+
+export const getProjectedState = (
+  inputText: string,
+  cursorPosition: number,
+  char: string,
+) => {
+  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/src/utils/worktree.ts

@@ -21,13 +21,7 @@ export interface WorktreeSession {
  */
 export function createWorktree(name: string, cwd: string): WorktreeSession {
   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);