@ai-matrx/chat 0.7.3 → 0.7.5

package/dist/agents/redux/execution-system/utils/content-prefilter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Content Pre-Filter — Fast-reject layers for splitContentIntoBlocksV2
+ *
+ * Designed to run BEFORE any regex, JSON parsing, or XML extraction.
+ * Returns a set of candidate categories for a given line so the main
+ * parser can skip entire detection branches.
+ *
+ * Layer 0: Single-character scan (nanoseconds)
+ * Layer 1: Cheap secondary validation (tens of nanoseconds)
+ *
+ * If no candidates are found → the line is guaranteed to be plain text.
+ */
+/**
+ * Bit flags — a line can be a candidate for multiple categories simultaneously.
+ * Using bits so the main parser can do `if (candidates & Candidate.CODE)`.
+ */
+export declare const Candidate: {
+    readonly NONE: 0;
+    readonly TEXT: 0;
+    readonly CODE: number;
+    readonly XML_SIMPLE: number;
+    readonly XML_ATTR: number;
+    readonly TABLE: number;
+    readonly IMAGE: number;
+    readonly VIDEO: number;
+    readonly DIVIDER: number;
+    readonly TREE: number;
+    readonly BARE_JSON: number;
+    readonly AUDIO: number;
+    readonly MATRX_FILE: number;
+};
+export type CandidateFlags = number;
+/**
+ * Scans a line and returns a bitmask of candidate categories.
+ *
+ * This scans the FULL line (not just the start) to support inline blocks
+ * like "Hello <decision prompt="...">". The scan is still cheap because
+ * we only look at individual characters — no regex, no string splitting.
+ *
+ * @param line     The raw line (before trimming)
+ * @param trimmed  The normalized+trimmed line (caller already has this)
+ * @returns        Bitmask of Candidate flags
+ */
+export declare function classifyLine(line: string, trimmed: string): CandidateFlags;
+export declare function isPlainText(flags: CandidateFlags): boolean;
+/**
+ * Quick check for whether flags include a specific candidate.
+ * Usage: `if (hasCandidate(flags, Candidate.CODE)) { ... }`
+ */
+export declare function hasCandidate(flags: CandidateFlags, candidate: number): boolean;

package/dist/agents/redux/execution-system/utils/content-prefilter.js

