@dexto/tui 1.6.2

package/dist/hooks/useKeyboardShortcuts.cjs

@@ -0,0 +1,87 @@
+"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 useKeyboardShortcuts_exports = {};
+__export(useKeyboardShortcuts_exports, {
+  useKeyboardShortcuts: () => useKeyboardShortcuts
+});
+module.exports = __toCommonJS(useKeyboardShortcuts_exports);
+var import_react = require("react");
+var import_ink = require("ink");
+const EXIT_WARNING_TIMEOUT = 3e3;
+function useKeyboardShortcuts({ state, dispatch, agent }) {
+  const { exit } = (0, import_ink.useApp)();
+  const sessionIdRef = (0, import_react.useRef)(state.session.id);
+  (0, import_react.useEffect)(() => {
+    sessionIdRef.current = state.session.id;
+  }, [state.session.id]);
+  (0, import_react.useEffect)(() => {
+    if (!state.ui.exitWarningShown || !state.ui.exitWarningTimestamp) return;
+    const elapsed = Date.now() - state.ui.exitWarningTimestamp;
+    const remaining = EXIT_WARNING_TIMEOUT - elapsed;
+    if (remaining <= 0) {
+      dispatch({ type: "EXIT_WARNING_CLEAR" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      dispatch({ type: "EXIT_WARNING_CLEAR" });
+    }, remaining);
+    return () => clearTimeout(timer);
+  }, [state.ui.exitWarningShown, state.ui.exitWarningTimestamp, dispatch]);
+  (0, import_ink.useInput)(
+    (inputChar, key) => {
+      if (state.approval) {
+        return;
+      }
+      if (state.ui.activeOverlay !== "none" && state.ui.activeOverlay !== "approval") {
+        return;
+      }
+      if (key.ctrl && inputChar === "c") {
+        if (state.ui.exitWarningShown) {
+          exit();
+        } else {
+          dispatch({ type: "EXIT_WARNING_SHOW" });
+        }
+        return;
+      }
+      if (key.escape) {
+        if (state.ui.exitWarningShown) {
+          dispatch({ type: "EXIT_WARNING_CLEAR" });
+          return;
+        }
+        if (state.ui.isProcessing) {
+          const currentSessionId = sessionIdRef.current;
+          if (!currentSessionId) {
+            return;
+          }
+          void agent.cancel(currentSessionId).catch(() => {
+          });
+          dispatch({ type: "CANCEL_START" });
+        } else if (state.ui.activeOverlay !== "none") {
+          dispatch({ type: "CLOSE_OVERLAY" });
+        }
+      }
+    },
+    // Always active - we handle guards internally for more reliable behavior
+    { isActive: true }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useKeyboardShortcuts
+});

package/dist/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hook for global keyboard shortcuts
+ * Handles shortcuts like Ctrl+C (with double-press to exit), Escape, etc.
+ */
+import type React from 'react';
+import type { DextoAgent } from '@dexto/core';
+import type { CLIAction } from '../state/actions.js';
+import type { CLIState } from '../state/types.js';
+interface UseKeyboardShortcutsProps {
+    state: CLIState;
+    dispatch: React.Dispatch<CLIAction>;
+    agent: DextoAgent;
+}
+/**
+ * Manages global keyboard shortcuts
+ * - Ctrl+C: Cancel processing (if running) or show exit warning (press again to exit)
+ * - Escape: Cancel processing or close overlays
+ */
+export declare function useKeyboardShortcuts({ state, dispatch, agent }: UseKeyboardShortcutsProps): void;
+export {};
+//# sourceMappingURL=useKeyboardShortcuts.d.ts.map

package/dist/hooks/useKeyboardShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcuts.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyboardShortcuts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,UAAU,yBAAyB;IAC/B,KAAK,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACpC,KAAK,EAAE,UAAU,CAAC;CACrB;AAKD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,yBAAyB,GAAG,IAAI,CA4EhG"}

package/dist/hooks/useKeyboardShortcuts.js

@@ -0,0 +1,63 @@
+import { useEffect, useRef } from "react";
+import { useInput, useApp } from "ink";
+const EXIT_WARNING_TIMEOUT = 3e3;
+function useKeyboardShortcuts({ state, dispatch, agent }) {
+  const { exit } = useApp();
+  const sessionIdRef = useRef(state.session.id);
+  useEffect(() => {
+    sessionIdRef.current = state.session.id;
+  }, [state.session.id]);
+  useEffect(() => {
+    if (!state.ui.exitWarningShown || !state.ui.exitWarningTimestamp) return;
+    const elapsed = Date.now() - state.ui.exitWarningTimestamp;
+    const remaining = EXIT_WARNING_TIMEOUT - elapsed;
+    if (remaining <= 0) {
+      dispatch({ type: "EXIT_WARNING_CLEAR" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      dispatch({ type: "EXIT_WARNING_CLEAR" });
+    }, remaining);
+    return () => clearTimeout(timer);
+  }, [state.ui.exitWarningShown, state.ui.exitWarningTimestamp, dispatch]);
+  useInput(
+    (inputChar, key) => {
+      if (state.approval) {
+        return;
+      }
+      if (state.ui.activeOverlay !== "none" && state.ui.activeOverlay !== "approval") {
+        return;
+      }
+      if (key.ctrl && inputChar === "c") {
+        if (state.ui.exitWarningShown) {
+          exit();
+        } else {
+          dispatch({ type: "EXIT_WARNING_SHOW" });
+        }
+        return;
+      }
+      if (key.escape) {
+        if (state.ui.exitWarningShown) {
+          dispatch({ type: "EXIT_WARNING_CLEAR" });
+          return;
+        }
+        if (state.ui.isProcessing) {
+          const currentSessionId = sessionIdRef.current;
+          if (!currentSessionId) {
+            return;
+          }
+          void agent.cancel(currentSessionId).catch(() => {
+          });
+          dispatch({ type: "CANCEL_START" });
+        } else if (state.ui.activeOverlay !== "none") {
+          dispatch({ type: "CLOSE_OVERLAY" });
+        }
+      }
+    },
+    // Always active - we handle guards internally for more reliable behavior
+    { isActive: true }
+  );
+}
+export {
+  useKeyboardShortcuts
+};

package/dist/hooks/useKeypress.cjs

@@ -0,0 +1,41 @@
+"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 useKeypress_exports = {};
+__export(useKeypress_exports, {
+  useKeypress: () => useKeypress
+});
+module.exports = __toCommonJS(useKeypress_exports);
+var import_react = require("react");
+var import_KeypressContext = require("../contexts/KeypressContext.js");
+function useKeypress(onKeypress, { isActive }) {
+  const { subscribe, unsubscribe } = (0, import_KeypressContext.useKeypressContext)();
+  (0, import_react.useEffect)(() => {
+    if (!isActive) {
+      return;
+    }
+    subscribe(onKeypress);
+    return () => {
+      unsubscribe(onKeypress);
+    };
+  }, [isActive, onKeypress, subscribe, unsubscribe]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useKeypress
+});

package/dist/hooks/useKeypress.d.ts

@@ -0,0 +1,18 @@
+/**
+ * useKeypress Hook
+ *
+ * Subscribe to keyboard events from the KeypressProvider.
+ * This replaces Ink's useInput hook.
+ */
+import type { KeypressHandler, Key } from '../contexts/KeypressContext.js';
+export type { Key };
+/**
+ * Hook to subscribe to keypress events.
+ *
+ * @param onKeypress - Callback for each keypress
+ * @param options.isActive - Whether to listen for input
+ */
+export declare function useKeypress(onKeypress: KeypressHandler, { isActive }: {
+    isActive: boolean;
+}): void;
+//# sourceMappingURL=useKeypress.d.ts.map

package/dist/hooks/useKeypress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeypress.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeypress.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,gCAAgC,CAAC;AAG3E,YAAY,EAAE,GAAG,EAAE,CAAC;AAEpB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,eAAe,EAAE,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,QAa3F"}

package/dist/hooks/useKeypress.js

@@ -0,0 +1,17 @@
+import { useEffect } from "react";
+import { useKeypressContext } from "../contexts/KeypressContext.js";
+function useKeypress(onKeypress, { isActive }) {
+  const { subscribe, unsubscribe } = useKeypressContext();
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    subscribe(onKeypress);
+    return () => {
+      unsubscribe(onKeypress);
+    };
+  }, [isActive, onKeypress, subscribe, unsubscribe]);
+}
+export {
+  useKeypress
+};

