@within-7/minto 0.0.5-dev.1

package/dist/hooks/useCancelRequest.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useCancelRequest.ts"],
+  "sourcesContent": ["import { useInput } from 'ink'\nimport { ToolUseConfirm } from '@components/permissions/PermissionRequest'\nimport { BinaryFeedbackContext } from '@screens/REPL'\nimport type { SetToolJSXFn } from '@tool'\n\nexport function useCancelRequest(\n  setToolJSX: SetToolJSXFn,\n  setToolUseConfirm: (toolUseConfirm: ToolUseConfirm | null) => void,\n  setBinaryFeedbackContext: (bfContext: BinaryFeedbackContext | null) => void,\n  onCancel: () => void,\n  isLoading: boolean,\n  isMessageSelectorVisible: boolean,\n  abortSignal?: AbortSignal,\n) {\n  useInput((_, key) => {\n    if (!key.escape) {\n      return\n    }\n    if (abortSignal?.aborted) {\n      return\n    }\n    if (!abortSignal) {\n      return\n    }\n    if (!isLoading) {\n      return\n    }\n    if (isMessageSelectorVisible) {\n      // Esc closes the message selector\n      return\n    }\n  \n    setToolJSX(null)\n    setToolUseConfirm(null)\n    setBinaryFeedbackContext(null)\n    onCancel()\n  })\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AAKlB,SAAS,iBACd,YACA,mBACA,0BACA,UACA,WACA,0BACA,aACA;AACA,WAAS,CAAC,GAAG,QAAQ;AACnB,QAAI,CAAC,IAAI,QAAQ;AACf;AAAA,IACF;AACA,QAAI,aAAa,SAAS;AACxB;AAAA,IACF;AACA,QAAI,CAAC,aAAa;AAChB;AAAA,IACF;AACA,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AACA,QAAI,0BAA0B;AAE5B;AAAA,IACF;AAEA,eAAW,IAAI;AACf,sBAAkB,IAAI;AACtB,6BAAyB,IAAI;AAC7B,aAAS;AAAA,EACX,CAAC;AACH;",
+  "names": []
+}

package/dist/hooks/useDoublePress.js

@@ -0,0 +1,31 @@
+import { useRef } from "react";
+const DOUBLE_PRESS_TIMEOUT_MS = 2e3;
+function useDoublePress(setPending, onDoublePress, onFirstPress) {
+  const lastPressRef = useRef(0);
+  const timeoutRef = useRef();
+  return () => {
+    const now = Date.now();
+    const timeSinceLastPress = now - lastPressRef.current;
+    if (timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current) {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = void 0;
+      }
+      onDoublePress();
+      setPending(false);
+    } else {
+      onFirstPress?.();
+      setPending(true);
+      timeoutRef.current = setTimeout(
+        () => setPending(false),
+        DOUBLE_PRESS_TIMEOUT_MS
+      );
+    }
+    lastPressRef.current = now;
+  };
+}
+export {
+  DOUBLE_PRESS_TIMEOUT_MS,
+  useDoublePress
+};
+//# sourceMappingURL=useDoublePress.js.map

package/dist/hooks/useDoublePress.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useDoublePress.ts"],
+  "sourcesContent": ["// Creates a function that calls one function on the first call and another\n// function on the second call within a certain timeout\n\nimport { useRef } from 'react'\n\nexport const DOUBLE_PRESS_TIMEOUT_MS = 2000\n\nexport function useDoublePress(\n  setPending: (pending: boolean) => void,\n  onDoublePress: () => void,\n  onFirstPress?: () => void,\n): () => void {\n  const lastPressRef = useRef<number>(0)\n  const timeoutRef = useRef<NodeJS.Timeout>()\n\n  return () => {\n    const now = Date.now()\n    const timeSinceLastPress = now - lastPressRef.current\n\n    // For this to count as a double-call, be sure to check that\n    // timeoutRef.current exists so we don't trigger on triple call\n    // (e.g. of Esc to clear the text input)\n    if (timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS && timeoutRef.current) {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current)\n        timeoutRef.current = undefined\n      }\n      onDoublePress()\n      setPending(false)\n    } else {\n      onFirstPress?.()\n      setPending(true)\n      timeoutRef.current = setTimeout(\n        () => setPending(false),\n        DOUBLE_PRESS_TIMEOUT_MS,\n      )\n    }\n\n    lastPressRef.current = now\n  }\n}\n"],
+  "mappings": "AAGA,SAAS,cAAc;AAEhB,MAAM,0BAA0B;AAEhC,SAAS,eACd,YACA,eACA,cACY;AACZ,QAAM,eAAe,OAAe,CAAC;AACrC,QAAM,aAAa,OAAuB;AAE1C,SAAO,MAAM;AACX,UAAM,MAAM,KAAK,IAAI;AACrB,UAAM,qBAAqB,MAAM,aAAa;AAK9C,QAAI,sBAAsB,2BAA2B,WAAW,SAAS;AACvE,UAAI,WAAW,SAAS;AACtB,qBAAa,WAAW,OAAO;AAC/B,mBAAW,UAAU;AAAA,MACvB;AACA,oBAAc;AACd,iBAAW,KAAK;AAAA,IAClB,OAAO;AACL,qBAAe;AACf,iBAAW,IAAI;AACf,iBAAW,UAAU;AAAA,QACnB,MAAM,WAAW,KAAK;AAAA,QACtB;AAAA,MACF;AAAA,IACF;AAEA,iBAAa,UAAU;AAAA,EACzB;AACF;",
+  "names": []
+}

