@within-7/minto 0.4.1 → 0.4.3

package/dist/hooks/useAgentTranscripts.js

@@ -1,141 +0,0 @@
-import { useState, useEffect, useMemo, useCallback, useRef } from "react";
-import {
-  transcriptEmitter,
-  getAgentTranscript
-} from "../utils/agentTranscripts.js";
-function useAgentTranscripts(agentIds) {
-  const [transcripts, setTranscripts] = useState(
-    () => /* @__PURE__ */ new Map()
-  );
-  const lazyLoadCacheRef = useRef(/* @__PURE__ */ new Map());
-  const syncScheduledRef = useRef(false);
-  const trackedAgentIds = useMemo(
-    () => agentIds ? new Set(agentIds) : null,
-    [agentIds?.join(",")]
-  );
-  useEffect(() => {
-    const handleUpdate = (event) => {
-      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {
-        return;
-      }
-      setTranscripts((prev) => {
-        const next = new Map(prev);
-        next.set(event.agentId, event.transcript);
-        return next;
-      });
-    };
-    transcriptEmitter.on("update", handleUpdate);
-    if (trackedAgentIds) {
-      for (const agentId of trackedAgentIds) {
-        const transcript = getAgentTranscript(agentId);
-        if (transcript) {
-          setTranscripts((prev) => {
-            const next = new Map(prev);
-            next.set(agentId, transcript);
-            return next;
-          });
-        }
-      }
-    }
-    return () => {
-      transcriptEmitter.off("update", handleUpdate);
-    };
-  }, [trackedAgentIds]);
-  const getTranscriptCallback = useCallback(
-    (agentId) => {
-      const cached = transcripts.get(agentId);
-      if (cached) {
-        return cached;
-      }
-      const lazyCached = lazyLoadCacheRef.current.get(agentId);
-      if (lazyCached) {
-        return lazyCached;
-      }
-      const loaded = getAgentTranscript(agentId);
-      if (loaded) {
-        lazyLoadCacheRef.current.set(agentId, loaded);
-      }
-      return loaded;
-    },
-    [transcripts]
-  );
-  useEffect(() => {
-    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {
-      syncScheduledRef.current = true;
-      const timeoutId = setTimeout(() => {
-        setTranscripts((prev) => {
-          const next = new Map(prev);
-          for (const [agentId, transcript] of lazyLoadCacheRef.current) {
-            if (!next.has(agentId)) {
-              next.set(agentId, transcript);
-            }
-          }
-          return next;
-        });
-        lazyLoadCacheRef.current = /* @__PURE__ */ new Map();
-        syncScheduledRef.current = false;
-      }, 0);
-      return () => {
-        clearTimeout(timeoutId);
-        syncScheduledRef.current = false;
-      };
-    }
-    return void 0;
-  }, [transcripts]);
-  const refreshTranscript = useCallback((agentId) => {
-    const fresh = getAgentTranscript(agentId);
-    if (fresh) {
-      setTranscripts((prev) => {
-        const next = new Map(prev);
-        next.set(agentId, fresh);
-        return next;
-      });
-    }
-  }, []);
-  const activeCount = useMemo(() => {
-    let count = 0;
-    for (const transcript of transcripts.values()) {
-      if (transcript.status === "running" || transcript.status === "pending") {
-        count++;
-      }
-    }
-    return count;
-  }, [transcripts]);
-  return {
-    transcripts,
-    getTranscript: getTranscriptCallback,
-    refreshTranscript,
-    activeCount
-  };
-}
-function useAgentTranscript(agentId) {
-  const [transcript, setTranscript] = useState(() => {
-    if (!agentId) return null;
-    return getAgentTranscript(agentId);
-  });
-  useEffect(() => {
-    if (!agentId) {
-      setTranscript(null);
-      return void 0;
-    }
-    const initial = getAgentTranscript(agentId);
-    if (initial) {
-      setTranscript(initial);
-    }
-    const handleUpdate = (event) => {
-      if (event.agentId === agentId) {
-        setTranscript(event.transcript);
-      }
-    };
-    transcriptEmitter.on("update", handleUpdate);
-    return () => {
-      transcriptEmitter.off("update", handleUpdate);
-    };
-  }, [agentId]);
-  return transcript;
-}
-export {
-  useAgentTranscript,
-  useAgentTranscripts
-};
-//# sourceMappingURL=useAgentTranscripts.js.map

