ocuclaw 1.3.2 → 1.3.4

package/dist/domain/conversation-state.js

@@ -2,8 +2,6 @@ import { filterDisplayEmojiText } from "./message-emoji-filter.js";
 import { stripAllTaggedSpans } from "./tagged-span-strip.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";
@@ -22,7 +20,6 @@ const SYNTHETIC_SESSION_INSTRUCTION_PATTERNS = [
   /\bdo not mention\b/,
   /\binternal\b.*\b(?:steps|files|tools|reasoning)\b/,
 ];
-// --- State ---
 
 let messages = [];
 let agentName = DEFAULT_AGENT_NAME;
@@ -30,13 +27,6 @@ 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;
 
@@ -83,10 +73,6 @@ function countSyntheticSessionInstructionSignals(normalizedText) {
   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;
@@ -100,21 +86,12 @@ function isLikelySyntheticSessionStarterPrompt(text) {
   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) {
@@ -126,11 +103,6 @@ function rebuildDisplayCache() {
   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");
@@ -138,12 +110,6 @@ function getTranscript() {
   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 "";
 
@@ -162,9 +128,6 @@ function stripReplyDirectives(text) {
     .trimEnd();
 }
 
-/**
- * Extract plain text from an array of marked inline tokens.
- */
 function renderInlineTokens(tokens) {
   let out = "";
   for (const token of tokens) {
@@ -186,13 +149,13 @@ function renderInlineTokens(tokens) {
         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;
     }
@@ -200,10 +163,6 @@ function renderInlineTokens(tokens) {
   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 = [];
 
@@ -218,10 +177,7 @@ function renderBlockTokens(tokens) {
         break;
 
       case "text":
-        // Block-level text token (marked wraps list-item content in these).
-        // Without this case it falls through to default, which recurses over
-        // the INLINE children as blocks — putting every bold/code span on its
-        // own line once the list join("\n") runs.
+
         blocks.push(token.tokens ? renderInlineTokens(token.tokens) : token.text);
         break;
 
@@ -251,11 +207,11 @@ function renderBlockTokens(tokens) {
 
       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(" | ")
@@ -266,19 +222,19 @@ function renderBlockTokens(tokens) {
       }
 
       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) {
@@ -297,14 +253,6 @@ function cleanupDisplayWhitespace(text) {
     .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;
@@ -319,15 +267,6 @@ function markdownToPlainText(markdown, options = {}) {
   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;
@@ -352,12 +291,6 @@ function extractText(content) {
   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),
@@ -365,16 +298,6 @@ function filterAndFormat() {
   }));
 }
 
-// --- 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 = [];
@@ -394,49 +317,22 @@ function groupIntoTurns(formatted) {
   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;
@@ -457,11 +353,22 @@ const conversationState = {
     }
   },
 
-  /**
-   * Update the agent name prefix used in formatted output.
-   *
-   * @param {string} name
-   */
+  replaceLatestUserMessage(content, name) {
+    let index = messages.length - 1;
+    while (index >= 0 && messages[index].role !== "user") {
+      index -= 1;
+    }
+
+    const msg = { role: "user", content };
+    if (name) msg.name = name;
+
+    if (index >= 0) {
+      messages = messages.slice(0, index);
+    }
+    messages.push(msg);
+    rebuildDisplayCache();
+  },
+
   setAgentName(name) {
     const next = name || DEFAULT_AGENT_NAME;
     if (agentName === next) return;
@@ -469,36 +376,18 @@ const conversationState = {
     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;
@@ -507,7 +396,6 @@ const conversationState = {
     transcriptDirty = false;
   },
 
-  // Exposed for testing
   _markdownToPlainText: markdownToPlainText,
   _extractText: extractText,
   _isLikelySyntheticSessionStarterPrompt: isLikelySyntheticSessionStarterPrompt,
@@ -516,6 +404,7 @@ const conversationState = {
 export const {
   hydrate,
   addMessage,
+  replaceLatestUserMessage,
   setAgentName,
   getPages,
   getPageCount,

package/dist/domain/debug-bundle-cache.js

@@ -0,0 +1,52 @@
+export function createBundleCache(opts) {
+  const maxEntries = Math.max(1, opts.maxEntries | 0);
+  const ttlMs = Number.isFinite(opts.ttlMs) && opts.ttlMs >= 0 ? opts.ttlMs : 5 * 60_000;
+  const now = typeof opts.now === "function" ? opts.now : () => Date.now();
+
+  const store = new Map();
+
+  function isExpired(entry) {
+    if (ttlMs === 0) return false;
+    return now() - entry.cachedMs > ttlMs;
+  }
+
+  function dropExpired() {
+    for (const [id, entry] of store) {
+      if (isExpired(entry)) store.delete(id);
+    }
+  }
+
+  function put(id, entry) {
+    dropExpired();
+    if (store.has(id)) store.delete(id);
+    store.set(id, entry);
+    while (store.size > maxEntries) {
+      const firstKey = store.keys().next().value;
+      store.delete(firstKey);
+    }
+  }
+
+  function get(id) {
+    const entry = store.get(id);
+    if (!entry) return null;
+    if (isExpired(entry)) {
+      store.delete(id);
+      return null;
+    }
+    return entry;
+  }
+
+  function del(id) {
+    store.delete(id);
+  }
+
+  function size() {
+    return store.size;
+  }
+
+  function sweep() {
+    dropExpired();
+  }
+
+  return { put, get, delete: del, size, sweep };
+}

package/dist/domain/debug-bundle-format.js

@@ -0,0 +1,60 @@
+export function sanitizeCategoryFilename(cat) {
+  return cat.replace(/\./g, "-") + ".jsonl";
+}
+
+export function bucketEventsToFiles(input) {
+  const { events, ringEvents, ringCapacity, appliedQuery } = input;
+  const byCategory = new Map();
+  for (const evt of events) {
+    if (!byCategory.has(evt.cat)) byCategory.set(evt.cat, []);
+    byCategory.get(evt.cat).push(evt);
+  }
+  const files = new Map();
+  const categories = [];
+  let overallFrom = null;
+  let overallTo = null;
+  let totalBytes = 0;
+  for (const [cat, list] of byCategory) {
+    list.sort((a, b) => a.ts - b.ts || (a.seq || 0) - (b.seq || 0));
+    const filename = sanitizeCategoryFilename(cat);
+    let bytes = 0;
+    let content = "";
+    for (const evt of list) {
+      const line = JSON.stringify(evt) + "\n";
+      content += line;
+      bytes += Buffer.byteLength(line, "utf8");
+    }
+    files.set(filename, content);
+    totalBytes += bytes;
+    const fromMs = list[0].ts;
+    const toMs = list[list.length - 1].ts;
+    if (overallFrom === null || fromMs < overallFrom) overallFrom = fromMs;
+    if (overallTo === null || toMs > overallTo) overallTo = toMs;
+    categories.push({ cat, count: list.length, bytes, fromMs, toMs, file: filename });
+  }
+  const summary = {
+    ringEvents, ringCapacity, totalBytes,
+    timeRange: overallFrom !== null && overallTo !== null
+      ? { fromMs: overallFrom, toMs: overallTo, spanMs: overallTo - overallFrom } : null,
+    categories, appliedQuery,
+  };
+  return { files, summary };
+}
+
+export function renderBundleReadme(summary) {
+  const lines = [];
+  lines.push("# Debug dump", "");
+  lines.push("See `.agents/skills/ocuclaw-debug/SKILL.md` → 'Analyzing bucketed dumps' for usage guidance.", "");
+  lines.push(`Ring: ${summary.ringEvents} / ${summary.ringCapacity}`);
+  lines.push(`Total bytes: ${summary.totalBytes}`);
+  if (summary.timeRange) lines.push(`Time range: ${summary.timeRange.fromMs} → ${summary.timeRange.toMs} (${summary.timeRange.spanMs} ms)`);
+  lines.push("", "## Buckets", "");
+  for (const c of summary.categories) {
+    const eventStr = c.count === 1 ? "1 event" : `${c.count} events`;
+    lines.push(`- \`${c.file}\` — ${eventStr}, ${c.bytes} bytes, ${c.fromMs} → ${c.toMs}`);
+  }
+  if (summary.categories.length === 0) lines.push("- (no events matched the query)");
+  lines.push("", "## Cross-category timeline", "");
+  lines.push("Per-category files are chronological WITHIN a category only. To reconstruct the global stream, merge-sort all `*.jsonl` by `(ts, seq)` — `seq` is the global monotonic tie-break that makes a same-`ts` merge deterministic.");
+  return lines.join("\n") + "\n";
+}

package/dist/domain/debug-bundle-preview.js

@@ -0,0 +1,123 @@
+export function buildBundlePreview(files, opts) {
+  const maxEvents = (opts && typeof opts.maxEvents === "number" && opts.maxEvents > 0) ? opts.maxEvents : 15;
+  const maxCharsPerEvent = (opts && typeof opts.maxCharsPerEvent === "number" && opts.maxCharsPerEvent > 0) ? opts.maxCharsPerEvent : 80;
+
+  const SKIP = new Set(["README.md", "metadata.json", "correlation-liveui.jsonl"]);
+
+  const catParsed = [];
+
+  const catNames = [];
+
+  if (files && typeof files.forEach === "function") {
+    files.forEach((content, filename) => {
+      if (SKIP.has(filename)) return;
+      if (!filename.endsWith(".jsonl")) return;
+
+      const cat = filename.slice(0, -(".jsonl".length));
+      const lines = content.split("\n").filter((l) => l.trim().length > 0);
+
+      const parsed = [];
+      for (const line of lines) {
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+
+          continue;
+        }
+        parsed.push(obj);
+      }
+      if (parsed.length > 0) {
+        catParsed.push(parsed);
+        catNames.push(cat);
+      }
+    });
+  }
+
+  const events = [];
+
+  let totalParsed = 0;
+  for (const parsed of catParsed) {
+    totalParsed += parsed.length;
+  }
+
+  if (catParsed.length > 0) {
+    const indices = new Array(catParsed.length).fill(0);
+    let added = 0;
+    let anyProgress = true;
+    while (added < maxEvents && anyProgress) {
+      anyProgress = false;
+      for (let ci = 0; ci < catParsed.length && added < maxEvents; ci++) {
+        const idx = indices[ci];
+        if (idx >= catParsed[ci].length) continue;
+        indices[ci] = idx + 1;
+        anyProgress = true;
+        const parsed = catParsed[ci][idx];
+        const ts = (parsed && typeof parsed.ts === "number") ? parsed.ts : 0;
+        const cat = (parsed && typeof parsed.cat === "string" && parsed.cat) ? parsed.cat : catNames[ci];
+        const text = extractText(parsed, maxCharsPerEvent);
+        events.push({ ts, cat, text });
+        added++;
+      }
+    }
+  }
+
+  const truncated = totalParsed > events.length;
+
+  return { events, truncated };
+}
+
+function extractText(parsed, maxChars) {
+  if (!parsed) return truncate("", maxChars);
+
+  const data = parsed.data;
+  const eventName = (typeof parsed.event === "string" && parsed.event) ? parsed.event : "";
+
+  let text = "";
+
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+
+    const TEXT_LIKE_KEYS = ["message", "text", "label", "note", "description", "reason", "state", "error"];
+    for (const key of TEXT_LIKE_KEYS) {
+      if (typeof data[key] === "string" && data[key]) {
+        text = data[key];
+        break;
+      }
+    }
+    if (!text) {
+
+      for (const v of Object.values(data)) {
+        if (typeof v === "string" && v) {
+          text = v;
+          break;
+        }
+      }
+    }
+    if (!text) {
+
+      const preview = {};
+      let count = 0;
+      for (const [k, v] of Object.entries(data)) {
+        if (typeof v === "number" || typeof v === "boolean") {
+          preview[k] = v;
+          if (++count >= 3) break;
+        }
+      }
+      if (count > 0) {
+        text = JSON.stringify(preview);
+      }
+    }
+  }
+
+  if (!text && eventName) {
+    text = eventName;
+  }
+
+  return truncate(text, maxChars);
+}
+
+function truncate(s, maxChars) {
+  if (typeof s !== "string") return "";
+  if (s.length <= maxChars) return s;
+  return s.slice(0, maxChars) + "…";
+}