decant-core 1.3.1 → 1.5.0

package/ai/chatgpt.js

@@ -759,6 +759,19 @@ export class ChatGPTParser extends ChatParser {
           }
         });
 
+        clone
+          .querySelectorAll(
+            '[data-testid="webpage-citation-pill"], [data-testid*="citation-pill"]',
+          )
+          .forEach((pill) => {
+            pill.querySelectorAll("img").forEach((img) => img.remove());
+            pill.querySelectorAll("span").forEach((span) => {
+              if (/^\+\d+$/.test(span.textContent.trim())) {
+                span.remove();
+              }
+            });
+          });
+
         noiseSelectors.forEach((selector) => {
           clone.querySelectorAll(selector).forEach((node) => node.remove());
         });
@@ -783,11 +796,13 @@ export class ChatGPTParser extends ChatParser {
   }
 
   extractMountedMessages() {
-    const articles = Array.from(document.querySelectorAll("article"));
+    const turns = getConversationTurns(document);
     const containers =
-      articles.length > 0
-        ? articles
-        : Array.from(document.querySelectorAll("[data-message-author-role]"));
+      turns.length > 0
+        ? turns
+        : Array.from(
+            document.querySelectorAll("article, [data-message-author-role]"),
+          );
 
     return containers
       .map((container) => this.extractMessage(container))

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/perplexity.js

@@ -1,5 +1,191 @@
 import { ChatParser } from "./base.js";
 import { convertToMarkdown } from "../utils/html-to-markdown.js";
+import { normalizeLatexMath } from "../utils/latex-math.js";
+
+export function getThreadSlug(url) {
+  if (!url || typeof url !== "string") return null;
+  const match = url.match(/\/search\/([a-zA-Z0-9_-]+)/);
+  if (match) return match[1];
+  const matchPage = url.match(/\/page\/([a-zA-Z0-9_-]+)/);
+  if (matchPage) return matchPage[1];
+  return null;
+}
+
+export function extractAssistantAnswer(entry) {
+  if (!entry) return "";
+  // 1. Check blocks -> plan_block.goals for markdown answer
+  if (Array.isArray(entry.blocks)) {
+    for (const b of entry.blocks) {
+      if (b.intended_usage === "plan" && b.plan_block?.goals) {
+        for (const g of b.plan_block.goals) {
+          if (g.description && g.description.length > 100) {
+            return g.description.trim();
+          }
+        }
+      }
+      if (b.answer_block?.answer) {
+        return b.answer_block.answer.trim();
+      }
+      if (b.markdown_block?.markdown) {
+        return b.markdown_block.markdown.trim();
+      }
+    }
+  }
+  // 2. Check direct answer or text fields
+  if (entry.answer && typeof entry.answer === "string") {
+    return entry.answer.trim();
+  }
+  if (entry.text && typeof entry.text === "string") {
+    try {
+      const parsed = JSON.parse(entry.text);
+      if (parsed.answer) return parsed.answer.trim();
+    } catch {
+      return entry.text.trim();
+    }
+  }
+  return "";
+}
+
+export function formatApiResult(threadData, currentUrl, fallbackTitle) {
+  const title =
+    threadData.thread_title ||
+    threadData.first_entry?.query_str ||
+    fallbackTitle ||
+    "Perplexity Search";
+
+  const allEntries = [];
+  if (threadData.first_entry) {
+    allEntries.push(threadData.first_entry);
+  }
+  if (Array.isArray(threadData.entries)) {
+    allEntries.push(...threadData.entries);
+  }
+  if (threadData.latest_entry) {
+    allEntries.push(threadData.latest_entry);
+  }
+
+  // Deduplicate entries by uuid / backend_uuid
+  const seenUuids = new Set();
+  const uniqueEntries = [];
+  for (const entry of allEntries) {
+    const id = entry.uuid || entry.backend_uuid || entry.query_str;
+    if (id && !seenUuids.has(id)) {
+      seenUuids.add(id);
+      uniqueEntries.push(entry);
+    }
+  }
+
+  const messages = [];
+  for (const entry of uniqueEntries) {
+    const prompt = (entry.query_str || "").trim();
+    const timestamp =
+      entry.entry_created_datetime || entry.updated_datetime || undefined;
+
+    if (prompt) {
+      const userMsg = { role: "User", content: prompt };
+      if (timestamp) userMsg.timestamp = timestamp;
+      messages.push(userMsg);
+    }
+
+    const rawAnswer = extractAssistantAnswer(entry);
+    if (rawAnswer) {
+      const normalizedAnswer = normalizeLatexMath(rawAnswer);
+      const assistantMsg = { role: "Perplexity", content: normalizedAnswer };
+      if (timestamp) assistantMsg.timestamp = timestamp;
+      messages.push(assistantMsg);
+    }
+  }
+
+  const effectiveUrl =
+    currentUrl ||
+    (threadData.first_entry?.thread_url_slug
+      ? `https://www.perplexity.ai/search/${threadData.first_entry.thread_url_slug}`
+      : "");
+
+  const metadata = {
+    Source: "Perplexity",
+    Date: new Date().toLocaleString(),
+    Link: effectiveUrl,
+    Method: "API",
+  };
+
+  return { title, messages, url: effectiveUrl, metadata };
+}
+
+export async function getPerplexityAccount() {
+  if (typeof window === "undefined") return null;
+
+  const isUuid = (str) =>
+    typeof str === "string" &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      str.trim(),
+    );
+
+  // 1. Check sessionStorage ('pplx-active-account')
+  try {
+    const sessionAcc = window.sessionStorage?.getItem("pplx-active-account");
+    if (sessionAcc && isUuid(sessionAcc)) return sessionAcc.trim();
+  } catch {
+    // Ignore storage errors
+  }
+
+  // 2. Check localStorage ('pplx-last-active-account')
+  try {
+    const localAcc = window.localStorage?.getItem("pplx-last-active-account");
+    if (localAcc && isUuid(localAcc)) return localAcc.trim();
+  } catch {
+    // Ignore storage errors
+  }
+
+  // 3. Scan keys in sessionStorage and localStorage for pplx account UUIDs
+  try {
+    for (const storage of [window.sessionStorage, window.localStorage]) {
+      if (!storage) continue;
+      for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (key && (key.includes("pplx") || key.includes("account"))) {
+          const val = storage.getItem(key);
+          if (val && isUuid(val)) return val.trim();
+        }
+      }
+    }
+  } catch {
+    // Ignore storage scanning errors
+  }
+
+  // 4. Check document.cookie if available
+  try {
+    const match = document.cookie?.match(
+      /(?:pplx-last-active-account|pplx-active-account)=([0-9a-f-]{36})/i,
+    );
+    if (match && isUuid(match[1])) return match[1].trim();
+  } catch {
+    // Ignore cookie errors
+  }
+
+  // 5. Fallback: query https://www.perplexity.ai/api/auth/linked-accounts using session cookies
+  try {
+    if (typeof fetch === "function") {
+      const res = await fetch(
+        "https://www.perplexity.ai/api/auth/linked-accounts",
+        {
+          method: "GET",
+          credentials: "include",
+          headers: { Accept: "application/json" },
+        },
+      );
+      if (res.ok) {
+        const data = await res.json();
+        const accountId = data?.accounts?.[0]?.user_id;
+        if (accountId && isUuid(accountId)) return accountId.trim();
+      }
+    }
+  } catch {
+    // Ignore linked-accounts network error
+  }
+
+  return null;
+}
 
 export class PerplexityParser extends ChatParser {
   name = "Perplexity";
@@ -7,7 +193,38 @@ export class PerplexityParser extends ChatParser {
     return url.includes("perplexity.ai");
   }
 
-  async parse() {
+  async fetchThread(slug) {
+    const accountId = await getPerplexityAccount();
+    const url = `https://www.perplexity.ai/rest/thread/${slug}?with_parent_info=true&with_schematized_response=true&version=2.18&source=default&limit=100&offset=0&from_first=true`;
+    const headers = {
+      Accept: "application/json",
+      "x-app-apiclient": "default",
+      "x-app-apiversion": "2.18",
+    };
+    if (accountId) {
+      headers["x-pplx-account"] = accountId;
+    }
+
+    const response = await fetch(url, {
+      method: "GET",
+      credentials: "include",
+      headers,
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Perplexity API request failed with status ${response.status}`,
+      );
+    }
+    return response.json();
+  }
+
+  async parse(options = {}) {
+    const parserMode = options.parserMode || "prefer_api";
+    const currentUrl =
+      typeof window !== "undefined" && window.location
+        ? window.location.href || ""
+        : "";
+
     const rawTitle =
       document.querySelector(".share-title-section h1")?.textContent ||
       document.querySelector("h1")?.textContent ||
@@ -15,6 +232,25 @@ export class PerplexityParser extends ChatParser {
       "Perplexity Search";
     const title = rawTitle.trim().replace(/\s+/g, " ");
 
+    // 1. Attempt API-first extraction when in prefer_api mode
+    if (parserMode !== "prefer_dom") {
+      const slug = getThreadSlug(currentUrl);
+      if (slug) {
+        try {
+          const apiData = await this.fetchThread(slug);
+          if (apiData && (apiData.entries?.length || apiData.first_entry)) {
+            return formatApiResult(apiData, currentUrl, title);
+          }
+        } catch (err) {
+          console.warn(
+            "[AI Exporter] Perplexity API fetch failed, falling back to DOM:",
+            err,
+          );
+        }
+      }
+    }
+
+    // 2. DOM extraction fallback
     const messages = [];
 
     // Perplexity Container
@@ -23,6 +259,7 @@ export class PerplexityParser extends ChatParser {
 
     // Candidates for User Messages
     const userSelectors = [
+      ".group\\/user-bubble",
       "h1.group\\/query",
       ".group\\/query",
       ".whitespace-pre-line.text-pretty",
@@ -40,43 +277,58 @@ export class PerplexityParser extends ChatParser {
     const elements = threadContainer.querySelectorAll(selectorString);
 
     // Helper to determine role
-    const getRole = (el) => {
+    const isUser = (el) => {
       for (const s of userSelectors) {
-        if (el.matches(s)) return "User";
+        if (el.matches(s)) return true;
       }
+      return false;
+    };
+
+    const isAssistant = (el) => {
       for (const s of assistantSelectors) {
-        if (el.matches(s)) return "Perplexity";
+        if (el.matches(s)) return true;
       }
-      return "Unknown";
+      return false;
     };
 
-    const seenText = new Set();
-
     elements.forEach((el) => {
-      // Perplexity nests things. Avoid duplicates if we selected a parent and a child.
-      // Also avoid "Related" section queries if possible (usually separate container, check parents?)
-
       // Check if inside "related" or "sources"
       if (el.closest('[class*="related"], [class*="sources"]')) return;
 
-      const role = getRole(el);
-      let text = convertToMarkdown(el);
-      text = text.trim();
+      if (isUser(el)) {
+        if (el.parentElement?.closest(".group\\/user-bubble, .group\\/query")) {
+          return;
+        }
+
+        // Extract timestamp if present in bubble
+        const timeEl = el.querySelector(
+          ".text-tertiary, [class*='text-tertiary']",
+        );
+        const timestamp = timeEl ? timeEl.textContent.trim() : undefined;
 
-      if (!text || seenText.has(text)) return;
+        // Clean user text container
+        const textEl = el.querySelector(".whitespace-pre-line") || el;
+        const text = convertToMarkdown(textEl).trim();
+        if (!text) return;
 
-      // Perplexity specific cleanup
-      // Remove "Sources" label text if it gets captured?
-      // Usually .prose contains the markdown answer.
+        const msgObj = { role: "User", content: text };
+        if (timestamp) {
+          msgObj.timestamp = timestamp;
+        }
+        messages.push(msgObj);
+      } else if (isAssistant(el)) {
+        // Avoid duplicate nested assistant containers (e.g. .prose inside div[id^="markdown-content-"])
+        if (el.parentElement?.closest('div[id^="markdown-content-"], .prose')) {
+          return;
+        }
 
-      seenText.add(text);
-      messages.push({ role, content: text });
+        const text = convertToMarkdown(el).trim();
+        if (!text) return;
+
+        messages.push({ role: "Perplexity", content: text });
+      }
     });
 
-    const currentUrl =
-      typeof window !== "undefined" && window.location
-        ? window.location.href || ""
-        : "";
     const metadata = {
       Source: "Perplexity",
       Date: new Date().toLocaleString(),

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "decant-core",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "Shared AI chat platform parsers and detection for Covai browser extensions.",
   "type": "module",
+  "engines": {
+    "node": ">=26.0.0"
+  },
   "main": "ai/index.js",
   "exports": {
     ".": "./ai/index.js",