package/dist/hooks/useAgentTranscripts.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAgentTranscripts.ts"],
-  "sourcesContent": ["/**\n * useAgentTranscripts Hook\n *\n * Provides real-time access to agent transcripts with automatic updates.\n * Subscribes to transcript events and maintains a reactive map of transcripts.\n */\n\nimport { useState, useEffect, useMemo, useCallback, useRef } from 'react'\nimport {\n  transcriptEmitter,\n  getAgentTranscript,\n  type AgentTranscript,\n  type TranscriptEvent,\n} from '@utils/agentTranscripts'\n\ninterface UseAgentTranscriptsResult {\n  /** Map of agentId to transcript */\n  transcripts: Map<string, AgentTranscript>\n  /** Get transcript by agentId */\n  getTranscript: (agentId: string) => AgentTranscript | null\n  /** Force refresh of a specific transcript */\n  refreshTranscript: (agentId: string) => void\n  /** Number of active transcripts */\n  activeCount: number\n}\n\n/**\n * Hook for accessing agent transcripts with real-time updates\n *\n * @param agentIds - Optional list of specific agent IDs to track\n * @returns Transcript state and utilities\n */\nexport function useAgentTranscripts(\n  agentIds?: string[],\n): UseAgentTranscriptsResult {\n  // State to hold current transcripts\n  const [transcripts, setTranscripts] = useState<Map<string, AgentTranscript>>(\n    () => new Map(),\n  )\n\n  // Ref-based cache for lazy loading during render (avoids setState during render)\n  // This allows getTranscript to return cached values synchronously without triggering re-renders\n  const lazyLoadCacheRef = useRef<Map<string, AgentTranscript>>(new Map())\n\n  // Prevent duplicate sync scheduling - avoids infinite render loops\n  const syncScheduledRef = useRef<boolean>(false)\n\n  // Track which agents we're interested in\n  const trackedAgentIds = useMemo(\n    () => (agentIds ? new Set(agentIds) : null),\n    [agentIds?.join(',')],\n  )\n\n  // Handle transcript updates\n  useEffect(() => {\n    const handleUpdate = (event: TranscriptEvent) => {\n      // If we have a tracked list and this agent isn't in it, skip\n      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {\n        return\n      }\n\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(event.agentId, event.transcript)\n        return next\n      })\n    }\n\n    // Subscribe to all transcript updates\n    transcriptEmitter.on('update', handleUpdate)\n\n    // Initial load for tracked agents\n    if (trackedAgentIds) {\n      for (const agentId of trackedAgentIds) {\n        const transcript = getAgentTranscript(agentId)\n        if (transcript) {\n          setTranscripts(prev => {\n            const next = new Map(prev)\n            next.set(agentId, transcript)\n            return next\n          })\n        }\n      }\n    }\n\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [trackedAgentIds])\n\n  // Get transcript by ID (with fallback to disk)\n  // IMPORTANT: This function may be called during render (e.g., by ParallelTasksGroupView),\n  // so we must NOT call setTranscripts here. Instead, we use a ref-based cache for lazy loading\n  // and schedule state updates via useEffect.\n  const getTranscriptCallback = useCallback(\n    (agentId: string): AgentTranscript | null => {\n      // Check state first (reactive updates)\n      const cached = transcripts.get(agentId)\n      if (cached) {\n        return cached\n      }\n\n      // Check ref cache (lazy loaded during render)\n      const lazyCached = lazyLoadCacheRef.current.get(agentId)\n      if (lazyCached) {\n        return lazyCached\n      }\n\n      // Try to load from disk - store in ref only (no setState during render!)\n      const loaded = getAgentTranscript(agentId)\n      if (loaded) {\n        lazyLoadCacheRef.current.set(agentId, loaded)\n      }\n      return loaded\n    },\n    [transcripts],\n  )\n\n  // Sync lazy-loaded transcripts from ref cache to state after render\n  // This ensures state stays up-to-date for future renders without causing\n  // \"Cannot update component while rendering\" warnings\n  useEffect(() => {\n    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {\n      syncScheduledRef.current = true\n      const timeoutId = setTimeout(() => {\n        setTranscripts(prev => {\n          const next = new Map(prev)\n          for (const [agentId, transcript] of lazyLoadCacheRef.current) {\n            if (!next.has(agentId)) {\n              next.set(agentId, transcript)\n            }\n          }\n          return next\n        })\n        lazyLoadCacheRef.current = new Map()\n        syncScheduledRef.current = false\n      }, 0)\n      return () => {\n        clearTimeout(timeoutId)\n        syncScheduledRef.current = false\n      }\n    }\n    return undefined\n  }, [transcripts])\n\n  // Force refresh a specific transcript\n  const refreshTranscript = useCallback((agentId: string) => {\n    const fresh = getAgentTranscript(agentId)\n    if (fresh) {\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(agentId, fresh)\n        return next\n      })\n    }\n  }, [])\n\n  // Count active (non-completed) transcripts\n  const activeCount = useMemo(() => {\n    let count = 0\n    for (const transcript of transcripts.values()) {\n      if (transcript.status === 'running' || transcript.status === 'pending') {\n        count++\n      }\n    }\n    return count\n  }, [transcripts])\n\n  return {\n    transcripts,\n    getTranscript: getTranscriptCallback,\n    refreshTranscript,\n    activeCount,\n  }\n}\n\n/**\n * Simplified hook for single transcript tracking\n */\nexport function useAgentTranscript(\n  agentId: string | undefined,\n): AgentTranscript | null {\n  const [transcript, setTranscript] = useState<AgentTranscript | null>(() => {\n    if (!agentId) return null\n    return getAgentTranscript(agentId)\n  })\n\n  useEffect(() => {\n    if (!agentId) {\n      setTranscript(null)\n      return undefined\n    }\n\n    // Load initial\n    const initial = getAgentTranscript(agentId)\n    if (initial) {\n      setTranscript(initial)\n    }\n\n    // Subscribe to updates for this specific agent\n    const handleUpdate = (event: TranscriptEvent) => {\n      if (event.agentId === agentId) {\n        setTranscript(event.transcript)\n      }\n    }\n\n    transcriptEmitter.on('update', handleUpdate)\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [agentId])\n\n  return transcript\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/hooks/useAnimationSync.js

@@ -1,53 +0,0 @@
-import { useState, useEffect } from "react";
-import { animationSync, ANIMATION_INTERVALS } from "../utils/animationSync.js";
-function useAnimationSync() {
-  const [state, setState] = useState(
-    () => animationSync.getFrame()
-  );
-  useEffect(() => {
-    const unsubscribe = animationSync.subscribe((frame) => {
-      setState(frame);
-    });
-    return unsubscribe;
-  }, []);
-  return state;
-}
-function useSpinnerAnimation(frames) {
-  const [frameIndex, setFrameIndex] = useState(0);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setFrameIndex((f) => (f + 1) % frames.length);
-    }, ANIMATION_INTERVALS.SPINNER);
-    return () => clearInterval(timer);
-  }, [frames.length]);
-  return frames[frameIndex] || frames[0] || "";
-}
-function useBlinkAnimation() {
-  const [visible, setVisible] = useState(true);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setVisible((v) => !v);
-    }, ANIMATION_INTERVALS.BLINK);
-    return () => clearInterval(timer);
-  }, []);
-  return visible;
-}
-function useElapsedTime(startTime) {
-  const [elapsed, setElapsed] = useState(0);
-  const start = startTime ?? Date.now();
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setElapsed(Math.floor((Date.now() - start) / 1e3));
-    }, ANIMATION_INTERVALS.ELAPSED_TIME);
-    return () => clearInterval(timer);
-  }, [start]);
-  return elapsed;
-}
-export {
-  ANIMATION_INTERVALS,
-  useAnimationSync,
-  useBlinkAnimation,
-  useElapsedTime,
-  useSpinnerAnimation
-};
-//# sourceMappingURL=useAnimationSync.js.map

