decant-core 1.0.0

package/ai/notebooklm.js

@@ -0,0 +1,140 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class NotebookLMParser extends ChatParser {
+  name = 'NotebookLM';
+  isAvailable(url) {
+    return url.includes('notebooklm.google.com') || url.includes('notebook.google.com');
+  }
+
+  async parse() {
+    let title = '';
+
+    // Title extraction
+    const titleEl = document.querySelector(
+      '.title-container .title, .notebook-title-input, input[aria-label*="title" i], h1.notebook-title',
+    );
+    if (titleEl) {
+      title = (titleEl.value || titleEl.textContent || '').trim();
+    }
+    if (!title) {
+      title = (document.title || 'Gemini Notebook')
+        .replace(/\s*-\s*(Gemini Notebook|NotebookLM)$/i, '')
+        .trim();
+    }
+    title = title || 'NotebookLM Conversation';
+
+    const messages = [];
+
+    // Selectors for turn pairs or individual message cards in NotebookLM
+    const messagePairs = Array.from(
+      document.querySelectorAll('.chat-message-pair, chat-message, .message-pair-container'),
+    );
+
+    // Filter to top-level containers
+    const topContainers = messagePairs.filter(
+      (el) => !messagePairs.some((parent) => parent !== el && parent.contains(el)),
+    );
+
+    if (topContainers.length > 0) {
+      topContainers.forEach((pair) => {
+        // User message
+        const userContainer = pair.querySelector(
+          '.from-user-container, .from-user-message-card-content',
+        );
+
+        // Model / Assistant response
+        const aiContainer = pair.querySelector(
+          '.to-user-container, .to-user-message-inner-content, labs-tailwind-doc-viewer',
+        );
+
+        if (userContainer) {
+          const contentEl =
+            userContainer.querySelector(
+              '.message-text-content, .md3-body-text, .from-user-message-inner-content',
+            ) || userContainer;
+
+          const clone = contentEl.cloneNode(true);
+          // Clean up noise buttons & icons
+          clone
+            .querySelectorAll('button, mat-icon, .mat-mdc-button-touch-target')
+            .forEach((el) => el.remove());
+
+          const userText = convertToMarkdown(clone).trim();
+          if (userText) {
+            messages.push({ role: 'User', content: userText });
+          }
+        }
+
+        if (aiContainer) {
+          const contentEl =
+            aiContainer.querySelector(
+              'labs-tailwind-doc-viewer, .message-text-content, .to-user-message-inner-content',
+            ) || aiContainer;
+
+          const clone = contentEl.cloneNode(true);
+          // Format citation markers (e.g., button.citation-marker -> <span class="citation-ref">[1]</span>)
+          clone.querySelectorAll('button.citation-marker').forEach((btn) => {
+            const citeNum = btn.textContent.trim();
+            if (citeNum && typeof document !== 'undefined') {
+              const spanNode = document.createElement('span');
+              spanNode.className = 'citation-ref';
+              spanNode.textContent = ` [${citeNum}]`;
+              btn.replaceWith(spanNode);
+            }
+          });
+
+          // Clean up other UI noise (thumbs up/down, action buttons)
+          clone
+            .querySelectorAll('button, mat-icon, .mat-mdc-button-touch-target, .feedback-actions')
+            .forEach((el) => el.remove());
+
+          const aiText = convertToMarkdown(clone).trim();
+          if (aiText) {
+            messages.push({ role: 'NotebookLM', content: aiText });
+          }
+        }
+      });
+    }
+
+    // Direct fallback if topContainers loop yielded no messages
+    if (messages.length === 0) {
+      const userContainers = Array.from(document.querySelectorAll('.from-user-container'));
+      const aiContainers = Array.from(document.querySelectorAll('.to-user-container'));
+
+      const maxLen = Math.max(userContainers.length, aiContainers.length);
+      for (let i = 0; i < maxLen; i++) {
+        if (userContainers[i]) {
+          const text = convertToMarkdown(userContainers[i]).trim();
+          if (text) messages.push({ role: 'User', content: text });
+        }
+        if (aiContainers[i]) {
+          const clone = aiContainers[i].cloneNode(true);
+          clone.querySelectorAll('button.citation-marker').forEach((btn) => {
+            const citeNum = btn.textContent.trim();
+            if (citeNum && typeof document !== 'undefined') {
+              const spanNode = document.createElement('span');
+              spanNode.className = 'citation-ref';
+              spanNode.textContent = ` [${citeNum}]`;
+              btn.replaceWith(spanNode);
+            }
+          });
+          clone.querySelectorAll('button, mat-icon').forEach((el) => el.remove());
+
+          const text = convertToMarkdown(clone).trim();
+          if (text) messages.push({ role: 'NotebookLM', content: text });
+        }
+      }
+    }
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'NotebookLM',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/perplexity.js

@@ -0,0 +1,85 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class PerplexityParser extends ChatParser {
+  name = 'Perplexity';
+  isAvailable(url) {
+    return url.includes('perplexity.ai');
+  }
+
+  async parse() {
+    const rawTitle =
+      document.querySelector('.share-title-section h1')?.textContent ||
+      document.querySelector('h1')?.textContent ||
+      document.title ||
+      'Perplexity Search';
+    const title = rawTitle.trim().replace(/\s+/g, ' ');
+
+    const messages = [];
+
+    // Perplexity Container
+    const threadContainer = document.querySelector('.max-w-threadContentWidth') || document.body;
+
+    // Candidates for User Messages
+    const userSelectors = [
+      'h1.group\\/query',
+      '.group\\/query',
+      '.whitespace-pre-line.text-pretty',
+      '[data-testid="search-bar-input"]', // fallback for input? typically input is not the message display
+    ];
+
+    // Candidates for Assistant Messages
+    const assistantSelectors = ['div[id^="markdown-content-"]', '.prose'];
+
+    // Strategy: Iterate children of thread container or find all matches in document
+    // Thread container is better to preserve order
+
+    // Let's select all potential message blocks within the thread container
+    const selectorString = [...userSelectors, ...assistantSelectors].join(', ');
+    const elements = threadContainer.querySelectorAll(selectorString);
+
+    // Helper to determine role
+    const getRole = (el) => {
+      for (const s of userSelectors) {
+        if (el.matches(s)) return 'User';
+      }
+      for (const s of assistantSelectors) {
+        if (el.matches(s)) return 'Perplexity';
+      }
+      return 'Unknown';
+    };
+
+    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 (!text || seenText.has(text)) return;
+
+      // Perplexity specific cleanup
+      // Remove "Sources" label text if it gets captured?
+      // Usually .prose contains the markdown answer.
+
+      seenText.add(text);
+      messages.push({ role, content: text });
+    });
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Perplexity',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/qwen.js

@@ -0,0 +1,101 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class QwenParser extends ChatParser {
+  name = 'Qwen';
+  isAvailable(url) {
+    return url.includes('qwen.ai');
+  }
+
+  async parse() {
+    // Try to get the actual chat title from multiple possible selectors
+    const titleSelectors = [
+      '.chat-item-drag-link-content-tip-text',
+      '.ant-tooltip-inner',
+      'input[placeholder*="title"]',
+      '.chat-title',
+      'h1',
+      'title',
+    ];
+
+    let title = 'Qwen Chat';
+    for (const selector of titleSelectors) {
+      const element = document.querySelector(selector);
+      if (element) {
+        const text = element.textContent || element.value || element.innerText;
+        if (text && text.trim() && text !== document.title) {
+          title = text.trim();
+          break;
+        }
+      }
+    }
+
+    const messages = [];
+
+    // chat.qwen.ai uses specific class names
+    const chatMessages = document.querySelectorAll('.qwen-chat-message');
+
+    chatMessages.forEach((message) => {
+      const isUser = message.classList.contains('qwen-chat-message-user');
+      const role = isUser ? 'User' : 'Qwen';
+
+      let content = '';
+      let attachments = [];
+
+      if (isUser) {
+        // Extract attachments first
+        const fileItems = message.querySelectorAll('.index-module__file-message-document___OjWnc');
+        fileItems.forEach((item) => {
+          const fileNameEl = item.querySelector('.fileitem-file-name-text');
+          const fileExtEl = item.querySelector('.fileitem-file-name-ext');
+          const fileSizeEl = item.querySelector('.fileitem-file-size span');
+
+          if (fileNameEl && fileExtEl) {
+            const fileName = fileNameEl.textContent.trim();
+            const fileExt = fileExtEl.textContent.trim();
+            const fileSize = fileSizeEl ? fileSizeEl.textContent.trim() : '';
+
+            attachments.push({
+              name: fileName + fileExt,
+              size: fileSize,
+            });
+          }
+        });
+
+        // User messages are in .user-message-content
+        const userContent = message.querySelector('.user-message-content');
+        if (userContent) {
+          content = convertToMarkdown(userContent);
+        }
+      } else {
+        // Assistant messages are in .qwen-markdown elements
+        const markdownContent = message.querySelector('.qwen-markdown');
+        if (markdownContent) {
+          content = convertToMarkdown(markdownContent);
+        }
+      }
+
+      // Add attachments to content if any exist
+      if (attachments.length > 0) {
+        const attachmentList = attachments
+          .map((att) => `- **${att.name}** (${att.size})`)
+          .join('\n');
+        content = content + '\n\n**Attachments:**\n' + attachmentList;
+      }
+
+      if (content && content.trim()) {
+        messages.push({ role, content: content.trim() });
+      }
+    });
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Qwen',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/z_ai.js

@@ -0,0 +1,101 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class ZAiParser extends ChatParser {
+  name = 'Z.ai';
+  isAvailable(url) {
+    return url.includes('chat.z.ai');
+  }
+
+  async parse() {
+    let title = '';
+    const titleEl = document.querySelector('title');
+    if (titleEl) {
+      title = titleEl.textContent.trim().replace(/\s+/g, ' ');
+    }
+    if (!title && document.title) {
+      title = document.title.trim().replace(/\s+/g, ' ');
+    }
+    title = title || 'Z.ai Chat';
+    const messages = [];
+
+    // Selectors for z.ai messages
+    const userSelector = '.chat-user';
+    const assistantSelector = '.chat-assistant';
+
+    // We'll traverse the DOM to find these in order
+    const allElements = document.querySelectorAll(`${userSelector}, ${assistantSelector}`);
+
+    allElements.forEach((el) => {
+      let role = 'Unknown';
+      let contentEl = null;
+
+      if (el.matches(userSelector)) {
+        role = 'User';
+        // Select user message text block (excluding edit/copy buttons)
+        contentEl = el.querySelector('div.relative.overflow-hidden') || el;
+      } else if (el.matches(assistantSelector)) {
+        role = 'Z.ai';
+        // Select assistant message content wrapper (excluding copy/regenerate buttons)
+        const rawContentEl =
+          el.querySelector('#response-content-container') ||
+          el.querySelector('.markdown-prose') ||
+          el;
+        const contentElClone = rawContentEl.cloneNode(true);
+
+        // Preprocess CodeMirror 6 code blocks into standard HTML <pre><code> structures
+        contentElClone.querySelectorAll('.cm-editor').forEach((cmEditor) => {
+          // Detect language from class names of the parent language container
+          const languageWrapper = cmEditor.closest('[class*="language-"]');
+          let language = '';
+          if (languageWrapper) {
+            const classList = Array.from(languageWrapper.classList);
+            const langClass = classList.find((cls) => cls.startsWith('language-'));
+            if (langClass) {
+              language = langClass.replace('language-', '');
+            }
+          }
+
+          // Extract the lines from CodeMirror editor view
+          const lines = Array.from(cmEditor.querySelectorAll('.cm-line'));
+          const codeText = lines.map((line) => line.textContent).join('\n');
+
+          // Create new pre and code tags using the clone's owner document context
+          const ownerDoc = cmEditor.ownerDocument || document;
+          const pre = ownerDoc.createElement('pre');
+          const code = ownerDoc.createElement('code');
+          if (language) {
+            code.className = `language-${language}`;
+          }
+          code.textContent = codeText;
+          pre.appendChild(code);
+
+          // Replace the enclosing language wrapper or cm-editor with the pre element
+          const targetToReplace = languageWrapper || cmEditor;
+          if (targetToReplace && targetToReplace.parentNode) {
+            targetToReplace.parentNode.replaceChild(pre, targetToReplace);
+          }
+        });
+
+        contentEl = contentElClone;
+      }
+
+      if (contentEl) {
+        const text = convertToMarkdown(contentEl);
+        if (text.trim()) {
+          messages.push({ role, content: text.trim() });
+        }
+      }
+    });
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Z.ai',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/detection/detect-platform.js

@@ -0,0 +1,100 @@
+import { AI_CHAT_DOMAINS, URL_PATTERNS } from './domains.js';
+import { ChatGPTParser } from '../ai/chatgpt.js';
+import { ClaudeParser } from '../ai/claude.js';
+import { GeminiParser } from '../ai/gemini.js';
+import { CopilotParser } from '../ai/copilot.js';
+import { DeepSeekParser } from '../ai/deepseek.js';
+import { MetaParser } from '../ai/meta.js';
+import { MistralParser } from '../ai/mistral.js';
+import { PerplexityParser } from '../ai/perplexity.js';
+import { QwenParser } from '../ai/qwen.js';
+import { LumoParser } from '../ai/lumo.js';
+import { ZAiParser } from '../ai/z_ai.js';
+import { GoogleAIStudioParser } from '../ai/google_ai_studio.js';
+import { NotebookLMParser } from '../ai/notebooklm.js';
+import { GoogleSearchAIParser } from '../ai/google_search_ai.js';
+import { GeminiCloudAssistParser } from '../ai/gemini_cloud_assist.js';
+
+/**
+ * Ordered list of parsers. First match wins.
+ * The order roughly reflects platform popularity / specificity.
+ */
+export const parsers = [
+  new ChatGPTParser(),
+  new ClaudeParser(),
+  new GeminiParser(),
+  new CopilotParser(),
+  new PerplexityParser(),
+  new DeepSeekParser(),
+  new QwenParser(),
+  new MetaParser(),
+  new MistralParser(),
+  new LumoParser(),
+  new ZAiParser(),
+  new GoogleAIStudioParser(),
+  new NotebookLMParser(),
+  new GoogleSearchAIParser(),
+  new GeminiCloudAssistParser(),
+];
+
+/**
+ * Detect whether a URL belongs to a known AI chat platform.
+ *
+ * @param {string} url
+ * @returns {{ type: 'ai-chat', platform: string, parser: import('../ai/base.js').ChatParser } | null}
+ */
+export function detectPlatform(url) {
+  if (!url) return null;
+
+  // Try simple domain matching first
+  try {
+    const parsed = new URL(url);
+    const hostname = parsed.hostname.toLowerCase();
+    const domainMatch = AI_CHAT_DOMAINS.some(
+      (domain) => hostname === domain || hostname.endsWith(`.${domain}`),
+    );
+    if (domainMatch) {
+      const parser = parsers.find((p) => p.isAvailable(url));
+      if (parser) {
+        return { type: 'ai-chat', platform: parser.getPlatformName(), parser };
+      }
+    }
+  } catch {
+    // Invalid URL
+  }
+
+  // Try regex / complex URL patterns
+  for (const pattern of URL_PATTERNS) {
+    if (pattern.test(url)) {
+      const parser = parsers.find((p) => p.isAvailable(url));
+      if (parser) {
+        return { type: 'ai-chat', platform: parser.getPlatformName(), parser };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Quick check: is this URL an AI chat page?
+ * Faster than detectPlatform() when you only need a boolean.
+ *
+ * @param {string} url
+ * @returns {boolean}
+ */
+export function isAiChatUrl(url) {
+  if (!url) return false;
+
+  try {
+    const parsed = new URL(url);
+    const hostname = parsed.hostname.toLowerCase();
+    if (AI_CHAT_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+
+  return URL_PATTERNS.some((pattern) => pattern.test(url));
+}

package/detection/domains.js

@@ -0,0 +1,45 @@
+/**
+ * AI chat platform domain definitions.
+ * Centralised so detection logic and UI (e.g. Decant's tip banner) share the same list.
+ */
+
+export const AI_CHAT_DOMAINS = [
+  'chatgpt.com',
+  'claude.ai',
+  'gemini.google.com',
+  'chat.deepseek.com',
+  'perplexity.ai',
+  'chat.qwen.ai',
+  'qwen.ai',
+  'chat.mistral.ai',
+  'copilot.microsoft.com',
+  'lumo.proton.me',
+  'meta.ai',
+  'aistudio.google.com',
+  'notebooklm.google.com',
+  'notebook.google.com',
+  'chat.z.ai',
+];
+
+/**
+ * Additional URL patterns that don't fit simple domain matching.
+ * Each entry: { test: (url) => boolean, platform: string }
+ */
+export const URL_PATTERNS = [
+  {
+    test: (url) => url.includes('copilot.microsoft.com') || url.includes('copilot.com') ||
+      url.includes('copilot.cloud.microsoft') || url.includes('m365.cloud.microsoft') ||
+      url.includes('m365.microsoft.com') || url.includes('bing.com/chat') ||
+      url.includes('bing.com/copilot') || url.includes('bing.com/copilotsearch') ||
+      url.includes('edgeservices.bing.com'),
+    platform: 'copilot',
+  },
+  {
+    test: (url) => /google\.[a-z.]+\/search/.test(url),
+    platform: 'google-search-ai',
+  },
+  {
+    test: (url) => url.includes('console.cloud.google.com/gemini'),
+    platform: 'gemini-cloud-assist',
+  },
+];