@dexto/tui 1.6.2

package/dist/utils/messageFormatting.js

@@ -0,0 +1,393 @@
+import path from "path";
+import os from "os";
+import { isTextPart, isAssistantMessage, isToolMessage } from "@dexto/core";
+const HIDDEN_TOOL_NAMES = /* @__PURE__ */ new Set(["wait_for"]);
+function normalizeToolName(toolName) {
+  if (toolName.startsWith("mcp--")) {
+    const trimmed = toolName.substring("mcp--".length);
+    const parts = trimmed.split("--");
+    return parts.length >= 2 ? parts.slice(1).join("--") : trimmed;
+  }
+  return toolName;
+}
+function shouldHideTool(toolName) {
+  if (!toolName) {
+    return false;
+  }
+  return HIDDEN_TOOL_NAMES.has(normalizeToolName(toolName));
+}
+const backgroundCompletionRegex = /<background-task-completion>[\s\S]*?<\/background-task-completion>/g;
+const stripBackgroundCompletion = (text) => text.replace(backgroundCompletionRegex, "").replace("<background-task-completion>", "").trim();
+import { generateMessageId } from "./idGenerator.js";
+const SKILL_INVOCATION_REGEX = /<skill-invocation>[\s\S]*?skill:\s*"(?:config:)?([^"]+)"[\s\S]*?<\/skill-invocation>/;
+const AUTOMATION_TRIGGER_REGEX = /<scheduled_automation_trigger>[\s\S]*?<\/scheduled_automation_trigger>/;
+function formatSkillInvocationMessage(content) {
+  const match = content.match(SKILL_INVOCATION_REGEX);
+  if (match) {
+    const skillName = match[1];
+    const contextMatch = content.match(/Task context:\s*(.+?)(?:\n|$)/);
+    if (contextMatch) {
+      return `/${skillName} ${contextMatch[1]}`;
+    }
+    return `/${skillName}`;
+  }
+  return content;
+}
+function isSkillInvocationMessage(content) {
+  return SKILL_INVOCATION_REGEX.test(content);
+}
+function extractAutomationTriggerInfo(content) {
+  const match = content.match(AUTOMATION_TRIGGER_REGEX);
+  if (!match) {
+    return null;
+  }
+  const block = match[0];
+  const taskMatch = block.match(/Task:\s*(.+)/i);
+  const triggeredMatch = block.match(/Triggered at:\s*(.+)/i);
+  const taskName = taskMatch?.[1]?.trim();
+  const triggeredAt = triggeredMatch?.[1]?.trim() ?? null;
+  return {
+    label: taskName ? `\u23F0 Scheduled Task: ${taskName}` : "\u23F0 Scheduled Task",
+    timestamp: triggeredAt,
+    source: "scheduler"
+  };
+}
+function stripAutomationTriggerTags(content) {
+  const stripped = content.replace(
+    /<scheduled_automation_trigger>[\s\S]*?<\/scheduled_automation_trigger>\s*/g,
+    ""
+  );
+  return stripped === content ? content : stripped.trim();
+}
+function makeRelativePath(absolutePath, cwd = process.cwd()) {
+  const normalizedPath = path.normalize(absolutePath);
+  const normalizedCwd = path.normalize(cwd);
+  const homeDir = os.homedir();
+  if (normalizedPath.startsWith(normalizedCwd + path.sep) || normalizedPath === normalizedCwd) {
+    const relative = path.relative(normalizedCwd, normalizedPath);
+    return relative || ".";
+  }
+  if (normalizedPath.startsWith(homeDir + path.sep) || normalizedPath === homeDir) {
+    return "~" + normalizedPath.slice(homeDir.length);
+  }
+  return absolutePath;
+}
+function formatPathForDisplay(absolutePath, maxWidth = 60, cwd = process.cwd()) {
+  const relativePath = makeRelativePath(absolutePath, cwd);
+  if (relativePath.length <= maxWidth) {
+    return relativePath;
+  }
+  return centerTruncatePath(relativePath, maxWidth);
+}
+function centerTruncatePath(filePath, maxWidth) {
+  if (filePath.length <= maxWidth) {
+    return filePath;
+  }
+  const sep = path.sep;
+  const segments = filePath.split(sep).filter(Boolean);
+  if (segments.length <= 3) {
+    return filePath.slice(0, maxWidth - 1) + "\u2026";
+  }
+  const first = filePath.startsWith(sep) ? sep + segments[0] : segments[0];
+  const lastTwo = segments.slice(-2).join(sep);
+  const truncated = `${first}${sep}\u2026${sep}${lastTwo}`;
+  if (truncated.length <= maxWidth) {
+    return truncated;
+  }
+  const filename = segments[segments.length - 1] || "";
+  const withJustFilename = `\u2026${sep}${filename}`;
+  if (withJustFilename.length <= maxWidth) {
+    return withJustFilename;
+  }
+  return filename.slice(0, maxWidth - 1) + "\u2026";
+}
+function toTitleCase(name) {
+  return name.replace(/[_-]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function getToolDisplayName(toolName) {
+  if (toolName.startsWith("mcp--")) {
+    const parts = toolName.split("--");
+    if (parts.length >= 3) {
+      return toTitleCase(parts.slice(2).join("--"));
+    }
+    return toTitleCase(toolName.substring(5));
+  }
+  return toTitleCase(toolName);
+}
+function getToolTypeBadge(toolName) {
+  if (toolName.startsWith("mcp--")) {
+    const parts = toolName.split("--");
+    if (parts.length >= 3 && parts[1]) {
+      return `MCP: ${parts[1]}`;
+    }
+    return "MCP";
+  }
+  return "local";
+}
+function formatToolHeader(options) {
+  const { toolName, args, presentationSnapshot } = options;
+  const snapshotHeader = presentationSnapshot?.header;
+  const displayName = snapshotHeader?.title ?? getToolDisplayName(toolName);
+  const argsFormatted = snapshotHeader?.argsText ?? formatArgsFallback(args);
+  const badge = getToolTypeBadge(toolName);
+  const isMcpTool = badge.startsWith("MCP");
+  const badgeSuffix = isMcpTool ? ` [${badge}]` : "";
+  const header = argsFormatted ? `${displayName}(${argsFormatted})${badgeSuffix}` : `${displayName}()${badgeSuffix}`;
+  return {
+    displayName,
+    argsFormatted,
+    badge,
+    header
+  };
+}
+function formatArgsFallback(args) {
+  const entries = Object.entries(args).filter(([k]) => !["__meta", "description"].includes(k)).slice(0, 4);
+  const str = entries.map(([k, v]) => {
+    const val = typeof v === "string" ? v : JSON.stringify(v);
+    return val.length > 50 ? `${k}=${val.slice(0, 47)}...` : `${k}=${val}`;
+  }).join(", ");
+  return str.length > 150 ? str.slice(0, 147) + "..." : str;
+}
+function createUserMessage(content) {
+  return {
+    id: generateMessageId("user"),
+    role: "user",
+    content,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createQueuedUserMessage(content, queuePosition) {
+  return {
+    id: generateMessageId("user-queued"),
+    role: "user",
+    content,
+    timestamp: /* @__PURE__ */ new Date(),
+    isQueued: true,
+    queuePosition
+  };
+}
+function createSystemMessage(content) {
+  return {
+    id: generateMessageId("system"),
+    role: "system",
+    content,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createErrorMessage(error) {
+  const content = error instanceof Error ? error.message : error;
+  return {
+    id: generateMessageId("error"),
+    role: "system",
+    content: `Error: ${content}`,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createToolMessage(toolName) {
+  return {
+    id: generateMessageId("tool"),
+    role: "tool",
+    content: `\u{1F527} Calling tool: ${toolName}`,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createStreamingMessage() {
+  return {
+    id: generateMessageId("assistant"),
+    role: "assistant",
+    content: "",
+    timestamp: /* @__PURE__ */ new Date(),
+    isStreaming: true
+  };
+}
+function extractTextContent(content) {
+  if (!content) {
+    return "";
+  }
+  return content.filter(isTextPart).map((part) => part.text).join("\n");
+}
+function formatToolResultPreview(result) {
+  try {
+    const parsed = JSON.parse(result);
+    if (parsed.status === "running" && parsed.taskId) {
+      return `Background task started (id: ${parsed.taskId})`;
+    }
+    if (parsed.found !== void 0 && parsed.taskId) {
+      return parsed.found ? `Task ${parsed.taskId} status: ${parsed.status ?? "unknown"}` : `Task ${parsed.taskId} not found`;
+    }
+    if (Array.isArray(parsed.tasks) && typeof parsed.count === "number") {
+      const running = parsed.tasks.filter((task) => task.status === "running").length;
+      return `Tasks: ${parsed.count} total${running > 0 ? ` \u2022 ${running} running` : ""}`;
+    }
+  } catch {
+  }
+  const maxChars = 200;
+  if (result.length <= maxChars) {
+    return result;
+  }
+  return result.slice(0, maxChars) + "\u2026";
+}
+function generateToolResultPreview(content) {
+  const textContent = extractTextContent(content);
+  if (!textContent) return "";
+  try {
+    const parsed = JSON.parse(textContent);
+    if (parsed.status === "running" && parsed.taskId) {
+      return `Background task started (id: ${parsed.taskId})`;
+    }
+    if (Array.isArray(parsed.tasks) && typeof parsed.count === "number") {
+      const running = parsed.tasks.filter((task) => task.status === "running").length;
+      return `Tasks: ${parsed.count} total${running > 0 ? ` \u2022 ${running} running` : ""}`;
+    }
+    if (parsed.found !== void 0 && parsed.taskId) {
+      return parsed.found ? `Task ${parsed.taskId} status: ${parsed.status ?? "unknown"}` : `Task ${parsed.taskId} not found`;
+    }
+  } catch {
+  }
+  const lines = textContent.split("\n");
+  const previewLines = lines.slice(0, 5);
+  let preview = previewLines.join("\n");
+  if (preview.length > 400) {
+    preview = preview.slice(0, 397) + "...";
+  } else if (lines.length > 5) {
+    preview += "\n...";
+  }
+  return preview;
+}
+function convertHistoryToUIMessages(history, sessionId) {
+  const uiMessages = [];
+  const toolCallMap = /* @__PURE__ */ new Map();
+  for (const msg of history) {
+    if (isAssistantMessage(msg) && msg.toolCalls) {
+      for (const toolCall of msg.toolCalls) {
+        toolCallMap.set(toolCall.id, toolCall);
+      }
+    }
+  }
+  history.forEach((msg, index) => {
+    const timestamp = new Date(msg.timestamp ?? Date.now() - (history.length - index) * 1e3);
+    if (isToolMessage(msg)) {
+      if (shouldHideTool(msg.name)) {
+        return;
+      }
+      const toolCall = toolCallMap.get(msg.toolCallId);
+      const displayName = msg.presentationSnapshot?.header?.title ?? getToolDisplayName(msg.name);
+      let toolContent = displayName;
+      const snapshotArgsText = msg.presentationSnapshot?.header?.argsText;
+      if (typeof snapshotArgsText === "string" && snapshotArgsText.length > 0) {
+        toolContent = `${displayName}(${snapshotArgsText})`;
+      }
+      if (!snapshotArgsText && toolCall) {
+        try {
+          const args = JSON.parse(toolCall.function.arguments || "{}");
+          const argsFormatted = formatArgsFallback(args);
+          if (argsFormatted) {
+            toolContent = `${displayName}(${argsFormatted})`;
+          }
+        } catch {
+        }
+      }
+      const badge = getToolTypeBadge(msg.name);
+      if (badge.startsWith("MCP")) {
+        toolContent = `${toolContent} [${badge}]`;
+      }
+      const resultPreview = generateToolResultPreview(msg.content);
+      uiMessages.push({
+        id: `session-${sessionId}-${index}`,
+        role: "tool",
+        content: toolContent,
+        timestamp,
+        toolStatus: "finished",
+        toolResult: resultPreview,
+        isError: msg.success === false,
+        // Store content parts for potential rich rendering
+        toolContent: msg.content,
+        // Restore structured display data for rich rendering (diffs, shell output, etc.)
+        ...msg.displayData !== void 0 && {
+          toolDisplayData: msg.displayData
+        }
+      });
+      return;
+    }
+    if (isAssistantMessage(msg)) {
+      let textContent2 = extractTextContent(msg.content);
+      textContent2 = stripBackgroundCompletion(textContent2);
+      if (!textContent2) return;
+      uiMessages.push({
+        id: `session-${sessionId}-${index}`,
+        role: "assistant",
+        content: textContent2,
+        timestamp
+      });
+      return;
+    }
+    let textContent = extractTextContent(msg.content);
+    textContent = stripBackgroundCompletion(textContent);
+    if (!textContent) return;
+    const automationTrigger = msg.role === "user" ? extractAutomationTriggerInfo(textContent) : null;
+    if (automationTrigger) {
+      uiMessages.push({
+        id: `session-${sessionId}-${index}-trigger`,
+        role: "system",
+        content: automationTrigger.label,
+        timestamp,
+        styledType: "external-trigger",
+        styledData: {
+          label: automationTrigger.label,
+          source: automationTrigger.source,
+          timestamp: automationTrigger.timestamp ?? timestamp
+        }
+      });
+      textContent = stripAutomationTriggerTags(textContent);
+    }
+    if (msg.role === "user") {
+      textContent = formatSkillInvocationMessage(textContent);
+    }
+    uiMessages.push({
+      id: `session-${sessionId}-${index}`,
+      role: msg.role,
+      content: textContent,
+      timestamp
+    });
+  });
+  return uiMessages;
+}
+async function getStartupInfo(agent, sessionId) {
+  const connectedServers = agent.mcpManager.getClients();
+  const failedConnections = agent.mcpManager.getFailedConnections();
+  const tools = await agent.getAllTools();
+  const toolCount = Object.keys(tools).length;
+  const logFile = sessionId ? (await agent.getSession(sessionId))?.logger.getLogFilePath() ?? null : null;
+  return {
+    connectedServers: {
+      count: connectedServers.size,
+      names: Array.from(connectedServers.keys())
+    },
+    failedConnections: Object.keys(failedConnections),
+    toolCount,
+    logFile
+  };
+}
+export {
+  centerTruncatePath,
+  convertHistoryToUIMessages,
+  createErrorMessage,
+  createQueuedUserMessage,
+  createStreamingMessage,
+  createSystemMessage,
+  createToolMessage,
+  createUserMessage,
+  extractAutomationTriggerInfo,
+  formatPathForDisplay,
+  formatSkillInvocationMessage,
+  formatToolHeader,
+  formatToolResultPreview,
+  getStartupInfo,
+  getToolDisplayName,
+  getToolTypeBadge,
+  isSkillInvocationMessage,
+  makeRelativePath,
+  normalizeToolName,
+  shouldHideTool,
+  stripAutomationTriggerTags
+};

package/dist/utils/messageFormatting.test.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_messageFormatting = require("./messageFormatting.js");
+(0, import_vitest.describe)("formatToolHeader fallback args", () => {
+  (0, import_vitest.it)("truncates from the start (not mid-string)", () => {
+    const long = "with base path set to packages/server (or absolute if needed). Summarize key directories and notable config/source files.";
+    const { header } = (0, import_messageFormatting.formatToolHeader)({
+      toolName: "spawn_agent",
+      args: {
+        instructions: long + " ".repeat(10) + "X".repeat(500)
+      }
+    });
+    (0, import_vitest.expect)(header).toContain("instructions=with base path set to packages/server");
+    (0, import_vitest.expect)(header).toContain("...");
+  });
+});

package/dist/utils/messageFormatting.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messageFormatting.test.d.ts.map

package/dist/utils/messageFormatting.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageFormatting.test.d.ts","sourceRoot":"","sources":["../../src/utils/messageFormatting.test.ts"],"names":[],"mappings":""}

package/dist/utils/messageFormatting.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { formatToolHeader } from "./messageFormatting.js";
+describe("formatToolHeader fallback args", () => {
+  it("truncates from the start (not mid-string)", () => {
+    const long = "with base path set to packages/server (or absolute if needed). Summarize key directories and notable config/source files.";
+    const { header } = formatToolHeader({
+      toolName: "spawn_agent",
+      args: {
+        instructions: long + " ".repeat(10) + "X".repeat(500)
+      }
+    });
+    expect(header).toContain("instructions=with base path set to packages/server");
+    expect(header).toContain("...");
+  });
+});

package/dist/utils/mouse.cjs

@@ -0,0 +1,196 @@
+"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 mouse_exports = {};
+__export(mouse_exports, {
+  ESC: () => import_input.ESC,
+  disableMouseEvents: () => disableMouseEvents,
+  enableMouseEvents: () => enableMouseEvents,
+  getMouseEventName: () => getMouseEventName,
+  isIncompleteMouseSequence: () => isIncompleteMouseSequence,
+  parseMouseEvent: () => parseMouseEvent,
+  parseSGRMouseEvent: () => parseSGRMouseEvent,
+  parseX11MouseEvent: () => parseX11MouseEvent
+});
+module.exports = __toCommonJS(mouse_exports);
+var import_input = require("./input.js");
+function enableMouseEvents() {
+  process.stdout.write("\x1B[?1002h\x1B[?1006h");
+}
+function disableMouseEvents() {
+  process.stdout.write("\x1B[?1006l\x1B[?1002l");
+}
+function getMouseEventName(buttonCode, isRelease) {
+  const isMove = (buttonCode & 32) !== 0;
+  if (buttonCode === 66) {
+    return "scroll-left";
+  } else if (buttonCode === 67) {
+    return "scroll-right";
+  }
+  if ((buttonCode & 64) === 64) {
+    if ((buttonCode & 1) === 0) {
+      return "scroll-up";
+    } else {
+      return "scroll-down";
+    }
+  }
+  if (isMove) {
+    return "move";
+  }
+  const button = buttonCode & 3;
+  const type = isRelease ? "release" : "press";
+  switch (button) {
+    case 0:
+      return `left-${type}`;
+    case 1:
+      return `middle-${type}`;
+    case 2:
+      return `right-${type}`;
+    default:
+      return null;
+  }
+}
+function getButtonFromCode(code) {
+  const button = code & 3;
+  switch (button) {
+    case 0:
+      return "left";
+    case 1:
+      return "middle";
+    case 2:
+      return "right";
+    default:
+      return "none";
+  }
+}
+function parseSGRMouseEvent(buffer) {
+  const match = buffer.match(import_input.SGR_MOUSE_REGEX);
+  if (match) {
+    const buttonCode = parseInt(match[1], 10);
+    const col = parseInt(match[2], 10);
+    const row = parseInt(match[3], 10);
+    const action = match[4];
+    const isRelease = action === "m";
+    const shift = (buttonCode & 4) !== 0;
+    const meta = (buttonCode & 8) !== 0;
+    const ctrl = (buttonCode & 16) !== 0;
+    const name = getMouseEventName(buttonCode, isRelease);
+    if (name) {
+      return {
+        event: {
+          name,
+          ctrl,
+          meta,
+          shift,
+          col,
+          row,
+          button: getButtonFromCode(buttonCode)
+        },
+        length: match[0].length
+      };
+    }
+  }
+  return null;
+}
+function parseX11MouseEvent(buffer) {
+  const match = buffer.match(import_input.X11_MOUSE_REGEX);
+  if (!match) return null;
+  const b = match[1].charCodeAt(0) - 32;
+  const col = match[1].charCodeAt(1) - 32;
+  const row = match[1].charCodeAt(2) - 32;
+  const shift = (b & 4) !== 0;
+  const meta = (b & 8) !== 0;
+  const ctrl = (b & 16) !== 0;
+  const isMove = (b & 32) !== 0;
+  const isWheel = (b & 64) !== 0;
+  let name = null;
+  if (isWheel) {
+    const button = b & 3;
+    switch (button) {
+      case 0:
+        name = "scroll-up";
+        break;
+      case 1:
+        name = "scroll-down";
+        break;
+    }
+  } else if (isMove) {
+    name = "move";
+  } else {
+    const button = b & 3;
+    if (button === 3) {
+      name = "left-release";
+    } else {
+      switch (button) {
+        case 0:
+          name = "left-press";
+          break;
+        case 1:
+          name = "middle-press";
+          break;
+        case 2:
+          name = "right-press";
+          break;
+      }
+    }
+  }
+  if (name) {
+    let button = getButtonFromCode(b);
+    if (name === "left-release" && button === "none") {
+      button = "left";
+    }
+    return {
+      event: {
+        name,
+        ctrl,
+        meta,
+        shift,
+        col,
+        row,
+        button
+      },
+      length: match[0].length
+    };
+  }
+  return null;
+}
+function parseMouseEvent(buffer) {
+  return parseSGRMouseEvent(buffer) || parseX11MouseEvent(buffer);
+}
+function isIncompleteMouseSequence(buffer) {
+  if (!(0, import_input.couldBeMouseSequence)(buffer)) return false;
+  if (parseMouseEvent(buffer)) return false;
+  if (buffer.startsWith(import_input.X11_EVENT_PREFIX)) {
+    return buffer.length < import_input.X11_EVENT_PREFIX.length + 3;
+  }
+  if (buffer.startsWith(import_input.SGR_EVENT_PREFIX)) {
+    return !/[mM]/.test(buffer) && buffer.length < 50;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ESC,
+  disableMouseEvents,
+  enableMouseEvents,
+  getMouseEventName,
+  isIncompleteMouseSequence,
+  parseMouseEvent,
+  parseSGRMouseEvent,
+  parseX11MouseEvent
+});

package/dist/utils/mouse.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Mouse Event Utilities
+ * Provides trackpad/mouse scroll support.
+ */
+import { ESC } from './input.js';
+export type MouseEventName = 'scroll-up' | 'scroll-down' | 'scroll-left' | 'scroll-right' | 'left-press' | 'left-release' | 'right-press' | 'right-release' | 'middle-press' | 'middle-release' | 'move';
+export interface MouseEvent {
+    name: MouseEventName;
+    col: number;
+    row: number;
+    shift: boolean;
+    meta: boolean;
+    ctrl: boolean;
+    button: 'left' | 'middle' | 'right' | 'none';
+}
+export type MouseHandler = (event: MouseEvent) => void | boolean;
+/**
+ * Enable mouse events in the terminal.
+ * Uses SGR extended mouse mode for better coordinate handling.
+ */
+export declare function enableMouseEvents(): void;
+/**
+ * Disable mouse events in the terminal.
+ */
+export declare function disableMouseEvents(): void;
+/**
+ * Get mouse event name from button code
+ *
+ * NOTE: X11 mouse protocol limitation - all button releases report the same code (3),
+ * so we cannot distinguish between left-release, middle-release, and right-release.
+ * This function returns 'left-release' for all releases in X11 mode.
+ * Consumers needing accurate release identification should track press state themselves.
+ */
+export declare function getMouseEventName(buttonCode: number, isRelease: boolean): MouseEventName | null;
+/**
+ * Parse SGR format mouse event
+ */
+export declare function parseSGRMouseEvent(buffer: string): {
+    event: MouseEvent;
+    length: number;
+} | null;
+/**
+ * Parse X11 format mouse event
+ */
+export declare function parseX11MouseEvent(buffer: string): {
+    event: MouseEvent;
+    length: number;
+} | null;
+/**
+ * Parse mouse event from buffer (tries both SGR and X11 formats)
+ */
+export declare function parseMouseEvent(buffer: string): {
+    event: MouseEvent;
+    length: number;
+} | null;
+/**
+ * Check if buffer could be an incomplete mouse sequence
+ */
+export declare function isIncompleteMouseSequence(buffer: string): boolean;
+export { ESC };
+//# sourceMappingURL=mouse.d.ts.map

package/dist/utils/mouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.d.ts","sourceRoot":"","sources":["../../src/utils/mouse.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACH,GAAG,EAMN,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GACpB,WAAW,GACX,aAAa,GACb,aAAa,GACb,cAAc,GACd,YAAY,GACZ,cAAc,GACd,aAAa,GACb,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,MAAM,CAAC;AAEb,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;CAChD;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAmC/F;AAmBD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiC/F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoE/F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAE5F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAmBjE;AAGD,OAAO,EAAE,GAAG,EAAE,CAAC"}