package/dist/hooks/useExitOnCtrlCD.js

@@ -0,0 +1,26 @@
+import { useInput } from "ink";
+import { useDoublePress } from "./useDoublePress.js";
+import { useState } from "react";
+function useExitOnCtrlCD(onExit) {
+  const [exitState, setExitState] = useState({
+    pending: false,
+    keyName: null
+  });
+  const handleCtrlC = useDoublePress(
+    (pending) => setExitState({ pending, keyName: "Ctrl-C" }),
+    onExit
+  );
+  const handleCtrlD = useDoublePress(
+    (pending) => setExitState({ pending, keyName: "Ctrl-D" }),
+    onExit
+  );
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") handleCtrlC();
+    if (key.ctrl && input === "d") handleCtrlD();
+  });
+  return exitState;
+}
+export {
+  useExitOnCtrlCD
+};
+//# sourceMappingURL=useExitOnCtrlCD.js.map

package/dist/hooks/useExitOnCtrlCD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useExitOnCtrlCD.ts"],
+  "sourcesContent": ["import { useInput } from 'ink'\nimport { useDoublePress } from './useDoublePress'\nimport { useState } from 'react'\n\ntype ExitState = {\n  pending: boolean\n  keyName: 'Ctrl-C' | 'Ctrl-D' | null\n}\n\nexport function useExitOnCtrlCD(onExit: () => void): ExitState {\n  const [exitState, setExitState] = useState<ExitState>({\n    pending: false,\n    keyName: null,\n  })\n\n  const handleCtrlC = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-C' }),\n    onExit,\n  )\n  const handleCtrlD = useDoublePress(\n    pending => setExitState({ pending, keyName: 'Ctrl-D' }),\n    onExit,\n  )\n\n  useInput((input, key) => {\n    if (key.ctrl && input === 'c') handleCtrlC()\n    if (key.ctrl && input === 'd') handleCtrlD()\n  })\n\n  return exitState\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AAOlB,SAAS,gBAAgB,QAA+B;AAC7D,QAAM,CAAC,WAAW,YAAY,IAAI,SAAoB;AAAA,IACpD,SAAS;AAAA,IACT,SAAS;AAAA,EACX,CAAC;AAED,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AACA,QAAM,cAAc;AAAA,IAClB,aAAW,aAAa,EAAE,SAAS,SAAS,SAAS,CAAC;AAAA,IACtD;AAAA,EACF;AAEA,WAAS,CAAC,OAAO,QAAQ;AACvB,QAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAC3C,QAAI,IAAI,QAAQ,UAAU,IAAK,aAAY;AAAA,EAC7C,CAAC;AAED,SAAO;AACT;",
+  "names": []
+}

package/dist/hooks/useHistorySearch.js

@@ -0,0 +1,62 @@
+import { useState, useMemo, useCallback, useEffect } from "react";
+function useHistorySearch(history) {
+  const [searchTerm, setSearchTerm] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [isActive, setIsActive] = useState(false);
+  const filteredResults = useMemo(() => {
+    if (!searchTerm.trim()) {
+      return history.map((item, index) => ({ item, index })).reverse();
+    }
+    const lowerSearch = searchTerm.toLowerCase();
+    return history.map((item, index) => ({ item, index })).filter(({ item }) => item.toLowerCase().includes(lowerSearch)).reverse();
+  }, [history, searchTerm]);
+  useEffect(() => {
+    if (filteredResults.length === 0) {
+      setSelectedIndex(0);
+    } else if (selectedIndex >= filteredResults.length) {
+      setSelectedIndex(Math.max(0, filteredResults.length - 1));
+    }
+  }, [filteredResults, selectedIndex]);
+  const moveUp = useCallback(() => {
+    setSelectedIndex(
+      (prev) => Math.max(0, Math.min(prev + 1, filteredResults.length - 1))
+    );
+  }, [filteredResults.length]);
+  const moveDown = useCallback(() => {
+    setSelectedIndex((prev) => Math.max(0, prev - 1));
+  }, []);
+  const selectedItem = useMemo(() => {
+    if (filteredResults.length === 0 || selectedIndex < 0 || selectedIndex >= filteredResults.length) {
+      return null;
+    }
+    return filteredResults[selectedIndex]?.item || null;
+  }, [filteredResults, selectedIndex]);
+  const reset = useCallback(() => {
+    setSearchTerm("");
+    setSelectedIndex(0);
+    setIsActive(false);
+  }, []);
+  const activate = useCallback(() => {
+    setIsActive(true);
+    setSearchTerm("");
+    setSelectedIndex(0);
+  }, []);
+  return {
+    // State
+    searchTerm,
+    setSearchTerm,
+    selectedIndex,
+    isActive,
+    filteredResults,
+    selectedItem,
+    // Actions
+    moveUp,
+    moveDown,
+    reset,
+    activate
+  };
+}
+export {
+  useHistorySearch
+};
+//# sourceMappingURL=useHistorySearch.js.map