package/dist/hooks/useAnimationSync.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAnimationSync.ts"],
-  "sourcesContent": ["/**\n * React hook for synchronized animations across components\n *\n * Provides synchronized animation state that updates at consistent intervals:\n * - Spinner: 120ms\n * - Blinking: 600ms\n * - Elapsed Time: 1000ms\n *\n * Usage:\n * ```tsx\n * function MySpinner() {\n *   const { spinnerFrame, blinkVisible, elapsedSeconds } = useAnimationSync()\n *   const spinnerChars = ['\u00B7', '\u2722', '\u2733', '\u2217', '\u273B', '\u273D']\n *   return <Text>{spinnerChars[spinnerFrame % spinnerChars.length]}</Text>\n * }\n * ```\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { animationSync, ANIMATION_INTERVALS } from '@utils/animationSync'\n\nexport interface AnimationState {\n  spinnerFrame: number\n  blinkVisible: boolean\n  elapsedSeconds: number\n}\n\n/**\n * Hook for synchronized animation state\n * Components using this hook will animate in sync with each other\n */\nexport function useAnimationSync(): AnimationState {\n  const [state, setState] = useState<AnimationState>(() =>\n    animationSync.getFrame(),\n  )\n\n  useEffect(() => {\n    const unsubscribe = animationSync.subscribe(frame => {\n      setState(frame)\n    })\n\n    return unsubscribe\n  }, [])\n\n  return state\n}\n\n/**\n * Hook for just the spinner animation (120ms interval)\n * Lighter weight than full animation sync if you only need spinner\n */\nexport function useSpinnerAnimation(frames: string[]): string {\n  const [frameIndex, setFrameIndex] = useState(0)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setFrameIndex(f => (f + 1) % frames.length)\n    }, ANIMATION_INTERVALS.SPINNER)\n\n    return () => clearInterval(timer)\n  }, [frames.length])\n\n  return frames[frameIndex] || frames[0] || ''\n}\n\n/**\n * Hook for blinking animation (600ms interval)\n */\nexport function useBlinkAnimation(): boolean {\n  const [visible, setVisible] = useState(true)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setVisible(v => !v)\n    }, ANIMATION_INTERVALS.BLINK)\n\n    return () => clearInterval(timer)\n  }, [])\n\n  return visible\n}\n\n/**\n * Hook for elapsed time counter (1000ms interval)\n */\nexport function useElapsedTime(startTime?: number): number {\n  const [elapsed, setElapsed] = useState(0)\n  const start = startTime ?? Date.now()\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setElapsed(Math.floor((Date.now() - start) / 1000))\n    }, ANIMATION_INTERVALS.ELAPSED_TIME)\n\n    return () => clearInterval(timer)\n  }, [start])\n\n  return elapsed\n}\n\n// Re-export intervals for convenience\nexport { ANIMATION_INTERVALS }\n"],
-  "mappings": "AAkBA,SAAS,UAAU,iBAA8B;AACjD,SAAS,eAAe,2BAA2B;AAY5C,SAAS,mBAAmC;AACjD,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAAyB,MACjD,cAAc,SAAS;AAAA,EACzB;AAEA,YAAU,MAAM;AACd,UAAM,cAAc,cAAc,UAAU,WAAS;AACnD,eAAS,KAAK;AAAA,IAChB,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAMO,SAAS,oBAAoB,QAA0B;AAC5D,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,CAAC;AAE9C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,oBAAc,QAAM,IAAI,KAAK,OAAO,MAAM;AAAA,IAC5C,GAAG,oBAAoB,OAAO;AAE9B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,OAAO,MAAM,CAAC;AAElB,SAAO,OAAO,UAAU,KAAK,OAAO,CAAC,KAAK;AAC5C;AAKO,SAAS,oBAA6B;AAC3C,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,IAAI;AAE3C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,OAAK,CAAC,CAAC;AAAA,IACpB,GAAG,oBAAoB,KAAK;AAE5B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAKO,SAAS,eAAe,WAA4B;AACzD,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,CAAC;AACxC,QAAM,QAAQ,aAAa,KAAK,IAAI;AAEpC,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,KAAK,OAAO,KAAK,IAAI,IAAI,SAAS,GAAI,CAAC;AAAA,IACpD,GAAG,oBAAoB,YAAY;AAEnC,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,KAAK,CAAC;AAEV,SAAO;AACT;",
-  "names": []
-}

package/dist/hooks/useApiKeyVerification.js

@@ -1,12 +0,0 @@
-function useApiKeyVerification() {
-  return {
-    status: "valid",
-    reverify: async () => {
-    },
-    error: null
-  };
-}
-export {
-  useApiKeyVerification
-};
-//# sourceMappingURL=useApiKeyVerification.js.map

package/dist/hooks/useApiKeyVerification.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useApiKeyVerification.ts"],
-  "sourcesContent": ["import { useCallback, useState } from 'react'\nimport { verifyApiKey } from '@services/claude'\nimport { getAnthropicApiKey } from '@utils/config'\n\nexport type VerificationStatus =\n  | 'loading'\n  | 'valid'\n  | 'invalid'\n  | 'missing'\n  | 'error'\n\nexport type ApiKeyVerificationResult = {\n  status: VerificationStatus\n  reverify: () => Promise<void>\n  error: Error | null\n}\n\nexport function useApiKeyVerification(): ApiKeyVerificationResult {\n  // const [status, setStatus] = useState<VerificationStatus>(() => {\n  //   const apiKey = getAnthropicApiKey()\n  //   return apiKey ? 'loading' : 'missing'\n  // })\n  // const [error, setError] = useState<Error | null>(null)\n\n  // const verify = useCallback(async (): Promise<void> => {\n  //   if (isDefaultApiKey()) {\n  //     setStatus('valid')\n  //     return\n  //   }\n\n  //   const apiKey = getAnthropicApiKey()\n  //   if (!apiKey) {\n  //     const newStatus = 'missing' as const\n  //     setStatus(newStatus)\n  //     return\n  //   }\n\n  //   try {\n  //     const isValid = await verifyApiKey(apiKey)\n  //     const newStatus = isValid ? 'valid' : 'invalid'\n  //     setStatus(newStatus)\n  //     return\n  //   } catch (error) {\n  //     // This happens when there an error response from the API but it's not an invalid API key error\n  //     // In this case, we still mark the API key as invalid - but we also log the error so we can\n  //     // display it to the user to be more helpful\n  //     setError(error as Error)\n  //     const newStatus = 'error' as const\n  //     setStatus(newStatus)\n  //     return\n  //   }\n  // }, [])\n\n  return {\n    status: 'valid',\n    reverify: async () => {},\n    error: null,\n  }\n}\n"],
-  "mappings": "AAiBO,SAAS,wBAAkD;AAoChE,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,UAAU,YAAY;AAAA,IAAC;AAAA,IACvB,OAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/dist/hooks/useArrowKeyHistory.js

