decant-core 1.3.0 → 1.4.0

package/ai/claude.js

@@ -70,6 +70,39 @@ function getCurrentBranch(data) {
   return branch;
 }
 
+const EXT_TO_LANG = {
+  py: "python",
+  js: "javascript",
+  jsx: "jsx",
+  ts: "typescript",
+  tsx: "tsx",
+  md: "markdown",
+  html: "html",
+  css: "css",
+  json: "json",
+  sh: "bash",
+  bash: "bash",
+  yml: "yaml",
+  yaml: "yaml",
+  sql: "sql",
+  java: "java",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  c: "c",
+  cpp: "cpp",
+  txt: "text",
+};
+
+const MIME_TO_LANG = {
+  "application/vnd.ant.react": "jsx",
+  "text/html": "html",
+  "image/svg+xml": "svg",
+  "application/vnd.ant.mermaid": "mermaid",
+  "text/markdown": "markdown",
+  "application/vnd.ant.code": "text",
+};
+
 function extractArtifactsFromText(text) {
   const artifactRegex = /<antArtifact[^>]*>([\s\S]*?)<\/antArtifact>/g;
   const artifacts = [];
@@ -90,53 +123,139 @@ function extractArtifactsFromText(text) {
   return artifacts;
 }
 
-function extractArtifacts(message) {
+function collectArtifacts(messages) {
+  const artifacts = new Map();
+  for (const m of messages) {
+    if (!Array.isArray(m?.content)) continue;
+    for (const block of m.content) {
+      if (block.type !== "tool_use" || block.name !== "artifacts") continue;
+      const input = block.input || {};
+      const id = input.id || "__artifact__";
+      let a = artifacts.get(id);
+      if (!a) {
+        a = { content: "" };
+        artifacts.set(id, a);
+      }
+
+      if (input.command === "update") {
+        if (
+          typeof input.old_str === "string" &&
+          typeof input.new_str === "string"
+        ) {
+          if (a.content.includes(input.old_str)) {
+            a.content = a.content.replace(input.old_str, () => input.new_str);
+          } else {
+            console.warn(
+              `[AI Exporter] Artifact "${a.title || id}": update could not be applied (source text not found).`,
+            );
+          }
+        }
+      } else if (typeof input.content === "string") {
+        a.content = input.content;
+      }
+
+      if (input.title) a.title = input.title;
+      if (input.type) a.type = input.type;
+      if (input.language) a.language = input.language;
+      a.lastBlock = block;
+      if (input.version_uuid) a.lastVersionUuid = input.version_uuid;
+    }
+  }
+  return artifacts;
+}
+
+function extractArtifacts(message, foldedArtifacts = new Map()) {
   const artifacts = [];
   if (message.content && Array.isArray(message.content)) {
     for (const content of message.content) {
-      if (
-        content.type === "tool_use" &&
-        (content.name === "artifacts" || content.name === "create_file") &&
-        content.display_content
-      ) {
-        const displayContent = content.display_content;
-        if (displayContent.type === "code_block" && displayContent.code) {
-          const filename = displayContent.filename || "artifact";
-          const title = filename
-            .split("/")
-            .pop()
-            .replace(/\.[^.]+$/, "");
-          artifacts.push({
-            title: title || "Artifact",
-            language: displayContent.language || "text",
-            content: displayContent.code.trim(),
-          });
-        } else if (
-          displayContent.type === "json_block" &&
-          displayContent.json_block
-        ) {
-          try {
-            const data = JSON.parse(displayContent.json_block);
-            if (data.filename) {
-              const filename = data.filename;
-              const title = filename
-                .split("/")
-                .pop()
-                .replace(/\.[^.]+$/, "");
-              artifacts.push({
-                title: title || "Artifact",
-                language: data.language || "text",
-                content: (data.code || "").trim(),
-              });
+      if (content.type === "tool_use") {
+        const input = content.input || {};
+        if (content.name === "artifacts") {
+          const id = input.id || "__artifact__";
+          const folded = foldedArtifacts.get(id);
+
+          // Only emit at the final edit block for this artifact
+          if (folded && folded.lastBlock && folded.lastBlock !== content) {
+            continue;
+          }
+          if (
+            folded &&
+            folded.lastVersionUuid &&
+            input.version_uuid &&
+            input.version_uuid !== folded.lastVersionUuid
+          ) {
+            continue;
+          }
+
+          const title = input.title || (folded && folded.title) || "Artifact";
+          const lang =
+            input.language ||
+            (folded && folded.language) ||
+            MIME_TO_LANG[input.type || (folded && folded.type)] ||
+            "text";
+          const code =
+            (folded && folded.content) || input.content || input.new_str || "";
+          if (code) {
+            artifacts.push({
+              title,
+              language: lang,
+              content: code.trim(),
+            });
+          }
+        } else if (content.name === "create_file") {
+          let code = "";
+          let filename = "file";
+          let lang = "";
+
+          if (typeof input.file_text === "string" && input.file_text) {
+            code = input.file_text.trim();
+            filename = String(input.path || "file")
+              .split("/")
+              .pop();
+            const ext = filename.includes(".")
+              ? filename.split(".").pop().toLowerCase()
+              : "";
+            lang = EXT_TO_LANG[ext] || ext || "text";
+          } else if (content.display_content) {
+            const displayContent = content.display_content;
+            if (displayContent.type === "code_block" && displayContent.code) {
+              filename = displayContent.filename || "artifact";
+              code = displayContent.code.trim();
+              lang = displayContent.language || "text";
+            } else if (
+              displayContent.type === "json_block" &&
+              displayContent.json_block
+            ) {
+              try {
+                const data = JSON.parse(displayContent.json_block);
+                if (data.filename) {
+                  filename = data.filename;
+                  code = (data.code || "").trim();
+                  lang = data.language || "text";
+                }
+              } catch (e) {
+                console.warn(
+                  "[AI Exporter] Failed to parse tool use artifact json:",
+                  e,
+                );
+              }
             }
-          } catch (e) {
-            console.warn(
-              "[AI Exporter] Failed to parse tool use artifact json:",
-              e,
-            );
+          }
+
+          if (code) {
+            const title = filename
+              .split("/")
+              .pop()
+              .replace(/\.[^.]+$/, "");
+            artifacts.push({
+              title: title || "Artifact",
+              language: lang,
+              content: code,
+            });
           }
         }
       }
+
       if (content.text) {
         artifacts.push(...extractArtifactsFromText(content.text));
       }
@@ -148,6 +267,68 @@ function extractArtifacts(message) {
   return artifacts;
 }
 
+function unrollInteractiveElements(root, doc) {
+  if (!root || !doc) return;
+
+  // Group slide titles by their common card container
+  const titleEls = Array.from(root.querySelectorAll(".text-title"));
+  if (titleEls.length > 0) {
+    const containerMap = new Map();
+    for (const titleEl of titleEls) {
+      let container = titleEl.parentElement;
+      while (container && container !== root) {
+        if (
+          container.classList.contains("@container") ||
+          container.classList.contains("bg-surface-2") ||
+          container.querySelector(
+            '[aria-label*="Go to step"], [aria-current="step"]',
+          )
+        ) {
+          break;
+        }
+        container = container.parentElement;
+      }
+      if (container && container !== root) {
+        if (!containerMap.has(container)) {
+          containerMap.set(container, []);
+        }
+        containerMap.get(container).push(titleEl);
+      }
+    }
+
+    for (const [container, titles] of containerMap.entries()) {
+      const slides = [];
+      titles.forEach((titleEl, idx) => {
+        const title = titleEl.textContent.trim();
+        const bodyEl =
+          titleEl.nextElementSibling ||
+          titleEl.parentElement.querySelector(".text-body");
+        const body = bodyEl ? bodyEl.textContent.trim() : "";
+        if (title) slides.push({ index: idx + 1, title, body });
+      });
+
+      if (slides.length > 0) {
+        const replacement = doc.createElement("div");
+        replacement.className = "unrolled-interactive-steps";
+        slides.forEach((slide) => {
+          const h3 = doc.createElement("h3");
+          h3.textContent = `${slide.index}. ${slide.title}`;
+          replacement.appendChild(h3);
+          if (slide.body) {
+            const p = doc.createElement("p");
+            p.textContent = slide.body;
+            replacement.appendChild(p);
+          }
+        });
+        container.replaceWith(replacement);
+      }
+    }
+  }
+
+  // Remove any remaining buttons
+  root.querySelectorAll("button").forEach((btn) => btn.remove());
+}
+
 export class ClaudeParser extends ChatParser {
   name = "Claude";
   constructor() {
@@ -189,6 +370,31 @@ export class ClaudeParser extends ChatParser {
           }
 
           const branch = getCurrentBranch(data);
+          const foldedArtifacts = collectArtifacts(branch);
+
+          const toolResultMap = new Map();
+          for (const msg of branch) {
+            if (Array.isArray(msg?.content)) {
+              for (const block of msg.content) {
+                if (block.type === "tool_result") {
+                  const toolUseId = block.tool_use_id || block.id;
+                  let answers = block.toolUseResult?.answers || {};
+                  if (
+                    (!answers || Object.keys(answers).length === 0) &&
+                    typeof block.content === "string"
+                  ) {
+                    try {
+                      const parsed = JSON.parse(block.content);
+                      answers = parsed.answers || parsed;
+                    } catch {
+                      answers = { result: block.content };
+                    }
+                  }
+                  toolResultMap.set(toolUseId, answers);
+                }
+              }
+            }
+          }
 
           const convTitle = data.name || title;
 
@@ -209,6 +415,47 @@ export class ClaudeParser extends ChatParser {
                   if (cleanText) {
                     contentStr += `${cleanText}\n\n`;
                   }
+                } else if (block.type === "tool_use") {
+                  const input = block.input || {};
+                  if (
+                    block.name === "visualize:show_widget" &&
+                    input.widget_code
+                  ) {
+                    const widgetTitle = input.title || "Interactive Widget";
+                    contentStr += `> **Interactive Widget: ${widgetTitle}**\n\n\`\`\`jsx\n${input.widget_code.trim()}\n\`\`\`\n\n`;
+                  } else if (block.name === "repl" && input.code) {
+                    contentStr += `**Analyzed data**\n\n\`\`\`javascript\n${input.code.trim()}\n\`\`\`\n\n`;
+                  } else if (
+                    block.name === "AskUserQuestion" &&
+                    Array.isArray(input.questions) &&
+                    input.questions.length > 0
+                  ) {
+                    const qCount = input.questions.length;
+                    const countLabel =
+                      qCount === 1
+                        ? "Asked 1 question"
+                        : `Asked ${qCount} questions`;
+                    let qStr = `> **${countLabel}:**\n`;
+                    const answers = toolResultMap.get(block.id) || {};
+                    for (const q of input.questions) {
+                      const qText = q.question || q.text || "";
+                      const ans = answers[qText];
+                      let ansStr = "";
+                      if (typeof ans === "string") {
+                        ansStr = ans;
+                      } else if (Array.isArray(ans)) {
+                        ansStr = ans.join(", ");
+                      } else if (ans && typeof ans === "object") {
+                        ansStr = JSON.stringify(ans);
+                      } else if (ans != null) {
+                        ansStr = String(ans);
+                      }
+                      qStr += ansStr
+                        ? `> - **${qText}** — ${ansStr}\n`
+                        : `> - ${qText}\n`;
+                    }
+                    contentStr += `${qStr}\n`;
+                  }
                 }
               }
             } else if (message.text) {
@@ -245,13 +492,37 @@ export class ClaudeParser extends ChatParser {
               }
             }
 
+            // Append files (images/documents)
+            if (message.files && Array.isArray(message.files)) {
+              for (const file of message.files) {
+                const name = file.file_name || "file";
+                if (
+                  file.file_kind === "image" &&
+                  (file.preview_url || file.preview_asset?.url)
+                ) {
+                  const url = file.preview_url || file.preview_asset.url;
+                  contentStr += `\n\n**Attachment: ${name}**\n\n![${name}](${url})\n\n`;
+                } else if (
+                  file.file_kind === "document" &&
+                  file.document_asset?.url
+                ) {
+                  const url = file.document_asset.url;
+                  const pages = file.document_asset.page_count;
+                  const pageInfo = pages
+                    ? ` · ${pages} page${pages === 1 ? "" : "s"}`
+                    : "";
+                  contentStr += `\n\n**Attachment: [${name}](${url})** _(document${pageInfo})_\n\n`;
+                }
+              }
+            }
+
             contentStr = contentStr.trim();
             if (contentStr) {
               messages.push({ role, content: contentStr });
             }
 
             // Extract and push artifacts
-            const artifacts = extractArtifacts(message);
+            const artifacts = extractArtifacts(message, foldedArtifacts);
             for (const artifact of artifacts) {
               let artContent = "";
               const artTitle = artifact.title || "Artifact";
@@ -356,13 +627,10 @@ export class ClaudeParser extends ChatParser {
       return !overlapsWithError;
     });
 
-    const combined = [...new Set([...strictCandidates, ...validFallbacks])];
-
-    const allElements = combined.sort((a, b) => {
-      return a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING
-        ? -1
-        : 1;
-    });
+    const combinedSet = new Set([...strictCandidates, ...validFallbacks]);
+    const allElements = Array.from(
+      document.querySelectorAll(`${strictSelectors}, ${fallbackSelectors}`),
+    ).filter((el) => combinedSet.has(el));
 
     const artifactElements = document.querySelectorAll(".artifact-block-cell");
     const artifactMap = new Map();
@@ -375,7 +643,7 @@ export class ClaudeParser extends ChatParser {
       if (el.matches('[data-testid="user-message"]')) {
         role = "User";
         const clone = el.cloneNode(true);
-        clone.querySelectorAll("button").forEach((btn) => btn.remove());
+        unrollInteractiveElements(clone, el.ownerDocument || document);
         content = convertToMarkdown(clone);
       } else if (
         el.matches(".font-claude-message") ||
@@ -384,7 +652,7 @@ export class ClaudeParser extends ChatParser {
       ) {
         role = "Claude";
         const clone = el.cloneNode(true);
-        clone.querySelectorAll("button").forEach((btn) => btn.remove());
+        unrollInteractiveElements(clone, el.ownerDocument || document);
         content = convertToMarkdown(clone);
       } else if (el.matches(".artifact-block-cell")) {
         role = "Claude Artifact";

package/ai/google_search_ai.js

@@ -61,6 +61,14 @@ export function sanitizeResponseContainer(container) {
 export function cleanMarkdownSpacing(markdown) {
   if (!markdown) return "";
   return markdown
+    .replace(
+      /(?:google|sn)\.\\?_setImageSrc\s*\(\s*['"][^'"]*['"]\s*,\s*['"][^'"]*['"]\s*\);?/gi,
+      "",
+    )
+    .replace(
+      /data:image(?:\\)?\/[a-zA-Z0-9+.-]+;base64,[A-Za-z0-9+/=\\]+/gi,
+      "",
+    )
     .replace(/[ \t]+$/gm, "")
     .replace(/\n{3,}/g, "\n\n")
     .trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decant-core",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Shared AI chat platform parsers and detection for Covai browser extensions.",
   "type": "module",
   "main": "ai/index.js",
@@ -52,9 +52,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@extractus/article-extractor": "^9.0.0",
+    "@extractus/article-extractor": "^9.0.1",
     "@mozilla/readability": "^0.6.0",
-    "defuddle": "^0.19.2",
+    "defuddle": "^0.19.3",
     "turndown": "^7.2.4",
     "turndown-plugin-gfm": "^1.0.2"
   },