@dexto/tui 1.6.2

package/dist/state/reducer.js

@@ -0,0 +1,316 @@
+function cliReducer(state, action) {
+  switch (action.type) {
+    // Input actions
+    case "INPUT_CHANGE":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          value: action.value
+        },
+        // Clear exit warning when user starts typing
+        ui: state.ui.exitWarningShown ? {
+          ...state.ui,
+          exitWarningShown: false,
+          exitWarningTimestamp: null
+        } : state.ui
+      };
+    case "INPUT_CLEAR":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          value: "",
+          historyIndex: -1
+        }
+      };
+    case "INPUT_HISTORY_NAVIGATE": {
+      const { history } = state.input;
+      if (history.length === 0) return state;
+      let newIndex = state.input.historyIndex;
+      if (action.direction === "up") {
+        if (newIndex < 0) {
+          newIndex = history.length - 1;
+        } else if (newIndex > 0) {
+          newIndex = newIndex - 1;
+        }
+      } else {
+        if (newIndex >= 0 && newIndex < history.length - 1) {
+          newIndex = newIndex + 1;
+        } else if (newIndex === history.length - 1) {
+          return {
+            ...state,
+            input: {
+              ...state.input,
+              value: "",
+              historyIndex: -1
+            }
+          };
+        }
+        if (newIndex < 0) return state;
+      }
+      const historyItem = history[newIndex];
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          value: historyItem || "",
+          historyIndex: newIndex
+        }
+      };
+    }
+    case "INPUT_HISTORY_RESET":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          historyIndex: -1
+        }
+      };
+    case "INPUT_HISTORY_ADD": {
+      const { history } = state.input;
+      if (!action.value || history.length > 0 && history[history.length - 1] === action.value) {
+        return state;
+      }
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          history: [...history, action.value].slice(-100),
+          // Keep last 100
+          historyIndex: -1
+        }
+      };
+    }
+    // Image actions
+    case "IMAGE_ADD":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          images: [...state.input.images, action.image]
+        }
+      };
+    case "IMAGE_REMOVE":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          images: state.input.images.filter((img) => img.id !== action.imageId)
+        }
+      };
+    case "IMAGES_CLEAR":
+      return {
+        ...state,
+        input: {
+          ...state.input,
+          images: []
+        }
+      };
+    case "CANCEL_START":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          isProcessing: false,
+          isCancelling: true
+        }
+      };
+    case "THINKING_START":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          isThinking: true
+        }
+      };
+    case "THINKING_END":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          isThinking: false
+        }
+      };
+    // UI actions
+    case "PROCESSING_START":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          isProcessing: true,
+          isCancelling: false,
+          // Clear cancellation flag for new request
+          activeOverlay: "none",
+          exitWarningShown: false,
+          // Clear exit warning on new submission
+          exitWarningTimestamp: null
+        }
+      };
+    case "PROCESSING_END":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          isProcessing: false,
+          isCancelling: false,
+          isThinking: false
+          // Clear thinking state when processing ends
+        }
+      };
+    case "SHOW_OVERLAY":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          activeOverlay: action.overlay
+        }
+      };
+    case "CLOSE_OVERLAY":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          activeOverlay: "none",
+          mcpWizardServerType: null
+          // Clear wizard state when closing overlay
+        }
+      };
+    case "SET_MCP_WIZARD_SERVER_TYPE":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          mcpWizardServerType: action.serverType
+        }
+      };
+    // Session actions
+    case "SESSION_SET":
+      return {
+        ...state,
+        session: {
+          ...state.session,
+          id: action.sessionId,
+          hasActiveSession: action.hasActiveSession
+        }
+      };
+    case "SESSION_CLEAR":
+      return {
+        ...state,
+        session: {
+          ...state.session,
+          id: null,
+          hasActiveSession: false
+        },
+        approval: null,
+        approvalQueue: [],
+        ui: {
+          ...state.ui,
+          activeOverlay: "none"
+        }
+      };
+    case "MODEL_UPDATE":
+      return {
+        ...state,
+        session: {
+          ...state.session,
+          modelName: action.modelName
+        }
+      };
+    case "CONVERSATION_RESET":
+      return {
+        ...state,
+        approval: null,
+        approvalQueue: [],
+        ui: {
+          ...state.ui,
+          activeOverlay: "none"
+        }
+      };
+    // Approval actions
+    case "APPROVAL_REQUEST":
+      if (state.approval?.approvalId === action.approval.approvalId) {
+        return state;
+      }
+      if (state.approvalQueue.some((r) => r.approvalId === action.approval.approvalId)) {
+        return state;
+      }
+      if (state.approval !== null) {
+        return {
+          ...state,
+          approvalQueue: [...state.approvalQueue, action.approval]
+        };
+      }
+      return {
+        ...state,
+        approval: action.approval,
+        ui: {
+          ...state.ui,
+          activeOverlay: "approval"
+        }
+      };
+    case "APPROVAL_COMPLETE":
+      if (state.approvalQueue.length > 0) {
+        const nextApproval = state.approvalQueue[0];
+        const remainingQueue = state.approvalQueue.slice(1);
+        return {
+          ...state,
+          approval: nextApproval,
+          approvalQueue: remainingQueue,
+          ui: {
+            ...state.ui,
+            activeOverlay: "approval"
+          }
+        };
+      }
+      return {
+        ...state,
+        approval: null,
+        ui: {
+          ...state.ui,
+          activeOverlay: "none"
+        }
+      };
+    // Exit warning actions (for double Ctrl+C to exit)
+    case "EXIT_WARNING_SHOW":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          exitWarningShown: true,
+          exitWarningTimestamp: Date.now()
+        }
+      };
+    case "EXIT_WARNING_CLEAR":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          exitWarningShown: false,
+          exitWarningTimestamp: null
+        }
+      };
+    // Copy mode actions (for text selection in alternate buffer)
+    case "COPY_MODE_ENABLE":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          copyModeEnabled: true
+        }
+      };
+    case "COPY_MODE_DISABLE":
+      return {
+        ...state,
+        ui: {
+          ...state.ui,
+          copyModeEnabled: false
+        }
+      };
+    default:
+      return state;
+  }
+}
+export {
+  cliReducer
+};