@@ -1,52 +0,0 @@
-import { useState } from "react";
-import { getHistory } from "../history.js";
-import { sanitizeInput } from "../utils/sanitizeInput.js";
-function useArrowKeyHistory(onSetInput, currentInput) {
-  const [historyIndex, setHistoryIndex] = useState(0);
-  const [lastTypedInput, setLastTypedInput] = useState("");
-  const updateInput = (input) => {
-    if (input !== void 0) {
-      const sanitized = sanitizeInput(input);
-      const mode = sanitized.startsWith("!") ? "bash" : "prompt";
-      const value = mode === "bash" ? sanitized.slice(1) : sanitized;
-      onSetInput(value, mode);
-    }
-  };
-  function onHistoryUp() {
-    const latestHistory = getHistory();
-    if (historyIndex < latestHistory.length) {
-      if (historyIndex === 0 && currentInput.trim() !== "") {
-        setLastTypedInput(currentInput);
-      }
-      const newIndex = historyIndex + 1;
-      setHistoryIndex(newIndex);
-      updateInput(latestHistory[historyIndex]);
-    }
-  }
-  function onHistoryDown() {
-    const latestHistory = getHistory();
-    if (historyIndex > 1) {
-      const newIndex = historyIndex - 1;
-      setHistoryIndex(newIndex);
-      updateInput(latestHistory[newIndex - 1]);
-    } else if (historyIndex === 1) {
-      setHistoryIndex(0);
-      updateInput(lastTypedInput);
-    }
-  }
-  function resetHistory() {
-    setLastTypedInput("");
-    setHistoryIndex(0);
-  }
-  return {
-    historyIndex,
-    setHistoryIndex,
-    onHistoryUp,
-    onHistoryDown,
-    resetHistory
-  };
-}
-export {
-  useArrowKeyHistory
-};
-//# sourceMappingURL=useArrowKeyHistory.js.map

package/dist/hooks/useArrowKeyHistory.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useArrowKeyHistory.ts"],
-  "sourcesContent": ["import { useState } from 'react'\nimport { getHistory } from '@history'\nimport { sanitizeInput } from '@utils/sanitizeInput'\n\nexport function useArrowKeyHistory(\n  onSetInput: (value: string, mode: 'bash' | 'prompt') => void,\n  currentInput: string,\n) {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastTypedInput, setLastTypedInput] = useState('')\n\n  const updateInput = (input: string | undefined) => {\n    if (input !== undefined) {\n      // Sanitize input to remove dangerous escape sequences\n      // This prevents corrupt history entries (like \"\\x1b\\x1bclear\") from\n      // triggering terminal resets when loaded\n      const sanitized = sanitizeInput(input)\n      const mode = sanitized.startsWith('!') ? 'bash' : 'prompt'\n      const value = mode === 'bash' ? sanitized.slice(1) : sanitized\n      onSetInput(value, mode)\n    }\n  }\n\n  function onHistoryUp() {\n    const latestHistory = getHistory()\n    if (historyIndex < latestHistory.length) {\n      if (historyIndex === 0 && currentInput.trim() !== '') {\n        setLastTypedInput(currentInput)\n      }\n      const newIndex = historyIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[historyIndex])\n    }\n  }\n\n  function onHistoryDown() {\n    const latestHistory = getHistory()\n    if (historyIndex > 1) {\n      const newIndex = historyIndex - 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[newIndex - 1])\n    } else if (historyIndex === 1) {\n      setHistoryIndex(0)\n      updateInput(lastTypedInput)\n    }\n  }\n\n  function resetHistory() {\n    setLastTypedInput('')\n    setHistoryIndex(0)\n  }\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB;AAEvB,SAAS,mBACd,YACA,cACA;AACA,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAClD,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,EAAE;AAEvD,QAAM,cAAc,CAAC,UAA8B;AACjD,QAAI,UAAU,QAAW;AAIvB,YAAM,YAAY,cAAc,KAAK;AACrC,YAAM,OAAO,UAAU,WAAW,GAAG,IAAI,SAAS;AAClD,YAAM,QAAQ,SAAS,SAAS,UAAU,MAAM,CAAC,IAAI;AACrD,iBAAW,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAEA,WAAS,cAAc;AACrB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,cAAc,QAAQ;AACvC,UAAI,iBAAiB,KAAK,aAAa,KAAK,MAAM,IAAI;AACpD,0BAAkB,YAAY;AAAA,MAChC;AACA,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,YAAY,CAAC;AAAA,IACzC;AAAA,EACF;AAEA,WAAS,gBAAgB;AACvB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,GAAG;AACpB,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,WAAW,CAAC,CAAC;AAAA,IACzC,WAAW,iBAAiB,GAAG;AAC7B,sBAAgB,CAAC;AACjB,kBAAY,cAAc;AAAA,IAC5B;AAAA,EACF;AAEA,WAAS,eAAe;AACtB,sBAAkB,EAAE;AACpB,oBAAgB,CAAC;AAAA,EACnB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/hooks/useAskUser.js

@@ -1,24 +0,0 @@
-import { useCallback } from "react";
-function useAskUser(setAskUserQuestionContext) {
-  return useCallback(
-    (questions) => {
-      return new Promise((resolve, reject) => {
-        setAskUserQuestionContext({
-          questions,
-          resolve: (answers) => {
-            resolve(answers);
-          },
-          reject: () => {
-            reject(new Error("User cancelled the question dialog"));
-          }
-        });
-      });
-    },
-    [setAskUserQuestionContext]
-  );
-}
-var useAskUser_default = useAskUser;
-export {
-  useAskUser_default as default
-};
-//# sourceMappingURL=useAskUser.js.map

package/dist/hooks/useAskUser.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAskUser.ts"],
-  "sourcesContent": ["import * as React from 'react'\nimport { useCallback } from 'react'\nimport type {\n  UserQuestion,\n  UserAnswer,\n  AskUserQuestionContext,\n} from '@minto-types/askUserQuestion'\n\ntype SetState<T> = React.Dispatch<React.SetStateAction<T>>\n\n/**\n * Function type for asking the user questions\n */\nexport type AskUserFn = (questions: UserQuestion[]) => Promise<UserAnswer[]>\n\n/**\n * Hook to provide the askUser function for triggering user question dialogs\n *\n * Similar to useCanUseTool, this creates a Promise-based interaction\n * where the dialog is shown and the promise resolves when the user responds.\n *\n * @param setAskUserQuestionContext - State setter to trigger the dialog\n * @returns Function to ask user questions\n */\nfunction useAskUser(\n  setAskUserQuestionContext: SetState<AskUserQuestionContext | null>,\n): AskUserFn {\n  return useCallback<AskUserFn>(\n    (questions: UserQuestion[]) => {\n      return new Promise<UserAnswer[]>((resolve, reject) => {\n        // Set the context to trigger the dialog render\n        setAskUserQuestionContext({\n          questions,\n          resolve: (answers: UserAnswer[]) => {\n            // User provided answers\n            resolve(answers)\n          },\n          reject: () => {\n            // User cancelled\n            reject(new Error('User cancelled the question dialog'))\n          },\n        })\n      })\n    },\n    [setAskUserQuestionContext],\n  )\n}\n\nexport default useAskUser\n"],
-  "mappings": "AACA,SAAS,mBAAmB;AAuB5B,SAAS,WACP,2BACW;AACX,SAAO;AAAA,IACL,CAAC,cAA8B;AAC7B,aAAO,IAAI,QAAsB,CAAC,SAAS,WAAW;AAEpD,kCAA0B;AAAA,UACxB;AAAA,UACA,SAAS,CAAC,YAA0B;AAElC,oBAAQ,OAAO;AAAA,UACjB;AAAA,UACA,QAAQ,MAAM;AAEZ,mBAAO,IAAI,MAAM,oCAAoC,CAAC;AAAA,UACxD;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,IACA,CAAC,yBAAyB;AAAA,EAC5B;AACF;AAEA,IAAO,qBAAQ;",
-  "names": []
-}

