decant-core 1.0.0

package/ai/gemini_cloud_assist.js

@@ -0,0 +1,91 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class GeminiCloudAssistParser extends ChatParser {
+  name = 'Gemini Cloud Assist';
+  isAvailable(url) {
+    return url.includes('console.cloud.google.com/gemini');
+  }
+
+  async parse() {
+    const activeItem = document.querySelector(
+      'mat-list-item.mdc-list-item--activated span.cfc-flex-grow-content',
+    );
+    let title = activeItem?.textContent?.trim() || '';
+
+    // Fallback if no active item
+    if (!title) {
+      const firstUserMsg = document.querySelector('.aic-user-message-text')?.textContent?.trim();
+      if (firstUserMsg) {
+        title = firstUserMsg.length > 50 ? firstUserMsg.substring(0, 50) + '...' : firstUserMsg;
+      }
+    }
+
+    if (!title) {
+      title = document.title || 'Gemini Cloud Assist';
+    }
+
+    // Clean up title whitespace
+    title = title.replace(/\s+/g, ' ').trim();
+
+    const messages = [];
+
+    // Find all turns inside aic-conversation or standard turn containers
+    const turns = document.querySelectorAll('aic-conversation .aic-turn, .aic-turn');
+
+    turns.forEach((turn) => {
+      // 1. Process user message
+      const userEl = turn.querySelector('.aic-user-message');
+      if (userEl) {
+        const textEl = userEl.querySelector('.aic-user-message-text') || userEl;
+        let text = convertToMarkdown(textEl).trim();
+        if (text) {
+          messages.push({
+            role: 'User',
+            content: text,
+          });
+        }
+      }
+
+      // 2. Process assistant message
+      const agentEl = turn.querySelector('aic-agent-entry');
+      if (agentEl) {
+        // Prefer the actual markdown renderer content if present, to avoid feedback actions/buttons noise
+        const markdownEl =
+          agentEl.querySelector('.ai-markdown-artifact-renderer') ||
+          agentEl.querySelector('.aic-markdown-renderer-container') ||
+          agentEl.querySelector('.aic-agent-content') ||
+          agentEl;
+
+        // Clone the element to safely strip unwanted components
+        const clone = markdownEl.cloneNode(true);
+        // Remove thumb up/down feedback buttons or loader/expander elements
+        clone
+          .querySelectorAll(
+            'button, aic-feedback-actions, .aic-agent-thoughts-container, aic-loading-indicator',
+          )
+          .forEach((el) => {
+            el.remove();
+          });
+
+        let text = convertToMarkdown(clone).trim();
+        if (text) {
+          messages.push({
+            role: 'Model',
+            content: text,
+          });
+        }
+      }
+    });
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Gemini Cloud Assist',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/google_ai_studio.js

@@ -0,0 +1,116 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class GoogleAIStudioParser extends ChatParser {
+  name = 'Google AI Studio';
+  isAvailable(url) {
+    return url.includes('aistudio.google.com');
+  }
+
+  async parse() {
+    let title = '';
+
+    // Title extraction strategies
+    const titleInput = document.querySelector(
+      'input[aria-label*="prompt name" i], input[aria-label*="title" i], .prompt-title',
+    );
+    if (titleInput && titleInput.value) {
+      title = titleInput.value.trim();
+    }
+    if (!title) {
+      const headerTitle = document.querySelector('.title-text, h1, .prompt-name');
+      if (headerTitle) {
+        title = headerTitle.textContent.trim();
+      }
+    }
+    if (!title) {
+      title = document.title || 'Google AI Studio Chat';
+    }
+    title = title.replace(/\s+/g, ' ').trim();
+
+    const messages = [];
+
+    // Selectors for chat turns
+    const allTurnElements = Array.from(
+      document.querySelectorAll('ms-chat-turn, .chat-turn-container, ms-prompt-editor'),
+    );
+
+    // Filter to top-level turn elements only (avoiding child elements nested in parent turn containers)
+    const turnElements = allTurnElements.filter(
+      (el) => !allTurnElements.some((parent) => parent !== el && parent.contains(el)),
+    );
+
+    if (turnElements.length > 0) {
+      turnElements.forEach((turn) => {
+        // User prompt element
+        const userEl =
+          turn.querySelector('.user-prompt, .user-prompt-container, .user-message') ||
+          (turn.tagName === 'MS-PROMPT-EDITOR' ? turn : null);
+
+        // Model output element
+        const aiEl = turn.querySelector(
+          '.model-response-text, .model-output, ms-model-output, .model-prompt-container',
+        );
+
+        if (userEl) {
+          const contentEl = userEl.querySelector('.turn-content, .prompt-text, textarea') || userEl;
+          let text;
+          if (contentEl.tagName === 'TEXTAREA') {
+            text = contentEl.value || contentEl.textContent || '';
+          } else {
+            text = convertToMarkdown(contentEl);
+          }
+          text = text.trim();
+          if (text) {
+            messages.push({ role: 'User', content: text });
+          }
+        }
+
+        if (aiEl) {
+          const clone = aiEl.cloneNode(true);
+          // Remove noise elements like copy buttons or action menus
+          clone
+            .querySelectorAll(
+              'button, .mat-expansion-panel-header, .author-label, .timestamp, ms-prompt-options-menu, .navigator-container',
+            )
+            .forEach((el) => el.remove());
+
+          let text = convertToMarkdown(clone).trim();
+          if (text && text !== 'Thinking...' && !text.includes('model_thought_output')) {
+            messages.push({ role: 'Google AI Studio', content: text });
+          }
+        }
+      });
+    }
+
+    // Fallback if turnElements linear loop yielded no messages
+    if (messages.length === 0) {
+      const userPrompts = document.querySelectorAll('.user-prompt, .user-prompt-container');
+      const modelOutputs = document.querySelectorAll(
+        '.model-response-text, ms-model-output, .model-output',
+      );
+
+      const maxLen = Math.max(userPrompts.length, modelOutputs.length);
+      for (let i = 0; i < maxLen; i++) {
+        if (userPrompts[i]) {
+          const text = (userPrompts[i].value || convertToMarkdown(userPrompts[i])).trim();
+          if (text) messages.push({ role: 'User', content: text });
+        }
+        if (modelOutputs[i]) {
+          const text = convertToMarkdown(modelOutputs[i]).trim();
+          if (text) messages.push({ role: 'Google AI Studio', content: text });
+        }
+      }
+    }
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Google AI Studio',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/google_search_ai.js

@@ -0,0 +1,114 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class GoogleSearchAIParser extends ChatParser {
+  name = 'Google Search AI';
+  isAvailable(url) {
+    return /google\.[a-z.]+\/search/.test(url);
+  }
+
+  async parse() {
+    const title = document.title || 'Google Search AI Overview';
+    const messages = [];
+
+    // 1. Extract the user's queries
+    const queries = [];
+    const queryElements = document.querySelectorAll('.sUKAcb');
+    queryElements.forEach((el) => {
+      // Clone the element to avoid mutating the live DOM
+      const clone = el.cloneNode(true);
+      const prefixEl = clone.querySelector('.iMqumd');
+      if (prefixEl) {
+        prefixEl.remove();
+      }
+      let text = clone.textContent || '';
+      // Fallback regex cleanup if needed
+      text = text.replace(/^\s*You\s+said:\s*/i, '').trim();
+      if (text) {
+        queries.push(text);
+      }
+    });
+
+    // Fallback to single-turn query extraction if no turn query elements are found
+    if (queries.length === 0) {
+      let userQuery = '';
+      const uqEl = document.querySelector('[data-uq]');
+      if (uqEl) {
+        userQuery = uqEl.getAttribute('data-uq');
+      }
+      if (!userQuery) {
+        const qEl = document.querySelector('[data-q]');
+        if (qEl) {
+          userQuery = qEl.getAttribute('data-q');
+        }
+      }
+      if (!userQuery) {
+        try {
+          const url = new URL(window.location.href);
+          userQuery = url.searchParams.get('q');
+        } catch {
+          // Ignore invalid URLs
+        }
+      }
+      if (!userQuery) {
+        const textarea =
+          document.querySelector('textarea.gLFyf') ||
+          document.querySelector('textarea.ITIRGe') ||
+          document.querySelector('input[name="q"]');
+        if (textarea) {
+          userQuery = textarea.value || textarea.textContent;
+        }
+      }
+      if (userQuery) {
+        queries.push(userQuery.trim());
+      }
+    }
+
+    // 2. Extract SGE / AI Overview responses
+    const responseContainers = [];
+    const turnElements = document.querySelectorAll('[data-scope-id="turn"]');
+    if (turnElements.length > 0) {
+      turnElements.forEach((turnEl) => {
+        const resEl =
+          turnEl.querySelector('[data-container-id="main-col"]') ||
+          turnEl.querySelector('[data-container-id="model-response-placeholder"]');
+        if (resEl) {
+          responseContainers.push(resEl);
+        }
+      });
+    } else {
+      // Fallback for pages without data-scope-id="turn"
+      const resEl =
+        document.querySelector('[data-container-id="main-col"]') ||
+        document.querySelector('[data-container-id="model-response-placeholder"]');
+      if (resEl) {
+        responseContainers.push(resEl);
+      }
+    }
+
+    // Pair queries and responses in order
+    const minLength = Math.min(queries.length, responseContainers.length);
+    for (let i = 0; i < minLength; i++) {
+      messages.push({ role: 'User', content: queries[i].trim() });
+      const text = convertToMarkdown(responseContainers[i]);
+      if (text.trim()) {
+        messages.push({ role: 'Model', content: text.trim() });
+      }
+    }
+
+    // If there is a trailing user query with no response container (yet)
+    if (queries.length > responseContainers.length) {
+      messages.push({ role: 'User', content: queries[queries.length - 1].trim() });
+    }
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Google Search AI',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/index.js

@@ -0,0 +1,34 @@
+/**
+ * @covai/parser-core — barrel export.
+ *
+ * Usage:
+ *   import { ChatGPTParser, detectPlatform } from '@covai/parser-core';
+ *   import { isAiChatUrl, AI_CHAT_DOMAINS } from '@covai/parser-core';
+ */
+
+// Base class
+export { ChatParser } from './base.js';
+
+// Individual parsers
+export { ChatGPTParser } from './chatgpt.js';
+export { ClaudeParser } from './claude.js';
+export { GeminiParser } from './gemini.js';
+export { CopilotParser } from './copilot.js';
+export { DeepSeekParser } from './deepseek.js';
+export { MetaParser } from './meta.js';
+export { MistralParser } from './mistral.js';
+export { PerplexityParser } from './perplexity.js';
+export { QwenParser } from './qwen.js';
+export { LumoParser } from './lumo.js';
+export { ZAiParser } from './z_ai.js';
+export { GoogleAIStudioParser } from './google_ai_studio.js';
+export { NotebookLMParser } from './notebooklm.js';
+export { GoogleSearchAIParser } from './google_search_ai.js';
+export { GeminiCloudAssistParser } from './gemini_cloud_assist.js';
+
+// Utilities
+export { convertToMarkdown, cleanMarkdown } from '../utils/html-to-markdown.js';
+
+// Detection
+export { detectPlatform, isAiChatUrl, parsers } from '../detection/detect-platform.js';
+export { AI_CHAT_DOMAINS } from '../detection/domains.js';

package/ai/lumo.js

@@ -0,0 +1,101 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class LumoParser extends ChatParser {
+  name = 'Lumo';
+  isAvailable(url) {
+    return url.includes('lumo.proton.me');
+  }
+
+  async parse() {
+    // Extract Title
+    let title = '';
+    const titleBtn = document.querySelector('.conversation-header-title-view button');
+    if (titleBtn && titleBtn.textContent) {
+      title = titleBtn.textContent.trim();
+    } else if (document.title) {
+      title = document.title.replace(/\s*-\s*Lumo.*$/i, '').trim();
+    }
+    title = title || 'Lumo Conversation';
+
+    const messages = [];
+    const messageElements = document.querySelectorAll('.lumo-chat-item[data-message-role]');
+
+    for (const el of messageElements) {
+      const roleAttr = el.getAttribute('data-message-role');
+
+      if (roleAttr === 'user') {
+        const contentEl =
+          el.querySelector('.lumo-markdown') || el.querySelector('.user-msg-container') || el;
+        const text = convertToMarkdown(contentEl);
+        if (text.trim()) {
+          messages.push({
+            role: 'User',
+            content: text.trim(),
+          });
+        }
+      } else if (roleAttr === 'assistant') {
+        const contentEl =
+          el.querySelector('.progressive-markdown-content') ||
+          el.querySelector('.assistant-msg-container') ||
+          el;
+
+        const ownerDoc = el.ownerDocument || document;
+        const contentElClone = contentEl.cloneNode(true);
+
+        // Preprocess Lumo code blocks to standard <pre><code class="language-xyz">...</code></pre>
+        contentElClone
+          .querySelectorAll('.lumo-syntax-highlighter, .lumo-code-block')
+          .forEach((codeBlock) => {
+            const codeEl = codeBlock.querySelector('code');
+            if (codeEl) {
+              let language = '';
+              const match = (codeEl.className || '').match(/language-([^\s]+)/);
+              if (match) {
+                language = match[1];
+              }
+
+              const codeText = codeEl.textContent || '';
+              const pre = ownerDoc.createElement('pre');
+              const code = ownerDoc.createElement('code');
+              if (language) {
+                code.className = `language-${language}`;
+              }
+              code.textContent = codeText;
+              pre.appendChild(code);
+
+              const parentToReplace = codeBlock.closest('.message-container') || codeBlock;
+              if (parentToReplace && parentToReplace.parentNode) {
+                parentToReplace.parentNode.replaceChild(pre, parentToReplace);
+              }
+            }
+          });
+
+        // Clean up UI toolbar and avatar elements from assistant clone
+        contentElClone
+          .querySelectorAll('.action-toolbar, .lumo-no-copy, .lumo-avatar, button')
+          .forEach((noCopy) => {
+            noCopy.remove();
+          });
+
+        const markdown = convertToMarkdown(contentElClone);
+        if (markdown.trim()) {
+          messages.push({
+            role: 'Lumo',
+            content: markdown.trim(),
+          });
+        }
+      }
+    }
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Lumo',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/meta.js

@@ -0,0 +1,110 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class MetaParser extends ChatParser {
+  name = 'Meta AI';
+  isAvailable(url) {
+    return url.includes('meta.ai');
+  }
+
+  async parse() {
+    // Try to get the conversation title from the input field or the header button
+    const titleInput = document.querySelector('input[placeholder="Conversation title"]');
+    const titleButton = document.querySelector('[data-slot="button"] span.truncate');
+    const title =
+      titleInput && titleInput.value
+        ? titleInput.value
+        : titleButton
+          ? titleButton.innerText
+          : 'Meta AI Session';
+
+    const messages = [];
+
+    // Find all possible message elements directly to avoid missing any that don't have a wrapper
+    const messageElements = Array.from(
+      document.querySelectorAll(
+        '[data-message-type="user"], [data-testid="assistant-message"], [data-message-id$="_user"], [data-message-id$="_assistant"]',
+      ),
+    );
+
+    // Keep only the outer-most elements if there are nested matches
+    const uniqueElements = messageElements.filter((el) => {
+      let parent = el.parentElement;
+      while (parent) {
+        if (messageElements.includes(parent)) {
+          return false;
+        }
+        parent = parent.parentElement;
+      }
+      return true;
+    });
+
+    uniqueElements.forEach((el) => {
+      let role = 'Unknown';
+      let content = '';
+
+      // Check if the element itself identifies as user or assistant
+      const isUser =
+        el.matches('[data-message-type="user"]') ||
+        (el.getAttribute('data-message-id') &&
+          el.getAttribute('data-message-id').endsWith('_user'));
+      const isAssistant =
+        el.matches('[data-testid="assistant-message"]') ||
+        (el.getAttribute('data-message-id') &&
+          el.getAttribute('data-message-id').endsWith('_assistant'));
+
+      if (isUser) {
+        role = 'User';
+        // User text is usually in a span with text-response class or simply pre-wrap
+        const textEl =
+          el.querySelector('[data-slot="text"].text-response') ||
+          el.querySelector('.whitespace-pre-wrap');
+        if (textEl) {
+          content = convertToMarkdown(textEl);
+        } else {
+          content = convertToMarkdown(el);
+        }
+      } else if (isAssistant) {
+        role = 'Meta AI';
+        // Assistant content is typically styled in markdown-content or prose
+        const contentEl =
+          el.querySelector('.markdown-content') ||
+          el.querySelector('.ur-markdown') ||
+          el.querySelector('.prose');
+        if (contentEl) {
+          const clone = contentEl.cloneNode(true);
+
+          // Remove noise elements (like citation pills, edit buttons, thinking status, etc)
+          const noiseSelectors = [
+            'button',
+            '.ur-citation-pill',
+            'svg',
+            '[data-testid="citation-pill"]',
+            '[data-testid="thinking-status"]',
+          ];
+          noiseSelectors.forEach((sel) => {
+            clone.querySelectorAll(sel).forEach((n) => n.remove());
+          });
+
+          content = convertToMarkdown(clone);
+        } else {
+          content = convertToMarkdown(el);
+        }
+      }
+
+      if (content) {
+        messages.push({ role, content });
+      }
+    });
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Meta AI',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}

package/ai/mistral.js

@@ -0,0 +1,57 @@
+import { ChatParser } from './base.js';
+import { convertToMarkdown } from '../utils/html-to-markdown.js';
+
+export class MistralParser extends ChatParser {
+  name = 'Mistral';
+  isAvailable(url) {
+    return url.includes('chat.mistral.ai');
+  }
+
+  async parse() {
+    // Extract Title
+    const titleElement = document.querySelector('span.truncate.text-sm');
+    let title = 'Mistral Conversation';
+    if (titleElement && titleElement.innerText) {
+      title = titleElement.innerText.trim();
+    } else if (document.title) {
+      title = document.title.replace(' - Mistral', '').trim();
+    }
+
+    const messages = [];
+    const messageElements = document.querySelectorAll('[data-message-author-role]');
+
+    for (const el of messageElements) {
+      const role = el.getAttribute('data-message-author-role');
+
+      if (role === 'user') {
+        const contentEl =
+          el.querySelector('.select-text') || el.querySelector('.whitespace-pre-wrap');
+        if (contentEl) {
+          messages.push({
+            role: 'User',
+            content: contentEl.innerText.trim(),
+          });
+        }
+      } else if (role === 'assistant') {
+        const answerEl = el.querySelector('[data-message-part-type="answer"]');
+        if (answerEl) {
+          const markdown = convertToMarkdown(answerEl.innerHTML);
+          messages.push({
+            role: 'Mistral',
+            content: markdown,
+          });
+        }
+      }
+    }
+
+    const currentUrl =
+      typeof window !== 'undefined' && window.location ? window.location.href || '' : '';
+    const metadata = {
+      Source: 'Mistral',
+      Date: new Date().toLocaleString(),
+      Link: currentUrl,
+    };
+
+    return { title, messages, url: currentUrl, metadata };
+  }
+}