package/dist/state/streaming-state.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_state_exports = {};
+__export(streaming_state_exports, {
+  isStreamingEnabled: () => isStreamingEnabled,
+  setStreamingEnabled: () => setStreamingEnabled,
+  subscribeToStreaming: () => subscribeToStreaming,
+  toggleStreaming: () => toggleStreaming
+});
+module.exports = __toCommonJS(streaming_state_exports);
+let streamingEnabled = false;
+const listeners = /* @__PURE__ */ new Set();
+function isStreamingEnabled() {
+  return streamingEnabled;
+}
+function setStreamingEnabled(enabled) {
+  if (streamingEnabled !== enabled) {
+    streamingEnabled = enabled;
+    listeners.forEach((listener) => listener(enabled));
+  }
+}
+function toggleStreaming() {
+  setStreamingEnabled(!streamingEnabled);
+  return streamingEnabled;
+}
+function subscribeToStreaming(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isStreamingEnabled,
+  setStreamingEnabled,
+  subscribeToStreaming,
+  toggleStreaming
+});

package/dist/state/streaming-state.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Streaming state manager for CLI
+ *
+ * Simple module-level state that can be accessed by both React components
+ * and command handlers. Uses a subscription pattern for React integration.
+ */
+type StreamingListener = (enabled: boolean) => void;
+/**
+ * Get current streaming state
+ */
+export declare function isStreamingEnabled(): boolean;
+/**
+ * Set streaming state and notify listeners
+ */
+export declare function setStreamingEnabled(enabled: boolean): void;
+/**
+ * Toggle streaming state
+ * @returns New streaming state
+ */
+export declare function toggleStreaming(): boolean;
+/**
+ * Subscribe to streaming state changes
+ * @returns Unsubscribe function
+ */
+export declare function subscribeToStreaming(listener: StreamingListener): () => void;
+export {};
+//# sourceMappingURL=streaming-state.d.ts.map

package/dist/state/streaming-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-state.d.ts","sourceRoot":"","sources":["../../src/state/streaming-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAKpD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAK1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAGzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAG5E"}

package/dist/state/streaming-state.js

@@ -0,0 +1,25 @@
+let streamingEnabled = false;
+const listeners = /* @__PURE__ */ new Set();
+function isStreamingEnabled() {
+  return streamingEnabled;
+}
+function setStreamingEnabled(enabled) {
+  if (streamingEnabled !== enabled) {
+    streamingEnabled = enabled;
+    listeners.forEach((listener) => listener(enabled));
+  }
+}
+function toggleStreaming() {
+  setStreamingEnabled(!streamingEnabled);
+  return streamingEnabled;
+}
+function subscribeToStreaming(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+export {
+  isStreamingEnabled,
+  setStreamingEnabled,
+  subscribeToStreaming,
+  toggleStreaming
+};

package/dist/state/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);