package/dist/hooks/usePhraseCycler.cjs

@@ -0,0 +1,74 @@
+"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 usePhraseCycler_exports = {};
+__export(usePhraseCycler_exports, {
+  usePhraseCycler: () => usePhraseCycler
+});
+module.exports = __toCommonJS(usePhraseCycler_exports);
+var import_react = require("react");
+var import_processingPhrases = require("../constants/processingPhrases.js");
+var import_tips = require("../constants/tips.js");
+function getRandomPhraseOrTip(disableTips = false) {
+  if (disableTips) {
+    return (0, import_processingPhrases.getRandomPhrase)();
+  }
+  const showTip = Math.random() < 1 / 3;
+  return showTip ? (0, import_tips.getRandomTip)() : (0, import_processingPhrases.getRandomPhrase)();
+}
+function usePhraseCycler({
+  isActive,
+  intervalMs = 8e3,
+  disableTips = false
+}) {
+  const [phrase, setPhrase] = (0, import_react.useState)(() => getRandomPhraseOrTip(disableTips));
+  const intervalRef = (0, import_react.useRef)(null);
+  const nextPhrase = (0, import_react.useCallback)(() => {
+    let newPhrase = getRandomPhraseOrTip(disableTips);
+    let attempts = 0;
+    while (newPhrase === phrase && attempts < 3) {
+      newPhrase = getRandomPhraseOrTip(disableTips);
+      attempts++;
+    }
+    setPhrase(newPhrase);
+  }, [phrase, disableTips]);
+  (0, import_react.useEffect)(() => {
+    if (isActive) {
+      setPhrase(getRandomPhraseOrTip(disableTips));
+      intervalRef.current = setInterval(() => {
+        setPhrase(getRandomPhraseOrTip(disableTips));
+      }, intervalMs);
+    } else {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [isActive, intervalMs, disableTips]);
+  return { phrase, nextPhrase };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePhraseCycler
+});

package/dist/hooks/usePhraseCycler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * usePhraseCycler Hook
+ * Cycles through processing phrases and tips at regular intervals
+ *
+ * Behavior:
+ * - 1/3 chance to show tip, 2/3 chance for witty phrase
+ * - Phrases cycle every 8 seconds while isActive is true
+ */
+export interface PhraseCyclerOptions {
+    /** Whether the cycler is active (should only run during processing) */
+    isActive: boolean;
+    /** Interval in milliseconds between phrase changes (default: 8000ms = 8 seconds) */
+    intervalMs?: number;
+    /** Disable tips (only show witty phrases) */
+    disableTips?: boolean;
+}
+export interface PhraseCyclerResult {
+    /** Current phrase to display */
+    phrase: string;
+    /** Manually trigger a new phrase */
+    nextPhrase: () => void;
+}
+/**
+ * Hook that cycles through witty processing phrases and informative tips
+ *
+ * @param options - Configuration options
+ * @returns Current phrase and control functions
+ */
+export declare function usePhraseCycler({ isActive, intervalMs, disableTips, }: PhraseCyclerOptions): PhraseCyclerResult;
+//# sourceMappingURL=usePhraseCycler.d.ts.map

package/dist/hooks/usePhraseCycler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePhraseCycler.d.ts","sourceRoot":"","sources":["../../src/hooks/usePhraseCycler.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,MAAM,WAAW,mBAAmB;IAChC,uEAAuE;IACvE,QAAQ,EAAE,OAAO,CAAC;IAClB,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IAC/B,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,UAAU,EAAE,MAAM,IAAI,CAAC;CAC1B;AAgBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAC5B,QAAQ,EACR,UAAiB,EACjB,WAAmB,GACtB,EAAE,mBAAmB,GAAG,kBAAkB,CA0C1C"}

package/dist/hooks/usePhraseCycler.js

@@ -0,0 +1,50 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { getRandomPhrase } from "../constants/processingPhrases.js";
+import { getRandomTip } from "../constants/tips.js";
+function getRandomPhraseOrTip(disableTips = false) {
+  if (disableTips) {
+    return getRandomPhrase();
+  }
+  const showTip = Math.random() < 1 / 3;
+  return showTip ? getRandomTip() : getRandomPhrase();
+}
+function usePhraseCycler({
+  isActive,
+  intervalMs = 8e3,
+  disableTips = false
+}) {
+  const [phrase, setPhrase] = useState(() => getRandomPhraseOrTip(disableTips));
+  const intervalRef = useRef(null);
+  const nextPhrase = useCallback(() => {
+    let newPhrase = getRandomPhraseOrTip(disableTips);
+    let attempts = 0;
+    while (newPhrase === phrase && attempts < 3) {
+      newPhrase = getRandomPhraseOrTip(disableTips);
+      attempts++;
+    }
+    setPhrase(newPhrase);
+  }, [phrase, disableTips]);
+  useEffect(() => {
+    if (isActive) {
+      setPhrase(getRandomPhraseOrTip(disableTips));
+      intervalRef.current = setInterval(() => {
+        setPhrase(getRandomPhraseOrTip(disableTips));
+      }, intervalMs);
+    } else {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [isActive, intervalMs, disableTips]);
+  return { phrase, nextPhrase };
+}
+export {
+  usePhraseCycler
+};

package/dist/hooks/useStreaming.cjs

@@ -0,0 +1,43 @@
+"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 useStreaming_exports = {};
+__export(useStreaming_exports, {
+  useStreaming: () => useStreaming
+});
+module.exports = __toCommonJS(useStreaming_exports);
+var import_react = require("react");
+var import_streaming_state = require("../state/streaming-state.js");
+function useStreaming() {
+  const [streaming, setStreamingState] = (0, import_react.useState)(import_streaming_state.isStreamingEnabled);
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = (0, import_streaming_state.subscribeToStreaming)((enabled) => {
+      setStreamingState(enabled);
+    });
+    return unsubscribe;
+  }, []);
+  return {
+    streaming,
+    setStreaming: import_streaming_state.setStreamingEnabled,
+    toggleStreaming: import_streaming_state.toggleStreaming
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useStreaming
+});

package/dist/hooks/useStreaming.d.ts

@@ -0,0 +1,19 @@
+/**
+ * React hook for streaming state
+ *
+ * Subscribes to the streaming state manager and returns current value.
+ * Components using this hook will re-render when streaming is toggled.
+ */
+export interface UseStreamingResult {
+    /** Current streaming state */
+    streaming: boolean;
+    /** Set streaming state */
+    setStreaming: (enabled: boolean) => void;
+    /** Toggle streaming state */
+    toggleStreaming: () => boolean;
+}
+/**
+ * Hook to access and modify streaming state
+ */
+export declare function useStreaming(): UseStreamingResult;
+//# sourceMappingURL=useStreaming.d.ts.map

package/dist/hooks/useStreaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreaming.d.ts","sourceRoot":"","sources":["../../src/hooks/useStreaming.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,kBAAkB;IAC/B,8BAA8B;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,0BAA0B;IAC1B,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC,6BAA6B;IAC7B,eAAe,EAAE,MAAM,OAAO,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CAiBjD"}

package/dist/hooks/useStreaming.js

@@ -0,0 +1,24 @@
+import { useState, useEffect } from "react";
+import {
+  isStreamingEnabled,
+  subscribeToStreaming,
+  setStreamingEnabled,
+  toggleStreaming
+} from "../state/streaming-state.js";
+function useStreaming() {
+  const [streaming, setStreamingState] = useState(isStreamingEnabled);
+  useEffect(() => {
+    const unsubscribe = subscribeToStreaming((enabled) => {
+      setStreamingState(enabled);
+    });
+    return unsubscribe;
+  }, []);
+  return {
+    streaming,
+    setStreaming: setStreamingEnabled,
+    toggleStreaming
+  };
+}
+export {
+  useStreaming
+};

package/dist/hooks/useTerminalSize.cjs

@@ -0,0 +1,48 @@
+"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 useTerminalSize_exports = {};
+__export(useTerminalSize_exports, {
+  useTerminalSize: () => useTerminalSize
+});
+module.exports = __toCommonJS(useTerminalSize_exports);
+var import_react = require("react");
+function useTerminalSize() {
+  const [size, setSize] = (0, import_react.useState)({
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  (0, import_react.useEffect)(() => {
+    function updateSize() {
+      setSize({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      });
+    }
+    process.stdout.on("resize", updateSize);
+    updateSize();
+    return () => {
+      process.stdout.off("resize", updateSize);
+    };
+  }, []);
+  return size;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useTerminalSize
+});

package/dist/hooks/useTerminalSize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * useTerminalSize Hook
+ *
+ * Listens to terminal resize events and provides current dimensions.
+ */
+export interface TerminalSize {
+    columns: number;
+    rows: number;
+}
+/**
+ * Hook that returns current terminal size and updates on resize
+ */
+export declare function useTerminalSize(): TerminalSize;
+//# sourceMappingURL=useTerminalSize.d.ts.map

package/dist/hooks/useTerminalSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTerminalSize.d.ts","sourceRoot":"","sources":["../../src/hooks/useTerminalSize.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,WAAW,YAAY;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,YAAY,CA0B9C"}

package/dist/hooks/useTerminalSize.js

@@ -0,0 +1,24 @@
+import { useState, useEffect } from "react";
+function useTerminalSize() {
+  const [size, setSize] = useState({
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  useEffect(() => {
+    function updateSize() {
+      setSize({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      });
+    }
+    process.stdout.on("resize", updateSize);
+    updateSize();
+    return () => {
+      process.stdout.off("resize", updateSize);
+    };
+  }, []);
+  return size;
+}
+export {
+  useTerminalSize
+};