wave-code 0.13.6 → 0.14.0

package/src/managers/inputReducer.ts

@@ -173,6 +173,10 @@ export type InputAction =
   | { type: "CLEAR_INPUT" }
   | { type: "START_PASTE"; payload: { buffer: string; cursorPosition: number } }
   | { type: "APPEND_PASTE_BUFFER"; payload: string }
+  | {
+      type: "APPEND_PASTE_CHUNK";
+      payload: { chunk: string; cursorPosition: number };
+    }
   | { type: "END_PASTE" }
   | {
       type: "ADD_IMAGE_AND_INSERT_PLACEHOLDER";
@@ -407,6 +411,21 @@ export function inputReducer(
         cursorPosition: 0,
         historyIndex: -1,
       };
+    case "APPEND_PASTE_CHUNK": {
+      // The reducer determines if this is a new paste or a continuation
+      // by checking if pasteBuffer is already set. This avoids the
+      // handler needing to track isPasting state, which can be stale
+      // when multiple dispatches fire before React state updates.
+      const isNewPaste = !state.pasteBuffer;
+      return {
+        ...state,
+        isPasting: true,
+        pasteBuffer: state.pasteBuffer + action.payload.chunk,
+        initialPasteCursorPosition: isNewPaste
+          ? action.payload.cursorPosition
+          : state.initialPasteCursorPosition,
+      };
+    }
     case "START_PASTE":
       return {
         ...state,

package/src/reducers/confirmationReducer.ts

@@ -0,0 +1,74 @@
+import type { PermissionDecision } from "wave-agent-sdk";
+
+export interface ConfirmationState {
+  selectedOption: "clear" | "auto" | "allow" | "alternative";
+  alternativeText: string;
+  alternativeCursorPosition: number;
+  hasUserInput: boolean;
+  decision: PermissionDecision | null;
+}
+
+export type ConfirmationAction =
+  | { type: "SELECT_OPTION"; option: ConfirmationState["selectedOption"] }
+  | { type: "INSERT_TEXT"; text: string }
+  | { type: "BACKSPACE" }
+  | { type: "MOVE_CURSOR_LEFT" }
+  | { type: "MOVE_CURSOR_RIGHT" }
+  | { type: "CONFIRM"; decision: PermissionDecision };
+
+export function confirmationReducer(
+  state: ConfirmationState,
+  action: ConfirmationAction,
+): ConfirmationState {
+  switch (action.type) {
+    case "SELECT_OPTION":
+      return { ...state, selectedOption: action.option };
+    case "INSERT_TEXT": {
+      const nextText =
+        state.alternativeText.slice(0, state.alternativeCursorPosition) +
+        action.text +
+        state.alternativeText.slice(state.alternativeCursorPosition);
+      return {
+        ...state,
+        selectedOption: "alternative",
+        alternativeText: nextText,
+        alternativeCursorPosition:
+          state.alternativeCursorPosition + action.text.length,
+        hasUserInput: true,
+      };
+    }
+    case "BACKSPACE": {
+      if (state.alternativeCursorPosition <= 0) return state;
+      const nextText =
+        state.alternativeText.slice(0, state.alternativeCursorPosition - 1) +
+        state.alternativeText.slice(state.alternativeCursorPosition);
+      return {
+        ...state,
+        selectedOption: "alternative",
+        alternativeText: nextText,
+        alternativeCursorPosition: state.alternativeCursorPosition - 1,
+        hasUserInput: nextText.length > 0,
+      };
+    }
+    case "MOVE_CURSOR_LEFT":
+      return {
+        ...state,
+        alternativeCursorPosition: Math.max(
+          0,
+          state.alternativeCursorPosition - 1,
+        ),
+      };
+    case "MOVE_CURSOR_RIGHT":
+      return {
+        ...state,
+        alternativeCursorPosition: Math.min(
+          state.alternativeText.length,
+          state.alternativeCursorPosition + 1,
+        ),
+      };
+    case "CONFIRM":
+      return { ...state, decision: action.decision };
+    default:
+      return state;
+  }
+}

package/src/reducers/questionReducer.ts

@@ -0,0 +1,251 @@
+import type { PermissionDecision } from "wave-agent-sdk";
+
+export interface QuestionSavedState {
+  selectedOptionIndex: number;
+  selectedOptionIndices: Set<number>;
+  otherText: string;
+  otherCursorPosition: number;
+}
+
+export interface QuestionState {
+  currentQuestionIndex: number;
+  selectedOptionIndex: number;
+  selectedOptionIndices: Set<number>;
+  userAnswers: Record<string, string>;
+  otherText: string;
+  otherCursorPosition: number;
+  savedStates: Record<number, QuestionSavedState>;
+  decision: PermissionDecision | null;
+}
+
+export type QuestionAction =
+  | { type: "SELECT_OPTION"; index: number }
+  | { type: "MOVE_OPTION_UP"; maxIndex: number }
+  | { type: "MOVE_OPTION_DOWN"; maxIndex: number }
+  | {
+      type: "TOGGLE_MULTI_SELECT";
+      optionsLength: number;
+    }
+  | { type: "CYCLE_QUESTION"; shift: boolean; questionCount: number }
+  | { type: "INSERT_OTHER"; text: string; optionsLength: number }
+  | { type: "DELETE_OTHER"; optionsLength: number }
+  | { type: "MOVE_OTHER_LEFT"; optionsLength: number }
+  | { type: "MOVE_OTHER_RIGHT"; optionsLength: number }
+  | {
+      type: "CONFIRM_ANSWER";
+      currentQuestion: {
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      };
+      options: Array<{ label: string }>;
+      isMultiSelect: boolean;
+      questions: Array<{
+        question: string;
+        options: Array<{ label: string }>;
+        multiSelect?: boolean;
+      }>;
+    };
+
+function buildAnswerFromSavedState(
+  q: {
+    question: string;
+    options: Array<{ label: string }>;
+    multiSelect?: boolean;
+  },
+  s: QuestionSavedState,
+): string {
+  const opts = [...q.options, { label: "Other" }];
+  let a = "";
+  if (q.multiSelect) {
+    const selectedLabels = Array.from(s.selectedOptionIndices)
+      .filter((i) => i < q.options.length)
+      .map((i) => q.options[i].label);
+    const isOtherChecked = s.selectedOptionIndices.has(opts.length - 1);
+    if (isOtherChecked && s.otherText.trim()) {
+      selectedLabels.push(s.otherText.trim());
+    }
+    a = selectedLabels.join(", ");
+  } else {
+    if (s.selectedOptionIndex === opts.length - 1) {
+      a = s.otherText.trim();
+    } else {
+      a = opts[s.selectedOptionIndex].label;
+    }
+  }
+  return a;
+}
+
+export function questionReducer(
+  state: QuestionState,
+  action: QuestionAction,
+): QuestionState {
+  switch (action.type) {
+    case "SELECT_OPTION":
+      return { ...state, selectedOptionIndex: action.index };
+    case "MOVE_OPTION_UP":
+      return {
+        ...state,
+        selectedOptionIndex: Math.max(0, state.selectedOptionIndex - 1),
+      };
+    case "MOVE_OPTION_DOWN":
+      return {
+        ...state,
+        selectedOptionIndex: Math.min(
+          action.maxIndex,
+          state.selectedOptionIndex + 1,
+        ),
+      };
+    case "TOGGLE_MULTI_SELECT": {
+      const nextIndices = new Set(state.selectedOptionIndices);
+      if (nextIndices.has(state.selectedOptionIndex))
+        nextIndices.delete(state.selectedOptionIndex);
+      else nextIndices.add(state.selectedOptionIndex);
+      return { ...state, selectedOptionIndices: nextIndices };
+    }
+    case "CYCLE_QUESTION": {
+      const direction = action.shift ? -1 : 1;
+      let nextIndex = state.currentQuestionIndex + direction;
+      if (nextIndex < 0) nextIndex = action.questionCount - 1;
+      if (nextIndex >= action.questionCount) 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,
+      };
+    }
+    case "INSERT_OTHER": {
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      const newText =
+        state.otherText.slice(0, state.otherCursorPosition) +
+        action.text +
+        state.otherText.slice(state.otherCursorPosition);
+      return {
+        ...state,
+        otherText: newText,
+        otherCursorPosition: state.otherCursorPosition + action.text.length,
+      };
+    }
+    case "DELETE_OTHER":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      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;
+    case "MOVE_OTHER_LEFT":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      return {
+        ...state,
+        otherCursorPosition: Math.max(0, state.otherCursorPosition - 1),
+      };
+    case "MOVE_OTHER_RIGHT":
+      if (state.selectedOptionIndex !== action.optionsLength - 1) return state;
+      return {
+        ...state,
+        otherCursorPosition: Math.min(
+          state.otherText.length,
+          state.otherCursorPosition + 1,
+        ),
+      };
+    case "CONFIRM_ANSWER": {
+      const { currentQuestion: cq, options, isMultiSelect, questions } = action;
+      const isOtherFocused = state.selectedOptionIndex === options.length - 1;
+      let answer = "";
+      if (isMultiSelect) {
+        const selectedLabels = Array.from(state.selectedOptionIndices)
+          .filter((i) => i < cq.options.length)
+          .map((i) => cq.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,
+        [cq.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),
+          },
+        };
+      }
+    }
+    default:
+      return state;
+  }
+}