@dexto/tui 1.6.2

package/dist/hooks/useAgentEvents.js

@@ -0,0 +1,360 @@
+import { useEffect, useRef } from "react";
+import { setMaxListeners } from "events";
+import {
+  getModelDisplayName
+} from "@dexto/core";
+import { generateMessageId } from "../utils/idGenerator.js";
+function extractTextContent(content) {
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+function useAgentEvents({
+  agent,
+  setMessages,
+  setPendingMessages,
+  setUi,
+  setSession,
+  setInput,
+  setApproval,
+  setApprovalQueue,
+  setQueuedMessages,
+  currentSessionId,
+  buffer
+}) {
+  const externalTriggerRef = useRef({ active: false, sessionId: null, messageId: null });
+  useEffect(() => {
+    const controller = new AbortController();
+    const { signal } = controller;
+    setMaxListeners(25, signal);
+    agent.on(
+      "llm:switched",
+      (payload) => {
+        if (payload.newConfig?.model) {
+          setSession((prev) => ({
+            ...prev,
+            modelName: getModelDisplayName(
+              payload.newConfig.model,
+              payload.newConfig.provider
+            )
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "service:event",
+      (payload) => {
+        if (payload.service !== "orchestration" || payload.event !== "tasks-updated") {
+          return;
+        }
+        if (payload.sessionId && payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const data = payload.data;
+        if (data.tasks) {
+          setUi((prev) => {
+            const runningCount = typeof data.runningCount === "number" ? data.runningCount : prev.backgroundTasksRunning;
+            return {
+              ...prev,
+              backgroundTasks: data.tasks ?? prev.backgroundTasks,
+              backgroundTasksRunning: runningCount
+            };
+          });
+        } else if (typeof data.runningCount === "number") {
+          setUi((prev) => ({
+            ...prev,
+            backgroundTasksRunning: data.runningCount ?? prev.backgroundTasksRunning
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "tool:background",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = `tool-${payload.toolCallId}`;
+        setMessages(
+          (prev) => prev.map((message) => {
+            if (message.id !== messageId) {
+              return message;
+            }
+            return {
+              ...message,
+              toolStatus: "running",
+              toolResult: "Background task started",
+              isBackground: true
+            };
+          })
+        );
+      },
+      { signal }
+    );
+    agent.on(
+      "tool:background-completed",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = `tool-${payload.toolCallId}`;
+        setMessages(
+          (prev) => prev.map((message) => {
+            if (message.id !== messageId) {
+              return message;
+            }
+            return {
+              ...message,
+              toolStatus: "finished",
+              toolResult: "Background task completed",
+              isBackground: true
+            };
+          })
+        );
+      },
+      { signal }
+    );
+    agent.on(
+      "session:reset",
+      () => {
+        setMessages([]);
+        setApproval(null);
+        setApprovalQueue([]);
+        setQueuedMessages([]);
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+      },
+      { signal }
+    );
+    agent.on(
+      "session:created",
+      (payload) => {
+        if (payload.switchTo) {
+          if (process.stdout.isTTY) {
+            process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+          }
+          setMessages([]);
+          setPendingMessages([]);
+          setApproval(null);
+          setApprovalQueue([]);
+          setQueuedMessages([]);
+          buffer.setText("");
+          setInput((prev) => ({
+            ...prev,
+            value: "",
+            history: [],
+            historyIndex: -1,
+            draftBeforeHistory: "",
+            images: [],
+            pastedBlocks: [],
+            pasteCounter: 0
+          }));
+          if (payload.sessionId === null) {
+            setSession((prev) => ({ ...prev, id: null, hasActiveSession: false }));
+          } else {
+            setSession((prev) => ({
+              ...prev,
+              id: payload.sessionId,
+              hasActiveSession: true
+            }));
+          }
+          setUi((prev) => ({
+            ...prev,
+            activeOverlay: "none",
+            historySearch: {
+              isActive: false,
+              query: "",
+              matchIndex: 0,
+              originalInput: "",
+              lastMatch: ""
+            }
+          }));
+        }
+      },
+      { signal }
+    );
+    agent.on(
+      "context:cleared",
+      () => {
+        setApproval(null);
+        setApprovalQueue([]);
+        setQueuedMessages([]);
+        setUi((prev) => ({ ...prev, activeOverlay: "none" }));
+      },
+      { signal }
+    );
+    agent.on(
+      "context:compacting",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) return;
+        setUi((prev) => ({ ...prev, isCompacting: true }));
+      },
+      { signal }
+    );
+    agent.on(
+      "context:compacted",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) return;
+        setUi((prev) => ({ ...prev, isCompacting: false }));
+        const reductionPercent = payload.originalTokens > 0 ? Math.round(
+          (payload.originalTokens - payload.compactedTokens) / payload.originalTokens * 100
+        ) : 0;
+        const compactionContent = `\u{1F4E6} Context compacted
+   ${payload.originalMessages} messages \u2192 ${payload.compactedMessages} messages
+   ~${payload.originalTokens.toLocaleString()} \u2192 ~${payload.compactedTokens.toLocaleString()} tokens (${reductionPercent}% reduction)`;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: generateMessageId("system"),
+            role: "system",
+            content: compactionContent,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+      },
+      { signal }
+    );
+    agent.on(
+      "message:queued",
+      (payload) => {
+        if (!payload.sessionId) return;
+        agent.getQueuedMessages(payload.sessionId).then((messages) => {
+          setQueuedMessages(messages);
+        }).catch(() => {
+        });
+      },
+      { signal }
+    );
+    agent.on(
+      "message:removed",
+      (payload) => {
+        setQueuedMessages((prev) => prev.filter((m) => m.id !== payload.id));
+      },
+      { signal }
+    );
+    agent.on(
+      "run:invoke",
+      (payload) => {
+        if (payload.sessionId !== currentSessionId) {
+          return;
+        }
+        const messageId = generateMessageId("assistant");
+        externalTriggerRef.current = {
+          active: true,
+          sessionId: payload.sessionId,
+          messageId
+        };
+        const promptText = extractTextContent(payload.content);
+        const sourceLabel = payload.source === "scheduler" ? "\u23F0 Scheduled Task" : payload.source === "a2a" ? "\u{1F916} A2A Request" : payload.source === "api" ? "\u{1F50C} API Request" : "\u{1F4E5} External Request";
+        const triggerTimestamp = /* @__PURE__ */ new Date();
+        const scheduleName = typeof payload.metadata?.scheduleName === "string" ? payload.metadata.scheduleName : null;
+        const triggerLabel = scheduleName ? `${sourceLabel}: ${scheduleName}` : sourceLabel;
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: generateMessageId("system"),
+            role: "system",
+            content: triggerLabel,
+            timestamp: triggerTimestamp,
+            styledType: "external-trigger",
+            styledData: {
+              label: triggerLabel,
+              source: payload.source ?? "external",
+              timestamp: triggerTimestamp
+            }
+          },
+          {
+            id: generateMessageId("user"),
+            role: "user",
+            content: promptText,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        ]);
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: true,
+          isThinking: true
+        }));
+        setPendingMessages([
+          {
+            id: messageId,
+            role: "assistant",
+            content: "",
+            timestamp: /* @__PURE__ */ new Date(),
+            isStreaming: true
+          }
+        ]);
+      },
+      { signal }
+    );
+    agent.on(
+      "llm:chunk",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        if (payload.chunkType !== "text") {
+          return;
+        }
+        setPendingMessages(
+          (prev) => prev.map(
+            (msg) => msg.id === externalTriggerRef.current.messageId ? { ...msg, content: msg.content + payload.content } : msg
+          )
+        );
+        setUi((prev) => prev.isThinking ? { ...prev, isThinking: false } : prev);
+      },
+      { signal }
+    );
+    agent.on(
+      "llm:thinking",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        setUi((prev) => ({ ...prev, isThinking: true }));
+      },
+      { signal }
+    );
+    agent.on(
+      "run:complete",
+      (payload) => {
+        if (!externalTriggerRef.current.active || payload.sessionId !== externalTriggerRef.current.sessionId) {
+          return;
+        }
+        setPendingMessages((prev) => {
+          const pendingMsg = prev.find(
+            (m) => m.id === externalTriggerRef.current.messageId
+          );
+          if (pendingMsg) {
+            setMessages((msgs) => [...msgs, { ...pendingMsg, isStreaming: false }]);
+          }
+          return prev.filter((m) => m.id !== externalTriggerRef.current.messageId);
+        });
+        setUi((prev) => ({
+          ...prev,
+          isProcessing: false,
+          isThinking: false
+        }));
+        externalTriggerRef.current = { active: false, sessionId: null, messageId: null };
+      },
+      { signal }
+    );
+    return () => {
+      controller.abort();
+    };
+  }, [
+    agent,
+    setMessages,
+    setPendingMessages,
+    setUi,
+    setSession,
+    setInput,
+    setApproval,
+    setApprovalQueue,
+    setQueuedMessages,
+    currentSessionId,
+    buffer
+  ]);
+}
+export {
+  useAgentEvents
+};