@@ -0,0 +1,243 @@
+import { OUR_FILE_URL_MARKERS } from "@ai-matrx/media/files/engine";
+const Candidate = {
+  NONE: 0,
+  TEXT: 0,
+  // No special block detected — plain text
+  CODE: 1 << 0,
+  // ``` or ~~~ fenced code block
+  XML_SIMPLE: 1 << 1,
+  // <thinking>, <flashcards>, etc.
+  XML_ATTR: 1 << 2,
+  // <decision prompt="...">, <artifact ...>
+  TABLE: 1 << 3,
+  // | col | col |
+  IMAGE: 1 << 4,
+  // ![alt](url) or [Image URL: ...]
+  VIDEO: 1 << 5,
+  // [Video URL: ...]
+  DIVIDER: 1 << 7,
+  // *** or # ===
+  TREE: 1 << 8,
+  // Box-drawing / ASCII tree characters
+  BARE_JSON: 1 << 9,
+  // { "key": ... } JSON object without code fences
+  AUDIO: 1 << 10,
+  // [Audio URL: ...] or a standalone …/clip.mp3 link
+  MATRX_FILE: 1 << 11
+  // link/URL to one of OUR files (signed S3 / CDN / public / share)
+};
+const AUDIO_EXT_RE = /\.(mp3|wav|m4a|aac|ogg|oga|opus|flac|weba|webm)(\?[^\s)]*)?$/i;
+function isStandaloneAudioLink(trimmed) {
+  const link = trimmed.match(/^!?\[.*?\]\((https?:\/\/[^\s)]+)\)$/);
+  if (link) return AUDIO_EXT_RE.test(link[1]);
+  if (/^https?:\/\/[^\s)]+$/.test(trimmed)) return AUDIO_EXT_RE.test(trimmed);
+  return false;
+}
+function mightBeOurFile(trimmed) {
+  const markers = OUR_FILE_URL_MARKERS;
+  for (let mi = 0; mi < markers.length; mi++) {
+    if (trimmed.includes(markers[mi])) return true;
+  }
+  return false;
+}
+const SIMPLE_XML_TAGS = /* @__PURE__ */ new Set([
+  "thinking",
+  "think",
+  "reasoning",
+  "info",
+  "task",
+  "database",
+  "private",
+  "plan",
+  "event",
+  "tool",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "timeline",
+  "progress_tracker",
+  "troubleshooting",
+  "resources",
+  "research"
+]);
+const ATTR_XML_TAGS = /* @__PURE__ */ new Set([
+  "decision",
+  "artifact",
+  // Editor pill tags — carry attributes (file, line, severity, language, …)
+  // so they're classified as ATTR. The chat-markdown renderer parses them
+  // back into chips on load.
+  "editor_error",
+  "editor_code_snippet"
+]);
+const ALL_XML_TAGS = /* @__PURE__ */ new Set([...SIMPLE_XML_TAGS, ...ATTR_XML_TAGS]);
+const TREE_CHARS = /* @__PURE__ */ new Set([
+  "\u251C",
+  "\u2514",
+  "\u2502",
+  "\u250C",
+  "\u2510",
+  "\u2518",
+  "\u252C",
+  "\u2534",
+  "\u2524",
+  "\u253C",
+  "\u2500"
+]);
+function classifyLine(line, trimmed) {
+  let flags = Candidate.NONE;
+  const len = trimmed.length;
+  if (len === 0) return flags;
+  const first = trimmed[0];
+  if (first === "`" || first === "~") {
+    if (len >= 3 && trimmed[1] === first && trimmed[2] === first) {
+      flags |= Candidate.CODE;
+    }
+  }
+  if (first === "{") {
+    flags |= Candidate.BARE_JSON;
+  }
+  if (first === "|") {
+    if (trimmed.indexOf("|", 1) !== -1) {
+      flags |= Candidate.TABLE;
+    }
+  }
+  if (first === "!" && len >= 2 && trimmed[1] === "[") {
+    flags |= Candidate.IMAGE;
+  }
+  if (first === "*" || first === "#") {
+    if (first === "*") {
+      if (isStarDivider(trimmed)) {
+        flags |= Candidate.DIVIDER;
+      }
+    } else {
+      if (len >= 4 && trimmed.indexOf("=") !== -1) {
+        flags |= Candidate.DIVIDER;
+      }
+    }
+  }
+  if (TREE_CHARS.has(first)) {
+    flags |= Candidate.TREE;
+  }
+  let searchFrom = 0;
+  while (searchFrom < len) {
+    const ltPos = trimmed.indexOf("<", searchFrom);
+    if (ltPos === -1) break;
+    if (ltPos + 2 < len && trimmed[ltPos + 1] === "<" && trimmed[ltPos + 2] === "<") {
+      searchFrom = ltPos + 3;
+      continue;
+    }
+    if (ltPos + 1 < len) {
+      const next = trimmed[ltPos + 1];
+      if (isLetter(next)) {
+        const tagName = extractTagName(trimmed, ltPos + 1);
+        if (tagName) {
+          if (SIMPLE_XML_TAGS.has(tagName)) {
+            flags |= Candidate.XML_SIMPLE;
+          }
+          if (ATTR_XML_TAGS.has(tagName)) {
+            flags |= Candidate.XML_ATTR;
+          }
+        }
+      }
+    }
+    searchFrom = ltPos + 1;
+  }
+  if (!(flags & Candidate.IMAGE) || !(flags & Candidate.VIDEO) || !(flags & Candidate.AUDIO)) {
+    const bracketIdx = trimmed.indexOf("[");
+    if (bracketIdx !== -1) {
+      if (bracketIdx + 10 < len) {
+        const after = trimmed[bracketIdx + 1];
+        if (after === "I" && trimmed.substring(bracketIdx + 1, bracketIdx + 11) === "Image URL:") {
+          flags |= Candidate.IMAGE;
+        } else if (after === "V" && trimmed.substring(bracketIdx + 1, bracketIdx + 11) === "Video URL:") {
+          flags |= Candidate.VIDEO;
+        } else if (after === "A" && trimmed.substring(bracketIdx + 1, bracketIdx + 11) === "Audio URL:") {
+          flags |= Candidate.AUDIO;
+        }
+      }
+    }
+  }
+  if (!(flags & Candidate.AUDIO) && (first === "[" || first === "!" || first === "h") && isStandaloneAudioLink(trimmed)) {
+    flags |= Candidate.AUDIO;
+  }
+  if (!(flags & Candidate.TABLE) && first !== "|") {
+    if (trimmed.indexOf("|") !== -1) {
+      const firstPipe = trimmed.indexOf("|");
+      if (firstPipe !== -1 && trimmed.indexOf("|", firstPipe + 1) !== -1) {
+        flags |= Candidate.TABLE;
+      }
+    }
+  }
+  if (!(flags & Candidate.TREE)) {
+    for (let ci = 1; ci < len; ci++) {
+      if (TREE_CHARS.has(trimmed[ci])) {
+        flags |= Candidate.TREE;
+        break;
+      }
+    }
+  }
+  if (!(flags & Candidate.TREE) && (first === " " || first === "	" || first === "\u2502" || first === "|" || first === "+")) {
+    if (looksLikeAsciiTree(trimmed)) {
+      flags |= Candidate.TREE;
+    }
+  }
+  if (!(flags & Candidate.MATRX_FILE) && mightBeOurFile(trimmed)) {
+    flags |= Candidate.MATRX_FILE;
+  }
+  return flags;
+}
+function isLetter(ch) {
+  const c = ch.charCodeAt(0);
+  return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+}
+function extractTagName(str, start) {
+  let end = start;
+  while (end < str.length) {
+    const c = str.charCodeAt(end);
+    if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95) {
+      end++;
+    } else {
+      break;
+    }
+  }
+  if (end === start) return null;
+  return str.substring(start, end).toLowerCase();
+}
+function isStarDivider(trimmed) {
+  let starCount = 0;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (ch === "*") {
+      starCount++;
+    } else if (ch !== " ") {
+      return false;
+    }
+  }
+  return starCount >= 3;
+}
+function looksLikeAsciiTree(trimmed) {
+  let i = 0;
+  while (i < trimmed.length) {
+    const ch2 = trimmed[i];
+    if (ch2 === " " || ch2 === "	" || ch2 === "\u2502" || ch2 === "|") {
+      i++;
+    } else {
+      break;
+    }
+  }
+  if (i >= trimmed.length) return false;
+  const ch = trimmed[i];
+  return ch === "\u251C" || ch === "\u2514" || ch === "+";
+}
+function isPlainText(flags) {
+  return flags === Candidate.NONE;
+}
+function hasCandidate(flags, candidate) {
+  return (flags & candidate) !== 0;
+}
+export {
+  Candidate,
+  classifyLine,
+  hasCandidate,
+  isPlainText
+};