package/dist/hooks/useBackgroundShells.js

@@ -1,29 +0,0 @@
-import { useEffect, useState } from "react";
-import {
-  BackgroundShellManager
-} from "../utils/BackgroundShellManager.js";
-function useBackgroundShells() {
-  const [shells, setShells] = useState([]);
-  const [isPanelVisible, setIsPanelVisible] = useState(false);
-  useEffect(() => {
-    const manager = BackgroundShellManager.getInstance();
-    setShells(manager.list());
-    const handleListChange = (updated) => {
-      setShells(updated);
-    };
-    manager.on("listChange", handleListChange);
-    return () => {
-      manager.off("listChange", handleListChange);
-    };
-  }, []);
-  return {
-    shells,
-    isPanelVisible,
-    setIsPanelVisible,
-    runningCount: shells.filter((s) => s.status === "running").length
-  };
-}
-export {
-  useBackgroundShells
-};
-//# sourceMappingURL=useBackgroundShells.js.map

package/dist/hooks/useBackgroundShells.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useBackgroundShells.ts"],
-  "sourcesContent": ["/**\n * Manages background shell state via event-driven subscription.\n * Replaces inline state + effect in REPL.tsx.\n */\nimport { useEffect, useState } from 'react'\nimport {\n  BackgroundShellManager,\n  type BackgroundShell,\n} from '@utils/BackgroundShellManager'\n\nexport function useBackgroundShells() {\n  const [shells, setShells] = useState<BackgroundShell[]>([])\n  const [isPanelVisible, setIsPanelVisible] = useState(false)\n\n  useEffect(() => {\n    const manager = BackgroundShellManager.getInstance()\n    setShells(manager.list())\n\n    const handleListChange = (updated: BackgroundShell[]) => {\n      setShells(updated)\n    }\n    manager.on('listChange', handleListChange)\n\n    return () => {\n      manager.off('listChange', handleListChange)\n    }\n  }, [])\n\n  return {\n    shells,\n    isPanelVisible,\n    setIsPanelVisible,\n    runningCount: shells.filter(s => s.status === 'running').length,\n  }\n}\n"],
-  "mappings": "AAIA,SAAS,WAAW,gBAAgB;AACpC;AAAA,EACE;AAAA,OAEK;AAEA,SAAS,sBAAsB;AACpC,QAAM,CAAC,QAAQ,SAAS,IAAI,SAA4B,CAAC,CAAC;AAC1D,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,KAAK;AAE1D,YAAU,MAAM;AACd,UAAM,UAAU,uBAAuB,YAAY;AACnD,cAAU,QAAQ,KAAK,CAAC;AAExB,UAAM,mBAAmB,CAAC,YAA+B;AACvD,gBAAU,OAAO;AAAA,IACnB;AACA,YAAQ,GAAG,cAAc,gBAAgB;AAEzC,WAAO,MAAM;AACX,cAAQ,IAAI,cAAc,gBAAgB;AAAA,IAC5C;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,OAAO,OAAO,OAAK,EAAE,WAAW,SAAS,EAAE;AAAA,EAC3D;AACF;",
-  "names": []
-}

package/dist/hooks/useCanUseTool.js