package/dist/hooks/useHistorySearch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useHistorySearch.ts"],
+  "sourcesContent": ["import { useState, useMemo, useCallback, useEffect } from 'react'\n\nexport type HistorySearchResult = {\n  item: string\n  index: number\n}\n\nexport function useHistorySearch(history: string[]) {\n  const [searchTerm, setSearchTerm] = useState('')\n  const [selectedIndex, setSelectedIndex] = useState(0)\n  const [isActive, setIsActive] = useState(false)\n\n  // Filter history items based on search term (case-insensitive)\n  const filteredResults = useMemo<HistorySearchResult[]>(() => {\n    if (!searchTerm.trim()) {\n      // No search term: show all history (reversed - most recent first)\n      return history\n        .map((item, index) => ({ item, index }))\n        .reverse()\n    }\n\n    // Search term: filter and reverse\n    const lowerSearch = searchTerm.toLowerCase()\n    return history\n      .map((item, index) => ({ item, index }))\n      .filter(({ item }) => item.toLowerCase().includes(lowerSearch))\n      .reverse()\n  }, [history, searchTerm])\n\n  // Reset selected index when search results change\n  useEffect(() => {\n    if (filteredResults.length === 0) {\n      setSelectedIndex(0)\n    } else if (selectedIndex >= filteredResults.length) {\n      setSelectedIndex(Math.max(0, filteredResults.length - 1))\n    }\n  }, [filteredResults, selectedIndex])\n\n  // Navigate up in the list (towards older items)\n  const moveUp = useCallback(() => {\n    setSelectedIndex(prev =>\n      Math.max(0, Math.min(prev + 1, filteredResults.length - 1)),\n    )\n  }, [filteredResults.length])\n\n  // Navigate down in the list (towards newer items)\n  const moveDown = useCallback(() => {\n    setSelectedIndex(prev => Math.max(0, prev - 1))\n  }, [])\n\n  // Get the currently selected item\n  const selectedItem = useMemo(() => {\n    if (\n      filteredResults.length === 0 ||\n      selectedIndex < 0 ||\n      selectedIndex >= filteredResults.length\n    ) {\n      return null\n    }\n    return filteredResults[selectedIndex]?.item || null\n  }, [filteredResults, selectedIndex])\n\n  // Reset search state\n  const reset = useCallback(() => {\n    setSearchTerm('')\n    setSelectedIndex(0)\n    setIsActive(false)\n  }, [])\n\n  // Activate search mode\n  const activate = useCallback(() => {\n    setIsActive(true)\n    setSearchTerm('')\n    setSelectedIndex(0)\n  }, [])\n\n  return {\n    // State\n    searchTerm,\n    setSearchTerm,\n    selectedIndex,\n    isActive,\n    filteredResults,\n    selectedItem,\n\n    // Actions\n    moveUp,\n    moveDown,\n    reset,\n    activate,\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,UAAU,SAAS,aAAa,iBAAiB;AAOnD,SAAS,iBAAiB,SAAmB;AAClD,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,EAAE;AAC/C,QAAM,CAAC,eAAe,gBAAgB,IAAI,SAAS,CAAC;AACpD,QAAM,CAAC,UAAU,WAAW,IAAI,SAAS,KAAK;AAG9C,QAAM,kBAAkB,QAA+B,MAAM;AAC3D,QAAI,CAAC,WAAW,KAAK,GAAG;AAEtB,aAAO,QACJ,IAAI,CAAC,MAAM,WAAW,EAAE,MAAM,MAAM,EAAE,EACtC,QAAQ;AAAA,IACb;AAGA,UAAM,cAAc,WAAW,YAAY;AAC3C,WAAO,QACJ,IAAI,CAAC,MAAM,WAAW,EAAE,MAAM,MAAM,EAAE,EACtC,OAAO,CAAC,EAAE,KAAK,MAAM,KAAK,YAAY,EAAE,SAAS,WAAW,CAAC,EAC7D,QAAQ;AAAA,EACb,GAAG,CAAC,SAAS,UAAU,CAAC;AAGxB,YAAU,MAAM;AACd,QAAI,gBAAgB,WAAW,GAAG;AAChC,uBAAiB,CAAC;AAAA,IACpB,WAAW,iBAAiB,gBAAgB,QAAQ;AAClD,uBAAiB,KAAK,IAAI,GAAG,gBAAgB,SAAS,CAAC,CAAC;AAAA,IAC1D;AAAA,EACF,GAAG,CAAC,iBAAiB,aAAa,CAAC;AAGnC,QAAM,SAAS,YAAY,MAAM;AAC/B;AAAA,MAAiB,UACf,KAAK,IAAI,GAAG,KAAK,IAAI,OAAO,GAAG,gBAAgB,SAAS,CAAC,CAAC;AAAA,IAC5D;AAAA,EACF,GAAG,CAAC,gBAAgB,MAAM,CAAC;AAG3B,QAAM,WAAW,YAAY,MAAM;AACjC,qBAAiB,UAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,CAAC;AAAA,EAChD,GAAG,CAAC,CAAC;AAGL,QAAM,eAAe,QAAQ,MAAM;AACjC,QACE,gBAAgB,WAAW,KAC3B,gBAAgB,KAChB,iBAAiB,gBAAgB,QACjC;AACA,aAAO;AAAA,IACT;AACA,WAAO,gBAAgB,aAAa,GAAG,QAAQ;AAAA,EACjD,GAAG,CAAC,iBAAiB,aAAa,CAAC;AAGnC,QAAM,QAAQ,YAAY,MAAM;AAC9B,kBAAc,EAAE;AAChB,qBAAiB,CAAC;AAClB,gBAAY,KAAK;AAAA,EACnB,GAAG,CAAC,CAAC;AAGL,QAAM,WAAW,YAAY,MAAM;AACjC,gBAAY,IAAI;AAChB,kBAAc,EAAE;AAChB,qBAAiB,CAAC;AAAA,EACpB,GAAG,CAAC,CAAC;AAEL,SAAO;AAAA;AAAA,IAEL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IAGA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/hooks/useInterval.js

@@ -0,0 +1,18 @@
+import { useEffect, useRef } from "react";
+function useInterval(callback, delay) {
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    function tick() {
+      savedCallback.current();
+    }
+    const id = setInterval(tick, delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+export {
+  useInterval
+};
+//# sourceMappingURL=useInterval.js.map

package/dist/hooks/useInterval.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useInterval.ts"],
+  "sourcesContent": ["import { useEffect, useRef } from 'react'\n\n/**\n * A custom hook that runs a callback at a specified interval.\n * The interval is cleared when the component unmounts.\n * The interval is also cleared and restarted if the delay changes.\n */\nexport function useInterval(callback: () => void, delay: number): void {\n  const savedCallback = useRef(callback)\n\n  // Remember the latest callback\n  useEffect(() => {\n    savedCallback.current = callback\n  }, [callback])\n\n  // Set up the interval\n  useEffect(() => {\n    function tick() {\n      savedCallback.current()\n    }\n\n    const id = setInterval(tick, delay)\n    return () => clearInterval(id)\n  }, [delay])\n}\n"],
+  "mappings": "AAAA,SAAS,WAAW,cAAc;AAO3B,SAAS,YAAY,UAAsB,OAAqB;AACrE,QAAM,gBAAgB,OAAO,QAAQ;AAGrC,YAAU,MAAM;AACd,kBAAc,UAAU;AAAA,EAC1B,GAAG,CAAC,QAAQ,CAAC;AAGb,YAAU,MAAM;AACd,aAAS,OAAO;AACd,oBAAc,QAAQ;AAAA,IACxB;AAEA,UAAM,KAAK,YAAY,MAAM,KAAK;AAClC,WAAO,MAAM,cAAc,EAAE;AAAA,EAC/B,GAAG,CAAC,KAAK,CAAC;AACZ;",
+  "names": []
+}

package/dist/hooks/useLogMessages.js

@@ -0,0 +1,14 @@
+import { useEffect } from "react";
+import { overwriteLog, getMessagesPath } from "../utils/log.js";
+function useLogMessages(messages, messageLogName, forkNumber) {
+  useEffect(() => {
+    overwriteLog(
+      getMessagesPath(messageLogName, forkNumber, 0),
+      messages.filter((_) => _.type !== "progress")
+    );
+  }, [messages, messageLogName, forkNumber]);
+}
+export {
+  useLogMessages
+};
+//# sourceMappingURL=useLogMessages.js.map

package/dist/hooks/useLogMessages.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useLogMessages.ts"],
+  "sourcesContent": ["import { useEffect } from 'react'\nimport { type Message } from '@query'\nimport { overwriteLog, getMessagesPath } from '@utils/log'\n\nexport function useLogMessages(\n  messages: Message[],\n  messageLogName: string,\n  forkNumber: number,\n): void {\n  useEffect(() => {\n    overwriteLog(\n      getMessagesPath(messageLogName, forkNumber, 0),\n      messages.filter(_ => _.type !== 'progress'),\n    )\n  }, [messages, messageLogName, forkNumber])\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAE1B,SAAS,cAAc,uBAAuB;AAEvC,SAAS,eACd,UACA,gBACA,YACM;AACN,YAAU,MAAM;AACd;AAAA,MACE,gBAAgB,gBAAgB,YAAY,CAAC;AAAA,MAC7C,SAAS,OAAO,OAAK,EAAE,SAAS,UAAU;AAAA,IAC5C;AAAA,EACF,GAAG,CAAC,UAAU,gBAAgB,UAAU,CAAC;AAC3C;",
+  "names": []
+}

package/dist/hooks/useLogStartupTime.js

@@ -0,0 +1,10 @@
+import { useEffect } from "react";
+function useLogStartupTime() {
+  useEffect(() => {
+    const startupTimeMs = Math.round(process.uptime() * 1e3);
+  }, []);
+}
+export {
+  useLogStartupTime
+};
+//# sourceMappingURL=useLogStartupTime.js.map

package/dist/hooks/useLogStartupTime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useLogStartupTime.ts"],
+  "sourcesContent": ["import { useEffect } from 'react'\n \n\nexport function useLogStartupTime(): void {\n  useEffect(() => {\n    const startupTimeMs = Math.round(process.uptime() * 1000)\n  }, [])\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAGnB,SAAS,oBAA0B;AACxC,YAAU,MAAM;AACd,UAAM,gBAAgB,KAAK,MAAM,QAAQ,OAAO,IAAI,GAAI;AAAA,EAC1D,GAAG,CAAC,CAAC;AACP;",
+  "names": []
+}

package/dist/hooks/useNotifyAfterTimeout.js

@@ -0,0 +1,42 @@
+import { useEffect } from "react";
+import { sendNotification } from "../services/notifier.js";
+import { memoize } from "lodash-es";
+const DEFAULT_INTERACTION_THRESHOLD_MS = 6e3;
+const STATE = {
+  lastInteractionTime: Date.now()
+};
+function updateLastInteractionTime() {
+  STATE.lastInteractionTime = Date.now();
+}
+function getTimeSinceLastInteraction() {
+  return Date.now() - STATE.lastInteractionTime;
+}
+function hasRecentInteraction(threshold) {
+  return getTimeSinceLastInteraction() < threshold;
+}
+function shouldNotify(threshold) {
+  return process.env.NODE_ENV !== "test" && !hasRecentInteraction(threshold);
+}
+const init = memoize(() => process.stdin.on("data", updateLastInteractionTime));
+function useNotifyAfterTimeout(message, timeout = DEFAULT_INTERACTION_THRESHOLD_MS) {
+  useEffect(() => {
+    init();
+    updateLastInteractionTime();
+  }, []);
+  useEffect(() => {
+    let hasNotified = false;
+    const timer = setInterval(() => {
+      if (shouldNotify(timeout) && !hasNotified) {
+        hasNotified = true;
+        sendNotification({
+          message
+        });
+      }
+    }, timeout);
+    return () => clearTimeout(timer);
+  }, [message, timeout]);
+}
+export {
+  useNotifyAfterTimeout
+};
+//# sourceMappingURL=useNotifyAfterTimeout.js.map

package/dist/hooks/useNotifyAfterTimeout.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useNotifyAfterTimeout.ts"],
+  "sourcesContent": ["import { useEffect } from 'react'\nimport { sendNotification } from '@services/notifier'\nimport { memoize } from 'lodash-es'\n\n// The time threshold in milliseconds for considering an interaction \"recent\" (6 seconds)\nconst DEFAULT_INTERACTION_THRESHOLD_MS = 6000\n\nconst STATE = {\n  lastInteractionTime: Date.now(),\n}\n\nfunction updateLastInteractionTime(): void {\n  STATE.lastInteractionTime = Date.now()\n}\n\nfunction getTimeSinceLastInteraction(): number {\n  return Date.now() - STATE.lastInteractionTime\n}\n\nfunction hasRecentInteraction(threshold: number): boolean {\n  return getTimeSinceLastInteraction() < threshold\n}\n\nfunction shouldNotify(threshold: number): boolean {\n  return process.env.NODE_ENV !== 'test' && !hasRecentInteraction(threshold)\n}\n\n// Start tracking the time of the user's last interaction with the app\nconst init = memoize(() => process.stdin.on('data', updateLastInteractionTime))\n\n/**\n * Hook that manages desktop notifications after a timeout period.\n *\n * Shows a notification in two cases:\n * 1. Immediately if the app has been idle for longer than the threshold\n * 2. After the specified timeout if the user doesn't interact within that time\n *\n * @param message - The notification message to display\n * @param timeout - The timeout in milliseconds (defaults to 6000ms)\n */\nexport function useNotifyAfterTimeout(\n  message: string,\n  timeout: number = DEFAULT_INTERACTION_THRESHOLD_MS,\n): void {\n  // Reset interaction time when hook is called to make sure that requests\n  // that took a long time to complete don't pop up a notification right away\n  useEffect(() => {\n    init()\n    updateLastInteractionTime()\n  }, [])\n\n  useEffect(() => {\n    let hasNotified = false\n    const timer = setInterval(() => {\n      if (shouldNotify(timeout) && !hasNotified) {\n        hasNotified = true\n        sendNotification({\n          message,\n        })\n      }\n    }, timeout)\n\n    return () => clearTimeout(timer)\n  }, [message, timeout])\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AACjC,SAAS,eAAe;AAGxB,MAAM,mCAAmC;AAEzC,MAAM,QAAQ;AAAA,EACZ,qBAAqB,KAAK,IAAI;AAChC;AAEA,SAAS,4BAAkC;AACzC,QAAM,sBAAsB,KAAK,IAAI;AACvC;AAEA,SAAS,8BAAsC;AAC7C,SAAO,KAAK,IAAI,IAAI,MAAM;AAC5B;AAEA,SAAS,qBAAqB,WAA4B;AACxD,SAAO,4BAA4B,IAAI;AACzC;AAEA,SAAS,aAAa,WAA4B;AAChD,SAAO,QAAQ,IAAI,aAAa,UAAU,CAAC,qBAAqB,SAAS;AAC3E;AAGA,MAAM,OAAO,QAAQ,MAAM,QAAQ,MAAM,GAAG,QAAQ,yBAAyB,CAAC;AAYvE,SAAS,sBACd,SACA,UAAkB,kCACZ;AAGN,YAAU,MAAM;AACd,SAAK;AACL,8BAA0B;AAAA,EAC5B,GAAG,CAAC,CAAC;AAEL,YAAU,MAAM;AACd,QAAI,cAAc;AAClB,UAAM,QAAQ,YAAY,MAAM;AAC9B,UAAI,aAAa,OAAO,KAAK,CAAC,aAAa;AACzC,sBAAc;AACd,yBAAiB;AAAA,UACf;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF,GAAG,OAAO;AAEV,WAAO,MAAM,aAAa,KAAK;AAAA,EACjC,GAAG,CAAC,SAAS,OAAO,CAAC;AACvB;",
+  "names": []
+}

package/dist/hooks/usePermissionRequestLogging.js

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+import { logUnaryEvent } from "../utils/unaryLogging.js";
+import { env } from "../utils/env.js";
+function usePermissionRequestLogging(toolUseConfirm, unaryEvent) {
+  useEffect(() => {
+    const languagePromise = Promise.resolve(unaryEvent.language_name);
+    languagePromise.then((language) => {
+      logUnaryEvent({
+        completion_type: unaryEvent.completion_type,
+        event: "response",
+        metadata: {
+          language_name: language,
+          message_id: toolUseConfirm.assistantMessage.message.id,
+          platform: env.platform
+        }
+      });
+    });
+  }, [toolUseConfirm, unaryEvent]);
+}
+export {
+  usePermissionRequestLogging
+};
+//# sourceMappingURL=usePermissionRequestLogging.js.map

package/dist/hooks/usePermissionRequestLogging.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/usePermissionRequestLogging.ts"],
+  "sourcesContent": ["import { useEffect } from 'react'\n \nimport { logUnaryEvent, CompletionType } from '@utils/unaryLogging'\nimport { ToolUseConfirm } from '@components/permissions/PermissionRequest'\nimport { env } from '@utils/env'\n\nexport type UnaryEvent = {\n  completion_type: CompletionType\n  language_name: string | Promise<string>\n}\n\n/**\n * Logs permission request events via unary logging.\n * Can handle either a string or Promise<string> for language_name.\n */\nexport function usePermissionRequestLogging(\n  toolUseConfirm: ToolUseConfirm,\n  unaryEvent: UnaryEvent,\n): void {\n  useEffect(() => {\n    \n\n    // Handle string or Promise language name\n    const languagePromise = Promise.resolve(unaryEvent.language_name)\n\n    // Log unary event once language is resolved\n    languagePromise.then(language => {\n      logUnaryEvent({\n        completion_type: unaryEvent.completion_type,\n        event: 'response',\n        metadata: {\n          language_name: language,\n          message_id: toolUseConfirm.assistantMessage.message.id,\n          platform: env.platform,\n        },\n      })\n    })\n  }, [toolUseConfirm, unaryEvent])\n}\n"],
+  "mappings": "AAAA,SAAS,iBAAiB;AAE1B,SAAS,qBAAqC;AAE9C,SAAS,WAAW;AAWb,SAAS,4BACd,gBACA,YACM;AACN,YAAU,MAAM;AAId,UAAM,kBAAkB,QAAQ,QAAQ,WAAW,aAAa;AAGhE,oBAAgB,KAAK,cAAY;AAC/B,oBAAc;AAAA,QACZ,iBAAiB,WAAW;AAAA,QAC5B,OAAO;AAAA,QACP,UAAU;AAAA,UACR,eAAe;AAAA,UACf,YAAY,eAAe,iBAAiB,QAAQ;AAAA,UACpD,UAAU,IAAI;AAAA,QAChB;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,GAAG,CAAC,gBAAgB,UAAU,CAAC;AACjC;",
+  "names": []
+}

package/dist/hooks/useTerminalSize.js

@@ -0,0 +1,38 @@
+import { useEffect, useState } from "react";
+let globalSize = {
+  columns: process.stdout.columns || 80,
+  rows: process.stdout.rows || 24
+};
+const listeners = /* @__PURE__ */ new Set();
+let isListenerAttached = false;
+function updateAllListeners() {
+  globalSize = {
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  };
+  listeners.forEach((listener) => listener());
+}
+function useTerminalSize() {
+  const [size, setSize] = useState(globalSize);
+  useEffect(() => {
+    const updateSize = () => setSize({ ...globalSize });
+    listeners.add(updateSize);
+    if (!isListenerAttached) {
+      process.stdout.setMaxListeners(20);
+      process.stdout.on("resize", updateAllListeners);
+      isListenerAttached = true;
+    }
+    return () => {
+      listeners.delete(updateSize);
+      if (listeners.size === 0 && isListenerAttached) {
+        process.stdout.off("resize", updateAllListeners);
+        isListenerAttached = false;
+      }
+    };
+  }, []);
+  return size;
+}
+export {
+  useTerminalSize
+};
+//# sourceMappingURL=useTerminalSize.js.map

package/dist/hooks/useTerminalSize.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/hooks/useTerminalSize.ts"],
+  "sourcesContent": ["import { useEffect, useState } from 'react'\n\n// Global state to share across all hook instances\nlet globalSize = {\n  columns: process.stdout.columns || 80,\n  rows: process.stdout.rows || 24,\n}\n\nconst listeners = new Set<() => void>()\nlet isListenerAttached = false\n\nfunction updateAllListeners() {\n  globalSize = {\n    columns: process.stdout.columns || 80,\n    rows: process.stdout.rows || 24,\n  }\n  listeners.forEach(listener => listener())\n}\n\nexport function useTerminalSize() {\n  const [size, setSize] = useState(globalSize)\n\n  useEffect(() => {\n    // Add this component's listener to the set\n    const updateSize = () => setSize({ ...globalSize })\n    listeners.add(updateSize)\n\n    // Only attach the global resize listener once\n    if (!isListenerAttached) {\n      // Increase max listeners to prevent warnings\n      process.stdout.setMaxListeners(20)\n      process.stdout.on('resize', updateAllListeners)\n      isListenerAttached = true\n    }\n\n    return () => {\n      // Remove this component's listener\n      listeners.delete(updateSize)\n\n      // If no more listeners, remove the global listener\n      if (listeners.size === 0 && isListenerAttached) {\n        process.stdout.off('resize', updateAllListeners)\n        isListenerAttached = false\n      }\n    }\n  }, [])\n\n  return size\n}\n"],
+  "mappings": "AAAA,SAAS,WAAW,gBAAgB;AAGpC,IAAI,aAAa;AAAA,EACf,SAAS,QAAQ,OAAO,WAAW;AAAA,EACnC,MAAM,QAAQ,OAAO,QAAQ;AAC/B;AAEA,MAAM,YAAY,oBAAI,IAAgB;AACtC,IAAI,qBAAqB;AAEzB,SAAS,qBAAqB;AAC5B,eAAa;AAAA,IACX,SAAS,QAAQ,OAAO,WAAW;AAAA,IACnC,MAAM,QAAQ,OAAO,QAAQ;AAAA,EAC/B;AACA,YAAU,QAAQ,cAAY,SAAS,CAAC;AAC1C;AAEO,SAAS,kBAAkB;AAChC,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,UAAU;AAE3C,YAAU,MAAM;AAEd,UAAM,aAAa,MAAM,QAAQ,EAAE,GAAG,WAAW,CAAC;AAClD,cAAU,IAAI,UAAU;AAGxB,QAAI,CAAC,oBAAoB;AAEvB,cAAQ,OAAO,gBAAgB,EAAE;AACjC,cAAQ,OAAO,GAAG,UAAU,kBAAkB;AAC9C,2BAAqB;AAAA,IACvB;AAEA,WAAO,MAAM;AAEX,gBAAU,OAAO,UAAU;AAG3B,UAAI,UAAU,SAAS,KAAK,oBAAoB;AAC9C,gBAAQ,OAAO,IAAI,UAAU,kBAAkB;AAC/C,6BAAqB;AAAA,MACvB;AAAA,IACF;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;",
+  "names": []
+}