package/dist/hooks/useAnimationTick.cjs

@@ -0,0 +1,71 @@
+"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 useAnimationTick_exports = {};
+__export(useAnimationTick_exports, {
+  useAnimationTick: () => useAnimationTick
+});
+module.exports = __toCommonJS(useAnimationTick_exports);
+var import_react = require("react");
+const DEFAULT_INTERVAL_MS = 80;
+let tick = 0;
+let interval = null;
+let intervalMs = DEFAULT_INTERVAL_MS;
+const listeners = /* @__PURE__ */ new Set();
+function start() {
+  if (interval) return;
+  interval = setInterval(() => {
+    tick = (tick + 1) % 1e6;
+    for (const listener of listeners) listener();
+  }, intervalMs);
+}
+function stop() {
+  if (!interval) return;
+  clearInterval(interval);
+  interval = null;
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  start();
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      stop();
+    }
+  };
+}
+function getSnapshot() {
+  return tick;
+}
+function useAnimationTick(options) {
+  const enabled = options?.enabled ?? true;
+  const nextIntervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;
+  if (nextIntervalMs < intervalMs) {
+    intervalMs = nextIntervalMs;
+    if (interval) {
+      stop();
+      start();
+    }
+  }
+  return (0, import_react.useSyncExternalStore)(enabled ? subscribe : () => () => {
+  }, getSnapshot, getSnapshot);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAnimationTick
+});