@@ -1,89 +0,0 @@
-import { useCallback } from "react";
-import { hasPermissionsToUseTool } from "../permissions.js";
-import { BashTool, inputSchema } from "../tools/BashTool/BashTool.js";
-import { getCommandSubcommandPrefix } from "../utils/commands.js";
-import { REJECT_MESSAGE } from "../utils/messages.js";
-import { getToolDescriptionAsync } from "../Tool.js";
-import { AbortError } from "../utils/errors.js";
-import { logError } from "../utils/log.js";
-function useCanUseTool(setToolUseConfirm) {
-  return useCallback(
-    async (tool, input, toolUseContext, assistantMessage) => {
-      return new Promise((resolve) => {
-        function logCancelledEvent() {
-        }
-        function resolveWithCancelledAndAbortAllToolCalls() {
-          resolve({
-            result: false,
-            message: REJECT_MESSAGE
-          });
-          toolUseContext.abortController.abort();
-        }
-        if (toolUseContext.abortController.signal.aborted) {
-          logCancelledEvent();
-          resolveWithCancelledAndAbortAllToolCalls();
-          return void 0;
-        }
-        return hasPermissionsToUseTool(
-          tool,
-          input,
-          toolUseContext,
-          assistantMessage
-        ).then(async (result) => {
-          if (result.result) {
-            resolve({ result: true });
-            return;
-          }
-          const [description, commandPrefix] = await Promise.all([
-            // Use getToolDescriptionAsync for safe async access
-            getToolDescriptionAsync(tool, input),
-            tool === BashTool ? getCommandSubcommandPrefix(
-              inputSchema.parse(input).command,
-              // already validated upstream, so ok to parse (as opposed to safeParse)
-              toolUseContext.abortController.signal
-            ) : Promise.resolve(null)
-          ]);
-          if (toolUseContext.abortController.signal.aborted) {
-            logCancelledEvent();
-            resolveWithCancelledAndAbortAllToolCalls();
-            return;
-          }
-          setToolUseConfirm({
-            assistantMessage,
-            tool,
-            description,
-            input,
-            commandPrefix,
-            riskScore: null,
-            onAbort() {
-              logCancelledEvent();
-              resolveWithCancelledAndAbortAllToolCalls();
-            },
-            onAllow(type) {
-              if (type === "permanent") {
-              } else {
-              }
-              resolve({ result: true });
-            },
-            onReject() {
-              resolveWithCancelledAndAbortAllToolCalls();
-            }
-          });
-        }).catch((error) => {
-          if (error instanceof AbortError) {
-            logCancelledEvent();
-            resolveWithCancelledAndAbortAllToolCalls();
-          } else {
-            logError(error);
-          }
-        });
-      });
-    },
-    [setToolUseConfirm]
-  );
-}
-var useCanUseTool_default = useCanUseTool;
-export {
-  useCanUseTool_default as default
-};
-//# sourceMappingURL=useCanUseTool.js.map