package/dist/hooks/useTextInput.js

@@ -0,0 +1,252 @@
+import { useState } from "react";
+import { useDoublePress } from "./useDoublePress.js";
+import { Cursor } from "../utils/Cursor.js";
+import {
+  getImageFromClipboard,
+  CLIPBOARD_ERROR_MESSAGE
+} from "../utils/imagePaste.js";
+const IMAGE_PLACEHOLDER = "[Image pasted]";
+function mapInput(input_map) {
+  return function(input) {
+    const handler = new Map(input_map).get(input) ?? (() => {
+    });
+    return handler(input);
+  };
+}
+function useTextInput({
+  value: originalValue,
+  onChange,
+  onSubmit,
+  onExit,
+  onExitMessage,
+  onMessage,
+  onHistoryUp,
+  onHistoryDown,
+  onHistoryReset,
+  mask = "",
+  multiline = false,
+  cursorChar,
+  invert,
+  columns,
+  onImagePaste,
+  disableCursorMovementForUpDownKeys = false,
+  externalOffset,
+  onOffsetChange
+}) {
+  const offset = externalOffset;
+  const setOffset = onOffsetChange;
+  const cursor = Cursor.fromText(originalValue, columns, offset);
+  const [imagePasteErrorTimeout, setImagePasteErrorTimeout] = useState(null);
+  function maybeClearImagePasteErrorTimeout() {
+    if (!imagePasteErrorTimeout) {
+      return;
+    }
+    clearTimeout(imagePasteErrorTimeout);
+    setImagePasteErrorTimeout(null);
+    onMessage?.(false);
+  }
+  const handleCtrlC = useDoublePress(
+    (show) => {
+      maybeClearImagePasteErrorTimeout();
+      onExitMessage?.(show, "Ctrl-C");
+    },
+    () => onExit?.(),
+    () => {
+      if (originalValue) {
+        onChange("");
+        onHistoryReset?.();
+      }
+    }
+  );
+  const handleEscape = useDoublePress(
+    (show) => {
+      maybeClearImagePasteErrorTimeout();
+      onMessage?.(!!originalValue && show, `Press Escape again to clear`);
+    },
+    () => {
+      if (originalValue) {
+        onChange("");
+      }
+    }
+  );
+  function clear() {
+    return Cursor.fromText("", columns, 0);
+  }
+  const handleEmptyCtrlD = useDoublePress(
+    (show) => onExitMessage?.(show, "Ctrl-D"),
+    () => onExit?.()
+  );
+  function handleCtrlD() {
+    maybeClearImagePasteErrorTimeout();
+    if (cursor.text === "") {
+      handleEmptyCtrlD();
+      return cursor;
+    }
+    return cursor.del();
+  }
+  function tryImagePaste() {
+    const base64Image = getImageFromClipboard();
+    if (base64Image === null) {
+      if (process.platform !== "darwin") {
+        return cursor;
+      }
+      onMessage?.(true, CLIPBOARD_ERROR_MESSAGE);
+      maybeClearImagePasteErrorTimeout();
+      setImagePasteErrorTimeout(
+        setTimeout(() => {
+          onMessage?.(false);
+        }, 4e3)
+      );
+      return cursor;
+    }
+    onImagePaste?.(base64Image);
+    return cursor.insert(IMAGE_PLACEHOLDER);
+  }
+  const handleCtrl = mapInput([
+    ["a", () => cursor.startOfLine()],
+    ["b", () => cursor.left()],
+    ["c", handleCtrlC],
+    ["d", handleCtrlD],
+    ["e", () => cursor.endOfLine()],
+    ["f", () => cursor.right()],
+    [
+      "h",
+      () => {
+        maybeClearImagePasteErrorTimeout();
+        return cursor.backspace();
+      }
+    ],
+    ["j", () => cursor.insert("\n")],
+    // Ctrl+J: Raw newline (Phase 2)
+    ["k", () => cursor.deleteToLineEnd()],
+    ["l", () => clear()],
+    ["n", () => downOrHistoryDown()],
+    ["p", () => upOrHistoryUp()],
+    ["u", () => cursor.deleteToLineStart()],
+    ["v", tryImagePaste],
+    ["w", () => cursor.deleteWordBefore()]
+  ]);
+  const handleMeta = mapInput([
+    ["b", () => cursor.prevWord()],
+    ["f", () => cursor.nextWord()],
+    ["d", () => cursor.deleteWordAfter()]
+  ]);
+  function handleEnter(key) {
+    if (multiline && cursor.offset > 0 && cursor.text[cursor.offset - 1] === "\\") {
+      return cursor.backspace().insert("\n");
+    }
+    if (key.meta) {
+      return cursor.insert("\n");
+    }
+    onSubmit?.(originalValue);
+  }
+  function upOrHistoryUp() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryUp?.();
+      return cursor;
+    }
+    const cursorUp = cursor.up();
+    if (cursorUp.equals(cursor)) {
+      onHistoryUp?.();
+    }
+    return cursorUp;
+  }
+  function downOrHistoryDown() {
+    if (disableCursorMovementForUpDownKeys) {
+      onHistoryDown?.();
+      return cursor;
+    }
+    const cursorDown = cursor.down();
+    if (cursorDown.equals(cursor)) {
+      onHistoryDown?.();
+    }
+    return cursorDown;
+  }
+  function onInput(input, key) {
+    if (key.tab) {
+      return;
+    }
+    if (key.backspace || key.delete || input === "\b" || input === "\x7F" || input === "\b") {
+      const nextCursor2 = cursor.backspace();
+      if (!cursor.equals(nextCursor2)) {
+        setOffset(nextCursor2.offset);
+        if (cursor.text !== nextCursor2.text) {
+          onChange(nextCursor2.text);
+        }
+      }
+      return;
+    }
+    const nextCursor = mapKey(key)(input);
+    if (nextCursor) {
+      if (!cursor.equals(nextCursor)) {
+        setOffset(nextCursor.offset);
+        if (cursor.text !== nextCursor.text) {
+          onChange(nextCursor.text);
+        }
+      }
+    }
+  }
+  function mapKey(key) {
+    if (key.backspace || key.delete) {
+      maybeClearImagePasteErrorTimeout();
+      return () => cursor.backspace();
+    }
+    switch (true) {
+      case key.escape:
+        return handleEscape;
+      case (key.leftArrow && (key.ctrl || key.meta || "fn" in key && key.fn)):
+        return () => cursor.prevWord();
+      case (key.rightArrow && (key.ctrl || key.meta || "fn" in key && key.fn)):
+        return () => cursor.nextWord();
+      case key.ctrl:
+        return handleCtrl;
+      case ("home" in key && key.home):
+        return () => cursor.startOfLine();
+      case ("end" in key && key.end):
+        return () => cursor.endOfLine();
+      case key.pageDown:
+        return () => cursor.endOfLine();
+      case key.pageUp:
+        return () => cursor.startOfLine();
+      case key.meta:
+        return handleMeta;
+      case key.return:
+        return () => handleEnter(key);
+      // Remove Tab handling - let completion system handle it
+      case key.upArrow:
+        return upOrHistoryUp;
+      case key.downArrow:
+        return downOrHistoryDown;
+      case key.leftArrow:
+        return () => cursor.left();
+      case key.rightArrow:
+        return () => cursor.right();
+    }
+    return function(input) {
+      switch (true) {
+        // Home key
+        case (input == "\x1B[H" || input == "\x1B[1~"):
+          return cursor.startOfLine();
+        // End key
+        case (input == "\x1B[F" || input == "\x1B[4~"):
+          return cursor.endOfLine();
+        // Handle backspace character explicitly - this is the key fix
+        case (input === "\b" || input === "\x7F" || input === "\b"):
+          maybeClearImagePasteErrorTimeout();
+          return cursor.backspace();
+        default:
+          return cursor.insert(input.replace(/\r/g, "\n"));
+      }
+    };
+  }
+  return {
+    onInput,
+    renderedValue: cursor.render(cursorChar, mask, invert),
+    offset,
+    setOffset
+  };
+}
+export {
+  useTextInput
+};
+//# sourceMappingURL=useTextInput.js.map