package/dist/hooks/useAnimationTick.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared animation tick for Ink UI.
+ *
+ * Motivation: avoid multiple independent timers (spinners, status indicators) that cause
+ * out-of-phase redraws and visible flicker.
+ */
+export declare function useAnimationTick(options?: {
+    enabled?: boolean;
+    intervalMs?: number;
+}): number;
+//# sourceMappingURL=useAnimationTick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationTick.d.ts","sourceRoot":"","sources":["../../src/hooks/useAnimationTick.ts"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAe7F"}

package/dist/hooks/useAnimationTick.js

@@ -0,0 +1,47 @@
+import { useSyncExternalStore } from "react";
+const DEFAULT_INTERVAL_MS = 80;
+let tick = 0;
+let interval = null;
+let intervalMs = DEFAULT_INTERVAL_MS;
+const listeners = /* @__PURE__ */ new Set();
+function start() {
+  if (interval) return;
+  interval = setInterval(() => {
+    tick = (tick + 1) % 1e6;
+    for (const listener of listeners) listener();
+  }, intervalMs);
+}
+function stop() {
+  if (!interval) return;
+  clearInterval(interval);
+  interval = null;
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  start();
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      stop();
+    }
+  };
+}
+function getSnapshot() {
+  return tick;
+}
+function useAnimationTick(options) {
+  const enabled = options?.enabled ?? true;
+  const nextIntervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;
+  if (nextIntervalMs < intervalMs) {
+    intervalMs = nextIntervalMs;
+    if (interval) {
+      stop();
+      start();
+    }
+  }
+  return useSyncExternalStore(enabled ? subscribe : () => () => {
+  }, getSnapshot, getSnapshot);
+}
+export {
+  useAnimationTick
+};

package/dist/hooks/useBatchedScroll.cjs

@@ -0,0 +1,44 @@
+"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 useBatchedScroll_exports = {};
+__export(useBatchedScroll_exports, {
+  useBatchedScroll: () => useBatchedScroll
+});
+module.exports = __toCommonJS(useBatchedScroll_exports);
+var import_react = require("react");
+function useBatchedScroll(currentScrollTop) {
+  const pendingScrollTopRef = (0, import_react.useRef)(null);
+  const currentScrollTopRef = (0, import_react.useRef)(currentScrollTop);
+  (0, import_react.useEffect)(() => {
+    currentScrollTopRef.current = currentScrollTop;
+    pendingScrollTopRef.current = null;
+  });
+  const getScrollTop = (0, import_react.useCallback)(
+    () => pendingScrollTopRef.current ?? currentScrollTopRef.current,
+    []
+  );
+  const setPendingScrollTop = (0, import_react.useCallback)((newScrollTop) => {
+    pendingScrollTopRef.current = newScrollTop;
+  }, []);
+  return { getScrollTop, setPendingScrollTop };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useBatchedScroll
+});

package/dist/hooks/useBatchedScroll.d.ts

@@ -0,0 +1,14 @@
+/**
+ * useBatchedScroll Hook
+ * Prevents scroll jitter by batching multiple scroll updates in the same frame.
+ */
+/**
+ * A hook to manage batched scroll state updates.
+ * It allows multiple scroll operations within the same tick to accumulate
+ * by keeping track of a 'pending' state that resets after render.
+ */
+export declare function useBatchedScroll(currentScrollTop: number): {
+    getScrollTop: () => number;
+    setPendingScrollTop: (newScrollTop: number) => void;
+};
+//# sourceMappingURL=useBatchedScroll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBatchedScroll.d.ts","sourceRoot":"","sources":["../../src/hooks/useBatchedScroll.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM;;wCAgBE,MAAM;EAKhE"}

package/dist/hooks/useBatchedScroll.js

@@ -0,0 +1,20 @@
+import { useRef, useEffect, useCallback } from "react";
+function useBatchedScroll(currentScrollTop) {
+  const pendingScrollTopRef = useRef(null);
+  const currentScrollTopRef = useRef(currentScrollTop);
+  useEffect(() => {
+    currentScrollTopRef.current = currentScrollTop;
+    pendingScrollTopRef.current = null;
+  });
+  const getScrollTop = useCallback(
+    () => pendingScrollTopRef.current ?? currentScrollTopRef.current,
+    []
+  );
+  const setPendingScrollTop = useCallback((newScrollTop) => {
+    pendingScrollTopRef.current = newScrollTop;
+  }, []);
+  return { getScrollTop, setPendingScrollTop };
+}
+export {
+  useBatchedScroll
+};