ocuclaw 0.1.0

package/dist/domain/conversation-state.js

@@ -0,0 +1,516 @@
+import { filterDisplayEmojiText } from "./message-emoji-filter.js";
+import { marked } from "marked";
+
+// --- Constants ---
+
+const DEFAULT_AGENT_NAME = "Agent";
+const REPLY_DIRECTIVE_TAG_RE = /\[\[\s*(?:reply_to_current|reply_to\s*:\s*[^\]\n]+)\s*\]\]/gi;
+const REPLY_DIRECTIVE_SENTINEL = "\u0000";
+const STANDALONE_REPLY_DIRECTIVE_LINE_RE = /^[ \t]*\u0000[ \t]*(?:\r?\n)?/gm;
+const INLINE_REPLY_DIRECTIVE_RE = /[ \t]*\u0000[ \t]*/g;
+const SYNTHETIC_SESSION_START_PREFIX_RE = /^a\s+new\s+session\s+was\s+started\b/;
+const SYNTHETIC_SESSION_START_SHAPE_RE =
+  /\b(?:new|fresh)\s+session\b|\bsession\b.*\b(?:started|reset|created)\b/;
+const SYNTHETIC_SESSION_INSTRUCTION_PATTERNS = [
+  /\bgreet\b/,
+  /\bconfigured\b.*\b(?:persona|style|voice)\b/,
+  /\bbe yourself\b|\bmannerisms\b|\bmood\b/,
+  /\b(?:1-3|1 to 3|one to three)\s+sentences?\b/,
+  /\bask\b.*\bwhat\b.*\bwant\b.*\bdo\b/,
+  /\bdefault(?:_| )model\b/,
+  /\bdo not mention\b/,
+  /\binternal\b.*\b(?:steps|files|tools|reasoning)\b/,
+];
+// --- State ---
+
+let messages = [];
+let agentName = DEFAULT_AGENT_NAME;
+let displayEntries = [];
+let cachedTranscript = "";
+let transcriptDirty = false;
+
+/**
+ * Build a display entry for a single message, or null if filtered out.
+ *
+ * @param {{role: string, content: string|Array, name?: string}} msg
+ * @param {{isFirstVisibleEntry?: boolean}} [options]
+ * @returns {{role: "user"|"assistant", text: string, name: string|null}|null}
+ */
+function buildDisplayEntry(msg, options = {}) {
+  if (!msg || (msg.role !== "user" && msg.role !== "assistant")) return null;
+
+  const text = extractText(msg.content);
+  if (!text) return null;
+
+  const { text: plainText } = markdownToPlainText(text, {
+    stripReplyTags: msg.role === "assistant",
+  });
+  if (!plainText) return null;
+  if (
+    msg.role === "user" &&
+    options.isFirstVisibleEntry === true &&
+    isLikelySyntheticSessionStarterPrompt(plainText)
+  ) {
+    return null;
+  }
+
+  return {
+    role: msg.role,
+    text: plainText,
+    name: typeof msg.name === "string" && msg.name ? msg.name : null,
+  };
+}
+
+function normalizeSessionStarterCandidate(text) {
+  if (typeof text !== "string") return "";
+  return text
+    .replace(/^\s*>+\s*/, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function countSyntheticSessionInstructionSignals(normalizedText) {
+  let count = 0;
+  for (const pattern of SYNTHETIC_SESSION_INSTRUCTION_PATTERNS) {
+    if (pattern.test(normalizedText)) count += 1;
+  }
+  return count;
+}
+
+/**
+ * Detect OpenClaw's synthetic bare /new or /reset starter prompt.
+ * This is heuristic-based (signals + shape), not exact whole-string matching.
+ */
+function isLikelySyntheticSessionStarterPrompt(text) {
+  const normalized = normalizeSessionStarterCandidate(text);
+  if (!normalized) return false;
+  if (!normalized.includes("/new") || !normalized.includes("/reset")) return false;
+
+  if (SYNTHETIC_SESSION_START_PREFIX_RE.test(normalized)) {
+    return true;
+  }
+  if (normalized.length < 80) return false;
+  if (!SYNTHETIC_SESSION_START_SHAPE_RE.test(normalized)) return false;
+  return countSyntheticSessionInstructionSignals(normalized) >= 2;
+}
+
+/**
+ * Format a display entry with role prefix.
+ *
+ * @param {{role: "user"|"assistant", text: string, name: string|null}} entry
+ * @returns {string}
+ */
+function formatEntry(entry) {
+  if (entry.role === "user") return `• ${entry.text}`;
+  const name = entry.name || agentName;
+  return `${name}: ${entry.text}`;
+}
+
+/**
+ * Rebuild derived display cache from raw messages.
+ */
+function rebuildDisplayCache() {
+  displayEntries = [];
+  for (const msg of messages) {
+    const entry = buildDisplayEntry(msg, {
+      isFirstVisibleEntry: displayEntries.length === 0,
+    });
+    if (entry) displayEntries.push(entry);
+  }
+  transcriptDirty = true;
+}
+
+/**
+ * Return the current transcript string, rebuilding lazily if needed.
+ *
+ * @returns {string}
+ */
+function getTranscript() {
+  if (!transcriptDirty) return cachedTranscript;
+  cachedTranscript = displayEntries.map((entry) => formatEntry(entry)).join("\n\n");
+  transcriptDirty = false;
+  return cachedTranscript;
+}
+
+// --- Markdown Pipeline ---
+
+/**
+ * Remove OpenClaw inline reply directives from assistant text before display.
+ * These control transport threading and should never be user-visible.
+ */
+function stripReplyDirectives(text) {
+  if (!text) return "";
+
+  const withSentinel = text.replace(REPLY_DIRECTIVE_TAG_RE, REPLY_DIRECTIVE_SENTINEL);
+  if (withSentinel === text) return text;
+
+  return withSentinel
+    .replace(STANDALONE_REPLY_DIRECTIVE_LINE_RE, "")
+    .replace(INLINE_REPLY_DIRECTIVE_RE, " ")
+    .replace(/[ \t]+\r?\n/g, "\n")
+    .replace(/\r?\n{3,}/g, "\n\n")
+    .replace(/^(?:\r?\n)+/, "")
+    .replace(/^[ \t]+/, "")
+    .replace(/[ \t]+$/gm, "")
+    .replace(/\u0000/g, "")
+    .trimEnd();
+}
+
+/**
+ * Extract plain text from an array of marked inline tokens.
+ */
+function renderInlineTokens(tokens) {
+  let out = "";
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text":
+      case "codespan":
+        out += token.text;
+        break;
+      case "strong":
+      case "em":
+      case "del":
+      case "link":
+        out += token.tokens ? renderInlineTokens(token.tokens) : (token.text || "");
+        break;
+      case "br":
+        out += "\n";
+        break;
+      case "escape":
+        out += token.text || "";
+        break;
+      case "html":
+        // Strip inline HTML tags
+        break;
+      case "image":
+        out += token.text || token.title || "";
+        break;
+      default:
+        // Unknown inline token — include raw text if available
+        if (token.text) out += token.text;
+        break;
+    }
+  }
+  return out;
+}
+
+/**
+ * Extract plain text from an array of marked block tokens.
+ * Returns an array of text blocks (each block is a paragraph-level chunk).
+ */
+function renderBlockTokens(tokens) {
+  const blocks = [];
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case "paragraph":
+        blocks.push(token.tokens ? renderInlineTokens(token.tokens) : token.text);
+        break;
+
+      case "heading":
+        blocks.push(token.tokens ? renderInlineTokens(token.tokens) : token.text);
+        break;
+
+      case "code":
+        blocks.push(token.text);
+        break;
+
+      case "blockquote":
+        if (token.tokens) {
+          const inner = renderBlockTokens(token.tokens);
+          blocks.push(...inner);
+        }
+        break;
+
+      case "list": {
+        const items = [];
+        for (const item of token.items) {
+          const itemText = item.tokens ? renderBlockTokens(item.tokens).join("\n") : item.text;
+          const bullet = token.ordered
+            ? `${items.length + 1}. `
+            : "- ";
+          items.push(bullet + itemText);
+        }
+        blocks.push(items.join("\n"));
+        break;
+      }
+
+      case "table": {
+        const rows = [];
+        // Header row
+        rows.push(
+          token.header.map((cell) => renderInlineTokens(cell.tokens)).join(" | ")
+        );
+        // Data rows
+        for (const row of token.rows) {
+          rows.push(
+            row.map((cell) => renderInlineTokens(cell.tokens)).join(" | ")
+          );
+        }
+        blocks.push(rows.join("\n"));
+        break;
+      }
+
+      case "hr":
+        // Skip horizontal rules
+        break;
+
+      case "space":
+        // Skip whitespace tokens
+        break;
+
+      case "html":
+        // Strip block-level HTML
+        break;
+
+      default:
+        // Unknown block token — include text if available
+        if (token.tokens) {
+          blocks.push(...renderBlockTokens(token.tokens));
+        } else if (token.text) {
+          blocks.push(token.text);
+        }
+        break;
+    }
+  }
+
+  return blocks;
+}
+
+function cleanupDisplayWhitespace(text) {
+  return text
+    .replace(/(\S)[ \t]{2,}(?=\S)/g, "$1 ")
+    .replace(/[ \t]+$/gm, "");
+}
+
+/**
+ * Convert Markdown text to plain text.
+ * Uses marked.lexer to parse, then walks the AST to extract text.
+ *
+ * @param {string} markdown
+ * @param {{ stripReplyTags?: boolean }} [options]
+ * @returns {{ text: string }}
+ */
+function markdownToPlainText(markdown, options = {}) {
+  if (!markdown) return { text: "" };
+  const source = options.stripReplyTags ? stripReplyDirectives(markdown) : markdown;
+  if (!source) return { text: "" };
+
+  const tokens = marked.lexer(source);
+  const blocks = renderBlockTokens(tokens);
+  const text = cleanupDisplayWhitespace(
+    filterDisplayEmojiText(blocks.join("\n\n"))
+  );
+
+  return { text };
+}
+
+// --- Content Extraction ---
+
+/**
+ * Extract displayable text from a message's content field.
+ * Content can be a string or an array of content blocks.
+ *
+ * @param {string|Array} content
+ * @returns {string|null} Text content, or null if no displayable text
+ */
+function extractText(content) {
+  if (typeof content === "string") {
+    return content || null;
+  }
+
+  if (!Array.isArray(content)) return null;
+
+  const textParts = [];
+  let hasImage = false;
+  for (const block of content) {
+    if (block && block.type === "text" && typeof block.text === "string") {
+      textParts.push(block.text);
+    }
+    if (block && block.type === "image") {
+      hasImage = true;
+    }
+  }
+
+  const text = textParts.length > 0 ? textParts.join("\n\n") : null;
+  if (!hasImage) return text;
+  if (!text) return "[Image]";
+  return `[Image] ${text}`;
+}
+
+// --- Message Filtering ---
+
+/**
+ * Filter messages for display and format them with name prefixes.
+ * Returns an array of formatted message strings.
+ */
+function filterAndFormat() {
+  return displayEntries.map((entry) => ({
+    text: formatEntry(entry),
+    role: entry.role,
+  }));
+}
+
+// --- Turn Grouping ---
+
+/**
+ * Group chronological formatted messages into turns.
+ * Each user message starts a new turn. Assistant messages before the first
+ * user message form their own turn.
+ *
+ * @param {Array<{text: string, role: string}>} formatted
+ * @returns {Array<Array<{text: string, role: string}>>}
+ */
+function groupIntoTurns(formatted) {
+  const turns = [];
+  let current = [];
+
+  for (const entry of formatted) {
+    if (entry.role === "user" && current.length > 0) {
+      turns.push(current);
+      current = [];
+    }
+    current.push(entry);
+  }
+
+  if (current.length > 0) {
+    turns.push(current);
+  }
+
+  return turns;
+}
+
+// --- Pagination ---
+
+/**
+ * Paginate conversation into chronological rolling pages.
+ * All messages are joined in order, with newest content at the tail of the
+ * resulting string.
+ *
+ * Relay intentionally does not char-split the transcript. Client render code
+ * owns virtual-page splitting.
+ *
+ * @returns {Array<{content: string, subPage: [number, number]|null, turn: null}>}
+ */
+function paginate() {
+  if (displayEntries.length === 0) return [];
+
+  // Join all messages chronologically (no reversal)
+  const allText = getTranscript();
+
+  return [{ content: allText, subPage: null, turn: null }];
+}
+
+// --- Public API ---
+
+const conversationState = {
+  /**
+   * Bulk load messages from chat.history and set agent name.
+   *
+   * @param {Array<{role: string, content: string|Array}>} msgs
+   * @param {string} [name] - Agent name for display prefix
+   */
+  hydrate(msgs, name) {
+    messages = Array.isArray(msgs) ? [...msgs] : [];
+    if (name) agentName = name;
+    rebuildDisplayCache();
+  },
+
+  /**
+   * Append a single message.
+   *
+   * @param {string} role
+   * @param {string|Array} content
+   * @param {string} [name] - Optional display name override (used for simulate)
+   */
+  addMessage(role, content, name) {
+    const msg = { role, content };
+    if (name) msg.name = name;
+    messages.push(msg);
+
+    const entry = buildDisplayEntry(msg, {
+      isFirstVisibleEntry: displayEntries.length === 0,
+    });
+    if (!entry) return;
+
+    displayEntries.push(entry);
+    const nextLine = formatEntry(entry);
+    if (transcriptDirty) return;
+    if (!cachedTranscript) {
+      cachedTranscript = nextLine;
+    } else {
+      cachedTranscript += `\n\n${nextLine}`;
+    }
+  },
+
+  /**
+   * Update the agent name prefix used in formatted output.
+   *
+   * @param {string} name
+   */
+  setAgentName(name) {
+    const next = name || DEFAULT_AGENT_NAME;
+    if (agentName === next) return;
+    agentName = next;
+    transcriptDirty = true;
+  },
+
+  /**
+   * Return paginated, filtered, markdown-stripped page array.
+   *
+   * @returns {Array<{content: string, subPage: [number, number]|null}>}
+   */
+  getPages() {
+    return paginate();
+  },
+
+  /**
+   * Return the number of pages.
+   *
+   * @returns {number}
+   */
+  getPageCount() {
+    return displayEntries.length > 0 ? 1 : 0;
+  },
+
+  /**
+   * Return the full unfiltered transcript.
+   *
+   * @returns {Array<{role: string, content: string|Array}>}
+   */
+  getRawMessages() {
+    return [...messages];
+  },
+
+  /**
+   * Reset all state.
+   */
+  clear() {
+    messages = [];
+    agentName = DEFAULT_AGENT_NAME;
+    displayEntries = [];
+    cachedTranscript = "";
+    transcriptDirty = false;
+  },
+
+  // Exposed for testing
+  _markdownToPlainText: markdownToPlainText,
+  _extractText: extractText,
+  _isLikelySyntheticSessionStarterPrompt: isLikelySyntheticSessionStarterPrompt,
+};
+
+export const {
+  hydrate,
+  addMessage,
+  setAgentName,
+  getPages,
+  getPageCount,
+  getRawMessages,
+  clear,
+  _markdownToPlainText,
+  _extractText,
+  _isLikelySyntheticSessionStarterPrompt,
+} = conversationState;
+
+export default conversationState;