package/dist/hooks/useCanUseTool.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useCanUseTool.ts"],
-  "sourcesContent": ["import React, { useCallback } from 'react'\nimport { hasPermissionsToUseTool } from '@permissions'\nimport { BashTool, inputSchema } from '@tools/BashTool/BashTool'\nimport { getCommandSubcommandPrefix } from '@utils/commands'\nimport { REJECT_MESSAGE } from '@utils/messages'\nimport type { Tool as ToolType, ToolUseContext } from '@tool'\nimport { getToolDescriptionAsync } from '@tool'\nimport { AssistantMessage } from '@query'\nimport { ToolUseConfirm } from '@components/permissions/PermissionRequest'\nimport { AbortError } from '@utils/errors'\nimport { logError } from '@utils/log'\n\ntype SetState<T> = React.Dispatch<React.SetStateAction<T>>\n\nexport type CanUseToolFn = (\n  tool: ToolType,\n  input: { [key: string]: unknown },\n  toolUseContext: ToolUseContext,\n  assistantMessage: AssistantMessage,\n) => Promise<{ result: true } | { result: false; message: string }>\n\nfunction useCanUseTool(\n  setToolUseConfirm: SetState<ToolUseConfirm | null>,\n): CanUseToolFn {\n  return useCallback<CanUseToolFn>(\n    async (tool, input, toolUseContext, assistantMessage) => {\n      return new Promise(resolve => {\n        function logCancelledEvent() {}\n\n        function resolveWithCancelledAndAbortAllToolCalls() {\n          resolve({\n            result: false,\n            message: REJECT_MESSAGE,\n          })\n          // Trigger a synthetic assistant message in query(), to cancel\n          // any other pending tool uses and stop further requests to the\n          // API and wait for user input.\n          toolUseContext.abortController.abort()\n        }\n\n        if (toolUseContext.abortController.signal.aborted) {\n          logCancelledEvent()\n          resolveWithCancelledAndAbortAllToolCalls()\n          return undefined\n        }\n\n        return hasPermissionsToUseTool(\n          tool,\n          input,\n          toolUseContext,\n          assistantMessage,\n        )\n          .then(async result => {\n            // Has permissions to use tool, granted in config\n            if (result.result) {\n              resolve({ result: true })\n              return\n            }\n\n            const [description, commandPrefix] = await Promise.all([\n              // Use getToolDescriptionAsync for safe async access\n              getToolDescriptionAsync(tool, input),\n              tool === BashTool\n                ? getCommandSubcommandPrefix(\n                    inputSchema.parse(input).command, // already validated upstream, so ok to parse (as opposed to safeParse)\n                    toolUseContext.abortController.signal,\n                  )\n                : Promise.resolve(null),\n            ])\n\n            if (toolUseContext.abortController.signal.aborted) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n              return\n            }\n\n            // Does not have permissions to use tool, ask the user\n            setToolUseConfirm({\n              assistantMessage,\n              tool,\n              description,\n              input,\n              commandPrefix,\n              riskScore: null,\n              onAbort() {\n                logCancelledEvent()\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n              onAllow(type) {\n                if (type === 'permanent') {\n                } else {\n                }\n                resolve({ result: true })\n              },\n              onReject() {\n                resolveWithCancelledAndAbortAllToolCalls()\n              },\n            })\n          })\n          .catch(error => {\n            if (error instanceof AbortError) {\n              logCancelledEvent()\n              resolveWithCancelledAndAbortAllToolCalls()\n            } else {\n              logError(error)\n            }\n          })\n      })\n    },\n    [setToolUseConfirm],\n  )\n}\n\nexport default useCanUseTool\n"],
-  "mappings": "AAAA,SAAgB,mBAAmB;AACnC,SAAS,+BAA+B;AACxC,SAAS,UAAU,mBAAmB;AACtC,SAAS,kCAAkC;AAC3C,SAAS,sBAAsB;AAE/B,SAAS,+BAA+B;AAGxC,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AAWzB,SAAS,cACP,mBACc;AACd,SAAO;AAAA,IACL,OAAO,MAAM,OAAO,gBAAgB,qBAAqB;AACvD,aAAO,IAAI,QAAQ,aAAW;AAC5B,iBAAS,oBAAoB;AAAA,QAAC;AAE9B,iBAAS,2CAA2C;AAClD,kBAAQ;AAAA,YACN,QAAQ;AAAA,YACR,SAAS;AAAA,UACX,CAAC;AAID,yBAAe,gBAAgB,MAAM;AAAA,QACvC;AAEA,YAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,4BAAkB;AAClB,mDAAyC;AACzC,iBAAO;AAAA,QACT;AAEA,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,EACG,KAAK,OAAM,WAAU;AAEpB,cAAI,OAAO,QAAQ;AACjB,oBAAQ,EAAE,QAAQ,KAAK,CAAC;AACxB;AAAA,UACF;AAEA,gBAAM,CAAC,aAAa,aAAa,IAAI,MAAM,QAAQ,IAAI;AAAA;AAAA,YAErD,wBAAwB,MAAM,KAAK;AAAA,YACnC,SAAS,WACL;AAAA,cACE,YAAY,MAAM,KAAK,EAAE;AAAA;AAAA,cACzB,eAAe,gBAAgB;AAAA,YACjC,IACA,QAAQ,QAAQ,IAAI;AAAA,UAC1B,CAAC;AAED,cAAI,eAAe,gBAAgB,OAAO,SAAS;AACjD,8BAAkB;AAClB,qDAAyC;AACzC;AAAA,UACF;AAGA,4BAAkB;AAAA,YAChB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,WAAW;AAAA,YACX,UAAU;AACR,gCAAkB;AAClB,uDAAyC;AAAA,YAC3C;AAAA,YACA,QAAQ,MAAM;AACZ,kBAAI,SAAS,aAAa;AAAA,cAC1B,OAAO;AAAA,cACP;AACA,sBAAQ,EAAE,QAAQ,KAAK,CAAC;AAAA,YAC1B;AAAA,YACA,WAAW;AACT,uDAAyC;AAAA,YAC3C;AAAA,UACF,CAAC;AAAA,QACH,CAAC,EACA,MAAM,WAAS;AACd,cAAI,iBAAiB,YAAY;AAC/B,8BAAkB;AAClB,qDAAyC;AAAA,UAC3C,OAAO;AACL,qBAAS,KAAK;AAAA,UAChB;AAAA,QACF,CAAC;AAAA,MACL,CAAC;AAAA,IACH;AAAA,IACA,CAAC,iBAAiB;AAAA,EACpB;AACF;AAEA,IAAO,wBAAQ;",
-  "names": []
-}

package/dist/hooks/useDeferredLoading.js

@@ -1,64 +0,0 @@
-import { useEffect, useState } from "react";
-import { getClients } from "../services/mcpClient.js";
-import { getTools } from "../tools.js";
-import { getCommands } from "../commands.js";
-import { getLatestVersion, getUpdateCommandSuggestions } from "../utils/autoUpdater.js";
-import { gt } from "semver";
-import { MACRO } from "../constants/macros.js";
-import { useStartupStatus } from "../components/StartupStatus.js";
-function useDeferredLoading(options) {
-  const [commands, setCommands] = useState(options.initialCommands);
-  const [tools, setTools] = useState(options.initialTools);
-  const [mcpClients, setMcpClients] = useState(
-    options.initialMcpClients
-  );
-  const [updateVersion, setUpdateVersion] = useState(
-    options.initialUpdateVersion ?? null
-  );
-  const [updateCommands, setUpdateCommands] = useState(
-    options.initialUpdateCommands ?? null
-  );
-  const { items: startupItems, update: updateStartup } = useStartupStatus([
-    { id: "mcp", label: "MCP servers" },
-    { id: "version", label: "Version check" }
-  ]);
-  useEffect(() => {
-    Promise.all([getClients(), getTools(options.enableArchitect)]).then(([clients, fullTools]) => {
-      setMcpClients(clients);
-      setTools(fullTools);
-      const connected = clients.filter((c) => c.type === "connected").length;
-      updateStartup("mcp", "done", `${connected}/${clients.length} connected`);
-    }).catch(() => {
-      updateStartup("mcp", "error", "connection failed");
-    });
-    getLatestVersion().then((latest) => {
-      if (latest && gt(latest, MACRO.VERSION)) {
-        getUpdateCommandSuggestions().then((cmds) => {
-          setUpdateVersion(latest);
-          setUpdateCommands(cmds);
-          updateStartup("version", "done", `v${latest} available`);
-        });
-      } else {
-        updateStartup("version", "done", "up to date");
-      }
-    }).catch(() => {
-      updateStartup("version", "done");
-    });
-    getCommands().then((fullCommands) => {
-      setCommands(fullCommands);
-    }).catch(() => {
-    });
-  }, []);
-  return {
-    commands,
-    tools,
-    mcpClients,
-    updateVersion,
-    updateCommands,
-    startupItems
-  };
-}
-export {
-  useDeferredLoading
-};
-//# sourceMappingURL=useDeferredLoading.js.map

