decant-core 1.13.0 → 1.14.0

package/ai/claude.js

@@ -1,5 +1,6 @@
 import { ChatParser } from "./base.js";
 import { convertToMarkdown } from "../utils/html-to-markdown.js";
+import { pickTimestamp } from "../utils/timestamps.js";
 
 async function getOrganizationId() {
   try {
@@ -736,6 +737,13 @@ export class ClaudeParser extends ChatParser {
               if (thinkingStr) {
                 msgObj.thinking = thinkingStr;
               }
+              const timestamp = pickTimestamp(message, [
+                "created_at",
+                "updated_at",
+              ]);
+              if (timestamp) {
+                msgObj.timestamp = timestamp;
+              }
               messages.push(msgObj);
             }
 
@@ -760,6 +768,14 @@ export class ClaudeParser extends ChatParser {
               messages.push({
                 role: "Claude Artifact",
                 content: artContent.trim(),
+                ...(pickTimestamp(message, ["created_at", "updated_at"])
+                  ? {
+                      timestamp: pickTimestamp(message, [
+                        "created_at",
+                        "updated_at",
+                      ]),
+                    }
+                  : {}),
               });
             }
           }
@@ -912,7 +928,36 @@ export class ClaudeParser extends ChatParser {
       }
 
       if (content) {
-        messages.push({ role, content });
+        const msgObj = { role, content };
+        // Best-effort DOM timestamp. <time datetime> usually lives in the
+        // sibling MessageActions toolbar inside the same transcript row —
+        // not inside the message element itself. Scope to the closest row
+        // so we never borrow the previous/next turn's timestamp. Sparse in
+        // practice (hover-only on some turns) — absent stays absent.
+        try {
+          let timeEl =
+            typeof el.querySelector === "function"
+              ? el.querySelector("time[datetime]")
+              : null;
+          if (!timeEl && typeof el.closest === "function") {
+            // Narrow containers only: transcript-row holds one turn, so its
+            // time belongs to this message. Never fall back to broad
+            // containers like article (many turns) — wrong date is worse
+            // than no date.
+            const row = el.closest(
+              '[data-testid="transcript-row"], .group\\/message-row',
+            );
+            timeEl = row?.querySelector?.("time[datetime]") || null;
+          }
+          const datetime = timeEl?.getAttribute?.("datetime");
+          const timestamp = pickTimestamp({ datetime }, ["datetime"]);
+          if (timestamp) {
+            msgObj.timestamp = timestamp;
+          }
+        } catch {
+          // Ignore DOM timestamp lookup errors
+        }
+        messages.push(msgObj);
       }
     }
 

package/ai/deepseek.js

@@ -1,5 +1,6 @@
 import { ChatParser } from "./base.js";
 import { convertToMarkdown } from "../utils/html-to-markdown.js";
+import { normalizeTimestamp } from "../utils/timestamps.js";
 
 function getUserToken() {
   try {
@@ -120,6 +121,12 @@ async function fetchDeepSeekConversation(sessionId, token) {
       if (thinking) {
         msg.thinking = thinking;
       }
+      // Turn granularity: inserted_at is seconds-epoch, ~identical within a
+      // USER/ASSISTANT pair, so both sides share the turn's timestamp.
+      const timestamp = normalizeTimestamp(msgNode?.inserted_at);
+      if (timestamp) {
+        msg.timestamp = timestamp;
+      }
       return msg;
     })
     .filter((msg) => msg.content.length > 0);

package/ai/meta.js

@@ -1,5 +1,6 @@
 import { ChatParser } from "./base.js";
 import { convertToMarkdown } from "../utils/html-to-markdown.js";
+import { pickTimestamp } from "../utils/timestamps.js";
 
 // Observed Relay doc_ids for the conversation message list (Sept 2026).
 // These rotate when Meta redeploys the web client. The parser tries the
@@ -139,12 +140,23 @@ export function formatMetaEdges(edges) {
   });
   const messages = [];
   for (const node of nodes) {
+    // Turn granularity: user + assistant in the same turn share createdAt,
+    // so both messages carry the same timestamp (matches Perplexity pattern).
+    const timestamp = pickTimestamp(node, ["createdAt", "userCreatedAt"]);
     if (node.__typename === "UserMessage") {
       const content = extractMetaUserText(node);
-      if (content) messages.push({ role: "User", content });
+      if (content) {
+        const msg = { role: "User", content };
+        if (timestamp) msg.timestamp = timestamp;
+        messages.push(msg);
+      }
     } else if (node.__typename === "AssistantMessage") {
       const content = extractMetaAssistantText(node);
-      if (content) messages.push({ role: "Meta AI", content });
+      if (content) {
+        const msg = { role: "Meta AI", content };
+        if (timestamp) msg.timestamp = timestamp;
+        messages.push(msg);
+      }
     }
   }
   return messages;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decant-core",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "A shared web extraction layer for AI conversations and regular web pages.",
   "type": "module",
   "engines": {

package/utils/timestamps.js

@@ -0,0 +1,65 @@
+/**
+ * Shared per-message timestamp normalization (decant-core).
+ *
+ * Parsers attach `timestamp` as ISO strings, locale strings, or numeric
+ * epochs (seconds or milliseconds). Display layers (ace) format whatever
+ * string they receive, so this helper keeps ISO/locale strings as-is and
+ * converts numeric epochs to ISO.
+ *
+ * Turn-granularity sources (Perplexity entries, Meta edges, DeepSeek pairs)
+ * reuse the same timestamp for both prompt and response — callers pass the
+ * same value to both messages.
+ */
+
+/** Epoch values with abs < 1e11 are treated as seconds, else milliseconds. */
+export function normalizeEpochToMs(value) {
+  if (Math.abs(value) < 1e11) return value * 1000;
+  return value;
+}
+
+/**
+ * Normalizes a raw timestamp to a display-ready string.
+ * @param {unknown} value ISO string, locale string, epoch number, or numeric string.
+ * @returns {string|null} ISO string for epochs, trimmed input for date strings, else null.
+ */
+export function normalizeTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    try {
+      return new Date(normalizeEpochToMs(value)).toISOString();
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) {
+      const numeric = Number(trimmed);
+      if (Number.isFinite(numeric)) {
+        try {
+          return new Date(normalizeEpochToMs(numeric)).toISOString();
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+    return trimmed;
+  }
+  return null;
+}
+
+/**
+ * Picks the first available timestamp from candidate fields.
+ * @param {object} source Parser payload object.
+ * @param {string[]} keys Field names to try in order.
+ * @returns {string|null}
+ */
+export function pickTimestamp(source, keys) {
+  if (!source || !Array.isArray(keys)) return null;
+  for (const key of keys) {
+    const normalized = normalizeTimestamp(source[key]);
+    if (normalized) return normalized;
+  }
+  return null;
+}