@dexto/tui 1.6.2

package/dist/utils/messageFormatting.cjs

@@ -0,0 +1,447 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var messageFormatting_exports = {};
+__export(messageFormatting_exports, {
+  centerTruncatePath: () => centerTruncatePath,
+  convertHistoryToUIMessages: () => convertHistoryToUIMessages,
+  createErrorMessage: () => createErrorMessage,
+  createQueuedUserMessage: () => createQueuedUserMessage,
+  createStreamingMessage: () => createStreamingMessage,
+  createSystemMessage: () => createSystemMessage,
+  createToolMessage: () => createToolMessage,
+  createUserMessage: () => createUserMessage,
+  extractAutomationTriggerInfo: () => extractAutomationTriggerInfo,
+  formatPathForDisplay: () => formatPathForDisplay,
+  formatSkillInvocationMessage: () => formatSkillInvocationMessage,
+  formatToolHeader: () => formatToolHeader,
+  formatToolResultPreview: () => formatToolResultPreview,
+  getStartupInfo: () => getStartupInfo,
+  getToolDisplayName: () => getToolDisplayName,
+  getToolTypeBadge: () => getToolTypeBadge,
+  isSkillInvocationMessage: () => isSkillInvocationMessage,
+  makeRelativePath: () => makeRelativePath,
+  normalizeToolName: () => normalizeToolName,
+  shouldHideTool: () => shouldHideTool,
+  stripAutomationTriggerTags: () => stripAutomationTriggerTags
+});
+module.exports = __toCommonJS(messageFormatting_exports);
+var import_path = __toESM(require("path"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_core = require("@dexto/core");
+var import_idGenerator = require("./idGenerator.js");
+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();
+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 = import_path.default.normalize(absolutePath);
+  const normalizedCwd = import_path.default.normalize(cwd);
+  const homeDir = import_os.default.homedir();
+  if (normalizedPath.startsWith(normalizedCwd + import_path.default.sep) || normalizedPath === normalizedCwd) {
+    const relative = import_path.default.relative(normalizedCwd, normalizedPath);
+    return relative || ".";
+  }
+  if (normalizedPath.startsWith(homeDir + import_path.default.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 = import_path.default.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: (0, import_idGenerator.generateMessageId)("user"),
+    role: "user",
+    content,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createQueuedUserMessage(content, queuePosition) {
+  return {
+    id: (0, import_idGenerator.generateMessageId)("user-queued"),
+    role: "user",
+    content,
+    timestamp: /* @__PURE__ */ new Date(),
+    isQueued: true,
+    queuePosition
+  };
+}
+function createSystemMessage(content) {
+  return {
+    id: (0, import_idGenerator.generateMessageId)("system"),
+    role: "system",
+    content,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createErrorMessage(error) {
+  const content = error instanceof Error ? error.message : error;
+  return {
+    id: (0, import_idGenerator.generateMessageId)("error"),
+    role: "system",
+    content: `Error: ${content}`,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createToolMessage(toolName) {
+  return {
+    id: (0, import_idGenerator.generateMessageId)("tool"),
+    role: "tool",
+    content: `\u{1F527} Calling tool: ${toolName}`,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function createStreamingMessage() {
+  return {
+    id: (0, import_idGenerator.generateMessageId)("assistant"),
+    role: "assistant",
+    content: "",
+    timestamp: /* @__PURE__ */ new Date(),
+    isStreaming: true
+  };
+}
+function extractTextContent(content) {
+  if (!content) {
+    return "";
+  }
+  return content.filter(import_core.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 ((0, import_core.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 ((0, import_core.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 ((0, import_core.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Message formatting utilities
+ * Helpers for creating and formatting messages
+ */
+import type { DextoAgent, InternalMessage, ToolPresentationSnapshotV1 } from '@dexto/core';
+import type { Message, ExternalTriggerStyledData } from '../state/types.js';
+export declare function normalizeToolName(toolName: string): string;
+export declare function shouldHideTool(toolName: string | undefined): boolean;
+/**
+ * Formats a skill invocation message for clean display.
+ * Converts verbose <skill-invocation> blocks to clean /skill-name format.
+ * Works for both fork skills (just the tag) and inline skills (tag + content).
+ *
+ * @param content - The message content to check and format
+ * @returns Formatted content if it's a skill invocation, original content otherwise
+ */
+export declare function formatSkillInvocationMessage(content: string): string;
+/**
+ * Checks if a message content is a skill invocation.
+ */
+export declare function isSkillInvocationMessage(content: string): boolean;
+export declare function extractAutomationTriggerInfo(content: string): {
+    label: string;
+    timestamp: string | null;
+    source: ExternalTriggerStyledData['source'];
+} | null;
+export declare function stripAutomationTriggerTags(content: string): string;
+/**
+ * Convert absolute path to display-friendly relative path.
+ * Strategy:
+ * 1. If path is under cwd → relative from cwd (e.g., "src/file.ts")
+ * 2. If path is under home → use tilde (e.g., "~/Projects/file.ts")
+ * 3. Otherwise → return absolute path
+ */
+export declare function makeRelativePath(absolutePath: string, cwd?: string): string;
+/**
+ * Format a path for display: relative + center-truncate if needed.
+ * @param absolutePath - The absolute file path
+ * @param maxWidth - Maximum display width (default 60)
+ * @param cwd - Current working directory for relative path calculation
+ */
+export declare function formatPathForDisplay(absolutePath: string, maxWidth?: number, cwd?: string): string;
+/**
+ * Center-truncate a file path to keep the filename visible.
+ * e.g., "/Users/karaj/Projects/very/long/path/to/file.ts" → "/Users/karaj/…/to/file.ts"
+ *
+ * Strategy:
+ * 1. If path fits within maxWidth, return as-is
+ * 2. Keep first segment (root/home) and last 2 segments (parent + filename)
+ * 3. Add "…" in the middle
+ */
+export declare function centerTruncatePath(filePath: string, maxWidth: number): string;
+export declare function getToolDisplayName(toolName: string): string;
+/**
+ * Gets the tool type badge for display.
+ * Returns: 'local' or MCP server name.
+ */
+export declare function getToolTypeBadge(toolName: string): string;
+/**
+ * Result of formatting a tool header for display
+ */
+export interface FormattedToolHeader {
+    /** User-friendly display name (e.g., "Explore", "Read") */
+    displayName: string;
+    /** Formatted arguments string (e.g., "file.ts" or "pattern, path: /src") */
+    argsFormatted: string;
+    /** Tool type badge (e.g., "internal", "custom", "MCP: github") */
+    badge: string;
+    /** Full formatted header string (e.g., "Explore(task) [custom]") */
+    header: string;
+}
+/**
+ * Formats a tool call header for consistent display across CLI.
+ * Used by both tool messages and approval prompts.
+ *
+ * Handles special cases like spawn_agent (uses agentId as display name).
+ *
+ * @param toolName - Tool name (local tool id or `mcp--...`)
+ * @param args - Tool arguments object
+ * @returns Formatted header components and full string
+ */
+export declare function formatToolHeader(options: {
+    toolName: string;
+    args: Record<string, unknown>;
+    presentationSnapshot?: ToolPresentationSnapshotV1;
+}): FormattedToolHeader;
+/**
+ * Creates a user message
+ */
+export declare function createUserMessage(content: string): Message;
+/**
+ * Creates a queued user message (shown when message is queued while processing)
+ */
+export declare function createQueuedUserMessage(content: string, queuePosition: number): Message;
+/**
+ * Creates a system message
+ */
+export declare function createSystemMessage(content: string): Message;
+/**
+ * Creates an error message
+ */
+export declare function createErrorMessage(error: Error | string): Message;
+/**
+ * Creates a tool call message
+ */
+export declare function createToolMessage(toolName: string): Message;
+/**
+ * Formats a streaming placeholder message
+ */
+export declare function createStreamingMessage(): Message;
+/**
+ * Generates a preview of tool result content for display
+ */
+export declare function formatToolResultPreview(result: string): string;
+/**
+ * Converts session history messages to UI messages
+ */
+export declare function convertHistoryToUIMessages(history: InternalMessage[], sessionId: string): Message[];
+/**
+ * Collects startup information for display in header
+ */
+export declare function getStartupInfo(agent: DextoAgent, sessionId: string | null): Promise<{
+    connectedServers: {
+        count: number;
+        names: string[];
+    };
+    failedConnections: string[];
+    toolCount: number;
+    logFile: string | null;
+}>;
+//# sourceMappingURL=messageFormatting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageFormatting.d.ts","sourceRoot":"","sources":["../../src/utils/messageFormatting.ts"],"names":[],"mappings":"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"}