package/dist/hooks/useDeferredLoading.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useDeferredLoading.ts"],
-  "sourcesContent": ["/**\n * Deferred loading of MCP clients, tools, commands, and version check.\n * Runs in background after mount so the REPL renders immediately.\n */\nimport { useEffect, useState } from 'react'\nimport type { Command } from '@commands'\nimport type { Tool } from '@tool'\nimport type { WrappedClient } from '@services/mcpClient'\nimport { getClients } from '@services/mcpClient'\nimport { getTools } from '@tools'\nimport { getCommands } from '@commands'\nimport { getLatestVersion, getUpdateCommandSuggestions } from '@utils/autoUpdater'\nimport { gt } from 'semver'\nimport { MACRO } from '@constants/macros'\nimport { useStartupStatus } from '@components/StartupStatus'\n\ninterface DeferredLoadingOptions {\n  initialCommands: Command[]\n  initialTools: Tool[]\n  initialMcpClients: WrappedClient[]\n  initialUpdateVersion?: string | null\n  initialUpdateCommands?: string[] | null\n  enableArchitect?: boolean\n}\n\nexport function useDeferredLoading(options: DeferredLoadingOptions) {\n  const [commands, setCommands] = useState<Command[]>(options.initialCommands)\n  const [tools, setTools] = useState<Tool[]>(options.initialTools)\n  const [mcpClients, setMcpClients] = useState<WrappedClient[]>(\n    options.initialMcpClients,\n  )\n  const [updateVersion, setUpdateVersion] = useState<string | null>(\n    options.initialUpdateVersion ?? null,\n  )\n  const [updateCommands, setUpdateCommands] = useState<string[] | null>(\n    options.initialUpdateCommands ?? null,\n  )\n\n  const { items: startupItems, update: updateStartup } = useStartupStatus([\n    { id: 'mcp', label: 'MCP servers' },\n    { id: 'version', label: 'Version check' },\n  ])\n\n  useEffect(() => {\n    // 1. MCP clients + full tools (including MCP tools)\n    Promise.all([getClients(), getTools(options.enableArchitect)])\n      .then(([clients, fullTools]) => {\n        setMcpClients(clients)\n        setTools(fullTools)\n        const connected = clients.filter(c => c.type === 'connected').length\n        updateStartup('mcp', 'done', `${connected}/${clients.length} connected`)\n      })\n      .catch(() => {\n        updateStartup('mcp', 'error', 'connection failed')\n      })\n\n    // 2. Version check\n    getLatestVersion()\n      .then(latest => {\n        if (latest && gt(latest, MACRO.VERSION)) {\n          getUpdateCommandSuggestions().then(cmds => {\n            setUpdateVersion(latest)\n            setUpdateCommands(cmds)\n            updateStartup('version', 'done', `v${latest} available`)\n          })\n        } else {\n          updateStartup('version', 'done', 'up to date')\n        }\n      })\n      .catch(() => {\n        updateStartup('version', 'done') // non-critical, just hide\n      })\n\n    // 3. Full commands (MCP, custom, plugin)\n    getCommands()\n      .then(fullCommands => {\n        setCommands(fullCommands)\n      })\n      .catch(() => {\n        // Non-critical: built-in commands still work\n      })\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  return {\n    commands,\n    tools,\n    mcpClients,\n    updateVersion,\n    updateCommands,\n    startupItems,\n  }\n}\n"],
-  "mappings": "AAIA,SAAS,WAAW,gBAAgB;AAIpC,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B,SAAS,kBAAkB,mCAAmC;AAC9D,SAAS,UAAU;AACnB,SAAS,aAAa;AACtB,SAAS,wBAAwB;AAW1B,SAAS,mBAAmB,SAAiC;AAClE,QAAM,CAAC,UAAU,WAAW,IAAI,SAAoB,QAAQ,eAAe;AAC3E,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAiB,QAAQ,YAAY;AAC/D,QAAM,CAAC,YAAY,aAAa,IAAI;AAAA,IAClC,QAAQ;AAAA,EACV;AACA,QAAM,CAAC,eAAe,gBAAgB,IAAI;AAAA,IACxC,QAAQ,wBAAwB;AAAA,EAClC;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,QAAQ,yBAAyB;AAAA,EACnC;AAEA,QAAM,EAAE,OAAO,cAAc,QAAQ,cAAc,IAAI,iBAAiB;AAAA,IACtE,EAAE,IAAI,OAAO,OAAO,cAAc;AAAA,IAClC,EAAE,IAAI,WAAW,OAAO,gBAAgB;AAAA,EAC1C,CAAC;AAED,YAAU,MAAM;AAEd,YAAQ,IAAI,CAAC,WAAW,GAAG,SAAS,QAAQ,eAAe,CAAC,CAAC,EAC1D,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM;AAC9B,oBAAc,OAAO;AACrB,eAAS,SAAS;AAClB,YAAM,YAAY,QAAQ,OAAO,OAAK,EAAE,SAAS,WAAW,EAAE;AAC9D,oBAAc,OAAO,QAAQ,GAAG,SAAS,IAAI,QAAQ,MAAM,YAAY;AAAA,IACzE,CAAC,EACA,MAAM,MAAM;AACX,oBAAc,OAAO,SAAS,mBAAmB;AAAA,IACnD,CAAC;AAGH,qBAAiB,EACd,KAAK,YAAU;AACd,UAAI,UAAU,GAAG,QAAQ,MAAM,OAAO,GAAG;AACvC,oCAA4B,EAAE,KAAK,UAAQ;AACzC,2BAAiB,MAAM;AACvB,4BAAkB,IAAI;AACtB,wBAAc,WAAW,QAAQ,IAAI,MAAM,YAAY;AAAA,QACzD,CAAC;AAAA,MACH,OAAO;AACL,sBAAc,WAAW,QAAQ,YAAY;AAAA,MAC/C;AAAA,IACF,CAAC,EACA,MAAM,MAAM;AACX,oBAAc,WAAW,MAAM;AAAA,IACjC,CAAC;AAGH,gBAAY,EACT,KAAK,kBAAgB;AACpB,kBAAY,YAAY;AAAA,IAC1B,CAAC,EACA,MAAM,MAAM;AAAA,IAEb,CAAC;AAAA,EAEL,GAAG,CAAC,CAAC;AAEL,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/hooks/useDoublePress.js

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

@@ -1,7 +0,0 @@
-{
-  "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": []
-}