wave-code 1.0.10 → 1.1.0

package/dist/reducers/questionReducer.js

@@ -1,375 +0,0 @@
-function buildAnswerFromSavedState(q, s) {
-    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, action) {
-    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(),
-                otherText: "",
-                otherCursorPosition: 0,
-            };
-            return {
-                ...state,
-                currentQuestionIndex: nextIndex,
-                ...nextState,
-                savedStates,
-            };
-        }
-        case "INSERT_OTHER": {
-            if (state.selectedOptionIndex !== action.optionsLength - 1)
-                return state;
-            const sanitized = action.text.replace(/\r\n?|\n/g, " ");
-            const newText = state.otherText.slice(0, state.otherCursorPosition) +
-                sanitized +
-                state.otherText.slice(state.otherCursorPosition);
-            return {
-                ...state,
-                otherText: newText,
-                otherCursorPosition: state.otherCursorPosition + sanitized.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(),
-                    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),
-                    },
-                };
-            }
-        }
-        case "CLEAR_DECISION":
-            return { ...state, decision: null };
-        case "HANDLE_KEY": {
-            const { input, key, questions } = action;
-            const currentQuestion = questions[state.currentQuestionIndex];
-            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 sanitized = input.replace(/\r\n?|\n/g, " ");
-                    const newText = state.otherText.slice(0, state.otherCursorPosition) +
-                        sanitized +
-                        state.otherText.slice(state.otherCursorPosition);
-                    return {
-                        ...state,
-                        otherText: newText,
-                        otherCursorPosition: state.otherCursorPosition + sanitized.length,
-                    };
-                }
-            }
-            return state;
-        }
-        default:
-            return state;
-    }
-}

package/dist/reducers/rewindSelectorReducer.d.ts

@@ -1,21 +0,0 @@
-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;

package/dist/reducers/rewindSelectorReducer.js

@@ -1,37 +0,0 @@
-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

@@ -1,23 +0,0 @@
-import { Key } from "ink";
-export interface SelectorState<T = unknown> {
-    selectedIndex: number;
-    pendingDecision: "select" | "insert" | "cancel" | null;
-    items: T[];
-}
-export type SelectorAction<T = unknown> = {
-    type: "MOVE_UP";
-} | {
-    type: "MOVE_DOWN";
-} | {
-    type: "RESET_INDEX";
-} | {
-    type: "SET_ITEMS";
-    items: T[];
-} | {
-    type: "HANDLE_KEY";
-    key: Key;
-    hasInsert: boolean;
-} | {
-    type: "CLEAR_DECISION";
-};
-export declare function selectorReducer<T = unknown>(state: SelectorState<T>, action: SelectorAction<T>): SelectorState<T>;

package/dist/reducers/selectorReducer.js

