mumpix 1.0.18 → 1.0.19

package/src/temporal/indexes.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const { dedupeEvents, normalizeText } = require('./operators');
+
+function addToMapSet(map, key, value) {
+  if (!key) return;
+  if (!map.has(key)) map.set(key, []);
+  map.get(key).push(value);
+}
+
+function uniqueWords(value) {
+  return Array.from(new Set(
+    normalizeText(value)
+      .split(' ')
+      .filter(Boolean)
+      .filter((token) => token.length > 2)
+  ));
+}
+
+function buildEventIndex(events) {
+  const normalized = dedupeEvents(events);
+  const keys = new Set();
+  const byId = new Map();
+  const byTitle = new Map();
+  const byAlias = new Map();
+  const byEntity = new Map();
+  const byType = new Map();
+  const byKind = new Map();
+  const byDate = new Map();
+  const byWord = new Map();
+  const byWorkspace = new Map();
+  const byRepo = new Map();
+  const bySource = new Map();
+
+  for (const event of normalized) {
+    keys.add(signatureForEvent(event));
+    if (event.event_id) byId.set(event.event_id, event);
+
+    addToMapSet(byTitle, normalizeText(event.title), event);
+    for (const alias of event.aliases || []) addToMapSet(byAlias, normalizeText(alias), event);
+    for (const entity of event.entities || []) addToMapSet(byEntity, normalizeText(entity), event);
+    addToMapSet(byType, normalizeText(event.event_type), event);
+    addToMapSet(byKind, normalizeText(event.event_kind), event);
+    if (event.event_date) addToMapSet(byDate, event.event_date, event);
+    if (event.workspace) addToMapSet(byWorkspace, normalizeText(event.workspace), event);
+    if (event.repo) addToMapSet(byRepo, normalizeText(event.repo), event);
+    if (event.source) addToMapSet(bySource, normalizeText(event.source), event);
+
+    for (const token of uniqueWords([
+      event.title,
+      (event.aliases || []).join(' '),
+      (event.entities || []).join(' '),
+      event.event_type,
+      event.event_kind,
+      event.workspace,
+      event.repo,
+      event.source,
+    ].join(' '))) {
+      addToMapSet(byWord, token, event);
+    }
+  }
+
+  return {
+    events: normalized,
+    byId,
+    byTitle,
+    byAlias,
+    byEntity,
+    byType,
+    byKind,
+    byDate,
+    byWord,
+    byWorkspace,
+    byRepo,
+    bySource,
+    _keys: keys,
+    stats: {
+      events: normalized.length,
+      titles: byTitle.size,
+      aliases: byAlias.size,
+      entities: byEntity.size,
+      types: byType.size,
+      kinds: byKind.size,
+      dates: byDate.size,
+      words: byWord.size,
+      workspaces: byWorkspace.size,
+      repos: byRepo.size,
+      sources: bySource.size,
+    },
+  };
+}
+
+function signatureForEvent(event) {
+  return [
+    event.event_type,
+    event.event_kind,
+    normalizeText(event.title),
+    event.event_date || '',
+    event.mention_date || '',
+    event.workspace || '',
+    event.repo || '',
+    event.source || '',
+    event.source_message_key || '',
+  ].join('|');
+}
+
+function appendEventIndex(index, events) {
+  const target = index || buildEventIndex([]);
+  const additions = dedupeEvents(events);
+  for (const event of additions) {
+    const key = signatureForEvent(event);
+    if (target._keys.has(key)) continue;
+    target._keys.add(key);
+    target.events.push(event);
+    if (event.event_id) target.byId.set(event.event_id, event);
+    addToMapSet(target.byTitle, normalizeText(event.title), event);
+    for (const alias of event.aliases || []) addToMapSet(target.byAlias, normalizeText(alias), event);
+    for (const entity of event.entities || []) addToMapSet(target.byEntity, normalizeText(entity), event);
+    addToMapSet(target.byType, normalizeText(event.event_type), event);
+    addToMapSet(target.byKind, normalizeText(event.event_kind), event);
+    if (event.event_date) addToMapSet(target.byDate, event.event_date, event);
+    if (event.workspace) addToMapSet(target.byWorkspace, normalizeText(event.workspace), event);
+    if (event.repo) addToMapSet(target.byRepo, normalizeText(event.repo), event);
+    if (event.source) addToMapSet(target.bySource, normalizeText(event.source), event);
+
+    for (const token of uniqueWords([
+      event.title,
+      (event.aliases || []).join(' '),
+      (event.entities || []).join(' '),
+      event.event_type,
+      event.event_kind,
+      event.workspace,
+      event.repo,
+      event.source,
+    ].join(' '))) {
+      addToMapSet(target.byWord, token, event);
+    }
+  }
+
+  target.stats = {
+    events: target.events.length,
+    titles: target.byTitle.size,
+    aliases: target.byAlias.size,
+    entities: target.byEntity.size,
+    types: target.byType.size,
+    kinds: target.byKind.size,
+    dates: target.byDate.size,
+    words: target.byWord.size,
+    workspaces: target.byWorkspace.size,
+    repos: target.byRepo.size,
+    sources: target.bySource.size,
+  };
+
+  return target;
+}
+
+function eventCandidatesForQuery(index, query) {
+  if (!index) return [];
+  const tokens = uniqueWords(query);
+  const seen = new Map();
+
+  for (const token of tokens) {
+    const matches = index.byWord.get(token) || [];
+    for (const event of matches) {
+      const key = event.event_id || `${event.title}|${event.event_date || event.mention_date || ''}`;
+      if (!seen.has(key)) seen.set(key, event);
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+module.exports = {
+  buildEventIndex,
+  appendEventIndex,
+  eventCandidatesForQuery,
+  uniqueWords,
+};

package/src/temporal/operators.js

@@ -0,0 +1,186 @@
+'use strict';
+
+// Generated by scripts/build-package.cjs from src/memory/events/operators.js
+// Do not edit this file directly in the publish tree.
+function normalizeText(value) {
+  return String(value || "")
+    .toLowerCase()
+    .replace(/["'“”‘’]/g, "")
+    .replace(/[^a-z0-9\s/.-]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function toEpochDay(isoDate) {
+  if (!isoDate) return null;
+  const ts = Date.parse(`${isoDate}T00:00:00Z`);
+  return Number.isFinite(ts) ? Math.floor(ts / 86400000) : null;
+}
+
+function normalizeEventRecord(record) {
+  const eventDate = record && record.event_date ? record.event_date : null;
+  const mentionDate = record && record.mention_date ? record.mention_date : null;
+  const observedAt = record && record.observed_at ? record.observed_at : (mentionDate || null);
+  const referencedAt = record && record.referenced_at ? record.referenced_at : (eventDate || mentionDate || null);
+  return {
+    ...record,
+    title: String(record && record.title ? record.title : "").trim(),
+    event_type: String(record && record.event_type ? record.event_type : "other").trim() || "other",
+    event_kind: String(record && (record.event_kind || record.event_type) ? (record.event_kind || record.event_type) : "other").trim() || "other",
+    aliases: Array.isArray(record && record.aliases) ? record.aliases.filter(Boolean).map(String) : [],
+    entities: Array.isArray(record && record.entities) ? record.entities.filter(Boolean).map(String) : [],
+    event_date: eventDate,
+    mention_date: mentionDate,
+    observed_at: observedAt,
+    referenced_at: referencedAt,
+    relative_offset: record && record.relative_offset ? String(record.relative_offset) : null,
+    event_phase: record && record.event_phase ? String(record.event_phase) : null,
+    time_granularity: record && record.time_granularity ? String(record.time_granularity) : "day",
+    temporal_confidence: record && typeof record.temporal_confidence === "number" ? record.temporal_confidence : null,
+    source_span: record && record.source_span ? String(record.source_span) : null,
+    epoch_day: record && typeof record.epoch_day === "number" ? record.epoch_day : toEpochDay(referencedAt),
+    date_source: record && record.date_source ? String(record.date_source) : "implicit",
+  };
+}
+
+function dedupeEvents(events) {
+  const seen = new Set();
+  const out = [];
+  for (const event of (events || []).map(normalizeEventRecord)) {
+    const key = [
+      event.event_type,
+      event.event_kind,
+      normalizeText(event.title),
+      event.event_date || "",
+      event.mention_date || "",
+    ].join("|");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(event);
+  }
+  return out;
+}
+
+function scoreEventMatch(event, anchor, options = {}) {
+  const anchorNorm = normalizeText(anchor);
+  if (!anchorNorm) return 0;
+
+  const titleNorm = normalizeText(event.title);
+  const aliasNorms = event.aliases.map(normalizeText);
+  const entityNorms = event.entities.map(normalizeText);
+  let score = 0;
+
+  if (titleNorm === anchorNorm) score += 100;
+  else if (titleNorm.includes(anchorNorm) || anchorNorm.includes(titleNorm)) score += 45;
+
+  for (const alias of aliasNorms) {
+    if (alias === anchorNorm) score += 80;
+    else if (alias.includes(anchorNorm) || anchorNorm.includes(alias)) score += 25;
+  }
+
+  for (const entity of entityNorms) {
+    if (entity === anchorNorm) score += 50;
+    else if (entity.includes(anchorNorm) || anchorNorm.includes(entity)) score += 15;
+  }
+
+  if (options.type && event.event_type === options.type) score += 15;
+  if (options.kind && event.event_kind === options.kind) score += 15;
+  if (options.semantics === "acquired" && event.event_type === "preorder") score -= 1000;
+  if (options.preferEventPhase && event.event_phase === options.preferEventPhase) score += 12;
+  if (event.event_phase === "preparation" && !/\bprepar/i.test(anchorNorm)) score -= 18;
+  if (event.event_phase === "scheduled") score += 4;
+
+  if (event.date_source === "explicit") score += 10;
+  else if (event.date_source === "derived") score += 6;
+  else if (event.date_source === "mention") score += 2;
+
+  if (typeof event.temporal_confidence === "number") {
+    score += Math.round(event.temporal_confidence * 4);
+  }
+
+  return score;
+}
+
+function resolveEvent(events, anchor, options = {}) {
+  const candidates = dedupeEvents(events).filter((event) => {
+    if (!event.title || event.epoch_day == null) return false;
+    if (options.type && event.event_type !== options.type) return false;
+    if (options.kind && event.event_kind !== options.kind) return false;
+    if (options.excludeType && event.event_type === options.excludeType) return false;
+    if (options.semantics === "acquired" && event.event_type === "preorder") return false;
+    return scoreEventMatch(event, anchor, options) > 0;
+  });
+
+  const ranked = candidates.sort((a, b) => {
+    const scoreDiff = scoreEventMatch(b, anchor, options) - scoreEventMatch(a, anchor, options);
+    if (scoreDiff !== 0) return scoreDiff;
+    if (options.preferLatest) return b.epoch_day - a.epoch_day;
+    return a.epoch_day - b.epoch_day;
+  });
+
+  return ranked[0] || null;
+}
+
+function first(events, options = {}) {
+  return dedupeEvents(events)
+    .filter((event) => event.epoch_day != null)
+    .filter((event) => !options.type || event.event_type === options.type)
+    .filter((event) => !options.kind || event.event_kind === options.kind)
+    .sort((a, b) => a.epoch_day - b.epoch_day)[0] || null;
+}
+
+function last(events, options = {}) {
+  return dedupeEvents(events)
+    .filter((event) => event.epoch_day != null)
+    .filter((event) => !options.type || event.event_type === options.type)
+    .filter((event) => !options.kind || event.event_kind === options.kind)
+    .sort((a, b) => b.epoch_day - a.epoch_day)[0] || null;
+}
+
+function firstAfter(events, query = {}) {
+  const anchor = query.anchor || first(events, { type: query.anchorType, kind: query.anchorKind });
+  if (!anchor || anchor.epoch_day == null) return null;
+
+  return dedupeEvents(events)
+    .filter((event) => event.epoch_day != null && event.epoch_day > anchor.epoch_day)
+    .filter((event) => !query.targetType || event.event_type === query.targetType)
+    .filter((event) => !query.targetKind || event.event_kind === query.targetKind)
+    .sort((a, b) => a.epoch_day - b.epoch_day)[0] || null;
+}
+
+function daysBetween(left, right) {
+  if (!left || !right || left.epoch_day == null || right.epoch_day == null) return null;
+  return Math.abs(right.epoch_day - left.epoch_day);
+}
+
+function monthsSince(event, referenceDate) {
+  if (!event || !referenceDate) return null;
+  const [yearA, monthA] = String(event.referenced_at || event.event_date || event.mention_date || "").split("-").map(Number);
+  const [yearB, monthB] = String(referenceDate).split("-").map(Number);
+  if (!yearA || !monthA || !yearB || !monthB) return null;
+  return ((yearB - yearA) * 12) + (monthB - monthA);
+}
+
+function countBefore(events, pivot, options = {}) {
+  if (!pivot || pivot.epoch_day == null) return null;
+  return dedupeEvents(events)
+    .filter((event) => event.epoch_day != null && event.epoch_day < pivot.epoch_day)
+    .filter((event) => !options.type || event.event_type === options.type)
+    .filter((event) => !options.kind || event.event_kind === options.kind)
+    .length;
+}
+
+module.exports = {
+  normalizeText,
+  toEpochDay,
+  normalizeEventRecord,
+  dedupeEvents,
+  scoreEventMatch,
+  resolveEvent,
+  first,
+  last,
+  firstAfter,
+  daysBetween,
+  monthsSince,
+  countBefore,
+};