@@ -1,42 +0,0 @@
-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(state.items.length - 1, state.selectedIndex + 1),
-            };
-        case "RESET_INDEX":
-            return { ...state, selectedIndex: 0 };
-        case "SET_ITEMS":
-            return { ...state, items: action.items, 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(state.items.length - 1, 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/reducers/workflowManagerReducer.d.ts

@@ -1,40 +0,0 @@
-import { Key } from "ink";
-import type { WorkflowRun } from "wave-agent-sdk";
-export type PendingEffect = {
-    type: "CANCEL";
-} | {
-    type: "STOP_RUN";
-    runId: string;
-};
-export interface WorkflowManagerState {
-    runs: WorkflowRun[];
-    selectedIndex: number;
-    viewMode: "list" | "detail";
-    detailRunId: string | null;
-    pendingEffect: PendingEffect | null;
-}
-export type WorkflowManagerAction = {
-    type: "SET_RUNS";
-    runs: WorkflowRun[];
-} | {
-    type: "SELECT_INDEX";
-    index: number;
-} | {
-    type: "MOVE_UP";
-} | {
-    type: "MOVE_DOWN";
-} | {
-    type: "SELECT_CURRENT";
-} | {
-    type: "SET_VIEW_MODE";
-    mode: "list" | "detail";
-} | {
-    type: "RESET_DETAIL";
-} | {
-    type: "HANDLE_KEY";
-    input: string;
-    key: Key;
-} | {
-    type: "CLEAR_PENDING_EFFECT";
-};
-export declare function workflowManagerReducer(state: WorkflowManagerState, action: WorkflowManagerAction): WorkflowManagerState;

package/dist/reducers/workflowManagerReducer.js

@@ -1,100 +0,0 @@
-export function workflowManagerReducer(state, action) {
-    switch (action.type) {
-        case "SET_RUNS":
-            return { ...state, runs: action.runs };
-        case "SELECT_INDEX":
-            return { ...state, selectedIndex: action.index };
-        case "MOVE_UP":
-            return { ...state, selectedIndex: Math.max(0, state.selectedIndex - 1) };
-        case "MOVE_DOWN":
-            return {
-                ...state,
-                selectedIndex: Math.min(state.runs.length > 0 ? state.runs.length - 1 : 0, state.selectedIndex + 1),
-            };
-        case "SELECT_CURRENT":
-            if (state.runs.length > 0 && state.selectedIndex < state.runs.length) {
-                return {
-                    ...state,
-                    detailRunId: state.runs[state.selectedIndex].runId,
-                    viewMode: "detail",
-                };
-            }
-            return state;
-        case "SET_VIEW_MODE":
-            return { ...state, viewMode: action.mode };
-        case "RESET_DETAIL":
-            return {
-                ...state,
-                viewMode: "list",
-                detailRunId: null,
-            };
-        case "HANDLE_KEY": {
-            const { input, key } = action;
-            if (state.viewMode === "list") {
-                if (key.return) {
-                    if (state.runs.length > 0 &&
-                        state.selectedIndex < state.runs.length) {
-                        return {
-                            ...state,
-                            detailRunId: state.runs[state.selectedIndex].runId,
-                            viewMode: "detail",
-                        };
-                    }
-                    return state;
-                }
-                if (key.escape) {
-                    return { ...state, pendingEffect: { type: "CANCEL" } };
-                }
-                if (key.upArrow) {
-                    return {
-                        ...state,
-                        selectedIndex: Math.max(0, state.selectedIndex - 1),
-                    };
-                }
-                if (key.downArrow) {
-                    return {
-                        ...state,
-                        selectedIndex: Math.min(state.runs.length > 0 ? state.runs.length - 1 : 0, state.selectedIndex + 1),
-                    };
-                }
-                if (input === "k") {
-                    if (state.runs.length > 0 &&
-                        state.selectedIndex < state.runs.length) {
-                        const selectedRun = state.runs[state.selectedIndex];
-                        if (selectedRun.status === "running") {
-                            return {
-                                ...state,
-                                pendingEffect: { type: "STOP_RUN", runId: selectedRun.runId },
-                            };
-                        }
-                    }
-                    return state;
-                }
-            }
-            else if (state.viewMode === "detail") {
-                if (key.escape) {
-                    return {
-                        ...state,
-                        viewMode: "list",
-                        detailRunId: null,
-                    };
-                }
-                if (input === "k" && state.detailRunId) {
-                    const run = state.runs.find((r) => r.runId === state.detailRunId);
-                    if (run && run.status === "running") {
-                        return {
-                            ...state,
-                            pendingEffect: { type: "STOP_RUN", runId: state.detailRunId },
-                        };
-                    }
-                    return state;
-                }
-            }
-            return state;
-        }
-        case "CLEAR_PENDING_EFFECT":
-            return { ...state, pendingEffect: null };
-        default:
-            return state;
-    }
-}

package/dist/session-selector-cli.d.ts

@@ -1,3 +0,0 @@
-export declare function startSessionSelectorCli({ workdir, }?: {
-    workdir?: string;
-}): Promise<string | null>;

package/dist/session-selector-cli.js

@@ -1,25 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render, Box } from "ink";
-import { listSessions, truncateContent } from "wave-agent-sdk";
-import { SessionSelector } from "./components/SessionSelector.js";
-export async function startSessionSelectorCli({ workdir, } = {}) {
-    const currentWorkdir = workdir || process.cwd();
-    const sessions = await listSessions(currentWorkdir);
-    if (sessions.length === 0) {
-        console.log(`No sessions found for workdir: ${currentWorkdir}`);
-        return null;
-    }
-    const sessionsWithContent = sessions.map((s) => ({
-        ...s,
-        firstMessage: truncateContent(s.firstMessage || "No content", 80),
-    }));
-    return new Promise((resolve) => {
-        const { unmount } = render(_jsx(Box, { padding: 1, children: _jsx(SessionSelector, { sessions: sessionsWithContent, onSelect: (sessionId) => {
-                    unmount();
-                    resolve(sessionId);
-                }, onCancel: () => {
-                    unmount();
-                    resolve(null);
-                } }) }));
-    });
-}