@remnic/core 1.0.0

package/dist/chunk-UCYSTFZR.js

@@ -0,0 +1,284 @@
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+
+// src/threading.ts
+import { readdir, readFile, writeFile, mkdir } from "fs/promises";
+import path from "path";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "it",
+  "they",
+  "them",
+  "their",
+  "what",
+  "which",
+  "who",
+  "how",
+  "when",
+  "where",
+  "why",
+  "and",
+  "but",
+  "or",
+  "if",
+  "because",
+  "so",
+  "just",
+  "about",
+  "like",
+  "also",
+  "very",
+  "really",
+  "here",
+  "there"
+]);
+function extractKeywords(content, maxKeywords = 3) {
+  const words = content.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w));
+  const freq = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    freq.set(word, (freq.get(word) ?? 0) + 1);
+  }
+  return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, maxKeywords).map(([word]) => word);
+}
+function generateTitle(keywords) {
+  if (keywords.length === 0) return "Untitled Thread";
+  return keywords.map((k) => k.charAt(0).toUpperCase() + k.slice(1)).join(", ");
+}
+var ThreadingManager = class {
+  constructor(threadsDir, gapMinutes = 30) {
+    this.threadsDir = threadsDir;
+    this.gapMinutes = gapMinutes;
+  }
+  threadsDir;
+  gapMinutes;
+  currentThreadId = null;
+  lastTurnTimestamp = null;
+  lastSessionKey = null;
+  async ensureDirectory() {
+    await mkdir(this.threadsDir, { recursive: true });
+  }
+  /**
+   * Check if we should start a new thread based on session key and time gap.
+   */
+  shouldStartNewThread(turn) {
+    const turnTime = new Date(turn.timestamp).getTime();
+    if (turn.sessionKey && this.lastSessionKey && turn.sessionKey !== this.lastSessionKey) {
+      return true;
+    }
+    if (this.lastTurnTimestamp) {
+      const gapMs = turnTime - this.lastTurnTimestamp;
+      const gapMinutes = gapMs / (1e3 * 60);
+      if (gapMinutes > this.gapMinutes) {
+        return true;
+      }
+    }
+    if (!this.currentThreadId) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Process a turn and return the thread ID it belongs to.
+   * Creates a new thread if needed.
+   */
+  async processTurn(turn, episodeIds) {
+    await this.ensureDirectory();
+    const turnTime = new Date(turn.timestamp).getTime();
+    if (this.shouldStartNewThread(turn)) {
+      const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+      const thread = {
+        id: threadId,
+        title: "New Thread",
+        // Will be updated later with keywords
+        createdAt: turn.timestamp,
+        updatedAt: turn.timestamp,
+        sessionKey: turn.sessionKey,
+        episodeIds: [...episodeIds],
+        linkedThreadIds: []
+      };
+      await this.saveThread(thread);
+      this.currentThreadId = threadId;
+      log.debug(`created new thread ${threadId}`);
+    } else if (this.currentThreadId) {
+      const thread = await this.loadThread(this.currentThreadId);
+      if (thread) {
+        for (const id of episodeIds) {
+          if (!thread.episodeIds.includes(id)) {
+            thread.episodeIds.push(id);
+          }
+        }
+        thread.updatedAt = turn.timestamp;
+        await this.saveThread(thread);
+      }
+    }
+    this.lastTurnTimestamp = turnTime;
+    this.lastSessionKey = turn.sessionKey ?? null;
+    return this.currentThreadId;
+  }
+  /**
+   * Append persisted memory IDs to an existing thread.
+   * Keeps IDs unique and updates the thread timestamp.
+   */
+  async appendEpisodeIds(threadId, episodeIds) {
+    if (episodeIds.length === 0) return;
+    const thread = await this.loadThread(threadId);
+    if (!thread) return;
+    let changed = false;
+    for (const id of episodeIds) {
+      if (!thread.episodeIds.includes(id)) {
+        thread.episodeIds.push(id);
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    thread.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.saveThread(thread);
+  }
+  /**
+   * Update thread title based on accumulated content.
+   */
+  async updateThreadTitle(threadId, content) {
+    const thread = await this.loadThread(threadId);
+    if (!thread) return;
+    const keywords = extractKeywords(content);
+    const title = generateTitle(keywords);
+    if (title !== thread.title) {
+      thread.title = title;
+      thread.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.saveThread(thread);
+      log.debug(`updated thread ${threadId} title: ${title}`);
+    }
+  }
+  /**
+   * Get all threads, sorted by updatedAt desc.
+   */
+  async getAllThreads() {
+    try {
+      const files = await readdir(this.threadsDir);
+      const threads = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const thread = await this.loadThread(file.replace(".json", ""));
+        if (thread) threads.push(thread);
+      }
+      return threads.sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get a thread by ID.
+   */
+  async loadThread(threadId) {
+    const filePath = path.join(this.threadsDir, `${threadId}.json`);
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save a thread.
+   */
+  async saveThread(thread) {
+    await this.ensureDirectory();
+    const filePath = path.join(this.threadsDir, `${thread.id}.json`);
+    await writeFile(filePath, JSON.stringify(thread, null, 2), "utf-8");
+  }
+  /**
+   * Link two threads together.
+   */
+  async linkThreads(threadId1, threadId2) {
+    const thread1 = await this.loadThread(threadId1);
+    const thread2 = await this.loadThread(threadId2);
+    if (!thread1 || !thread2) return false;
+    if (!thread1.linkedThreadIds.includes(threadId2)) {
+      thread1.linkedThreadIds.push(threadId2);
+      await this.saveThread(thread1);
+    }
+    if (!thread2.linkedThreadIds.includes(threadId1)) {
+      thread2.linkedThreadIds.push(threadId1);
+      await this.saveThread(thread2);
+    }
+    return true;
+  }
+  /**
+   * Get the current thread ID (if any).
+   */
+  getCurrentThreadId() {
+    return this.currentThreadId;
+  }
+  /**
+   * Reset threading state (e.g., on plugin restart).
+   */
+  reset() {
+    this.currentThreadId = null;
+    this.lastTurnTimestamp = null;
+    this.lastSessionKey = null;
+  }
+};
+
+export {
+  ThreadingManager
+};
+//# sourceMappingURL=chunk-UCYSTFZR.js.map

package/dist/chunk-UCYSTFZR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/threading.ts"],"sourcesContent":["/**\n * Conversation Threading (Phase 3B)\n *\n * Groups related memories into conversation threads with auto-generated titles.\n * Thread boundary detection: new session key OR time gap > threshold.\n */\n\nimport { readdir, readFile, writeFile, mkdir } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { log } from \"./logger.js\";\nimport type { BufferTurn, ConversationThread } from \"./types.js\";\n\n/** Stop words for title extraction */\nconst STOP_WORDS = new Set([\n  \"a\", \"an\", \"the\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\",\n  \"have\", \"has\", \"had\", \"do\", \"does\", \"did\", \"will\", \"would\", \"could\",\n  \"should\", \"may\", \"might\", \"must\", \"shall\", \"can\", \"need\", \"to\", \"of\",\n  \"in\", \"for\", \"on\", \"with\", \"at\", \"by\", \"from\", \"as\", \"into\", \"through\",\n  \"during\", \"before\", \"after\", \"above\", \"below\", \"between\", \"this\", \"that\",\n  \"these\", \"those\", \"i\", \"me\", \"my\", \"we\", \"our\", \"you\", \"your\", \"he\",\n  \"she\", \"it\", \"they\", \"them\", \"their\", \"what\", \"which\", \"who\", \"how\",\n  \"when\", \"where\", \"why\", \"and\", \"but\", \"or\", \"if\", \"because\", \"so\",\n  \"just\", \"about\", \"like\", \"also\", \"very\", \"really\", \"here\", \"there\",\n]);\n\n/**\n * Extract top keywords from content for thread title.\n * Simple TF approach (no IDF needed for single thread).\n */\nfunction extractKeywords(content: string, maxKeywords: number = 3): string[] {\n  const words = content\n    .toLowerCase()\n    .replace(/[^a-z0-9\\s-]/g, \" \")\n    .split(/\\s+/)\n    .filter((w) => w.length >= 4 && !STOP_WORDS.has(w));\n\n  // Count frequencies\n  const freq = new Map<string, number>();\n  for (const word of words) {\n    freq.set(word, (freq.get(word) ?? 0) + 1);\n  }\n\n  // Sort by frequency, take top N\n  return [...freq.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, maxKeywords)\n    .map(([word]) => word);\n}\n\n/**\n * Generate a thread title from keywords.\n */\nfunction generateTitle(keywords: string[]): string {\n  if (keywords.length === 0) return \"Untitled Thread\";\n  // Capitalize and join\n  return keywords\n    .map((k) => k.charAt(0).toUpperCase() + k.slice(1))\n    .join(\", \");\n}\n\nexport class ThreadingManager {\n  private currentThreadId: string | null = null;\n  private lastTurnTimestamp: number | null = null;\n  private lastSessionKey: string | null = null;\n\n  constructor(\n    private readonly threadsDir: string,\n    private readonly gapMinutes: number = 30,\n  ) {}\n\n  async ensureDirectory(): Promise<void> {\n    await mkdir(this.threadsDir, { recursive: true });\n  }\n\n  /**\n   * Check if we should start a new thread based on session key and time gap.\n   */\n  shouldStartNewThread(turn: BufferTurn): boolean {\n    const turnTime = new Date(turn.timestamp).getTime();\n\n    // Different session key = new thread\n    if (turn.sessionKey && this.lastSessionKey && turn.sessionKey !== this.lastSessionKey) {\n      return true;\n    }\n\n    // Time gap > threshold = new thread\n    if (this.lastTurnTimestamp) {\n      const gapMs = turnTime - this.lastTurnTimestamp;\n      const gapMinutes = gapMs / (1000 * 60);\n      if (gapMinutes > this.gapMinutes) {\n        return true;\n      }\n    }\n\n    // No current thread = new thread\n    if (!this.currentThreadId) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Process a turn and return the thread ID it belongs to.\n   * Creates a new thread if needed.\n   */\n  async processTurn(turn: BufferTurn, episodeIds: string[]): Promise<string> {\n    await this.ensureDirectory();\n\n    const turnTime = new Date(turn.timestamp).getTime();\n\n    if (this.shouldStartNewThread(turn)) {\n      // Create new thread\n      const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;\n      const thread: ConversationThread = {\n        id: threadId,\n        title: \"New Thread\", // Will be updated later with keywords\n        createdAt: turn.timestamp,\n        updatedAt: turn.timestamp,\n        sessionKey: turn.sessionKey,\n        episodeIds: [...episodeIds],\n        linkedThreadIds: [],\n      };\n\n      await this.saveThread(thread);\n      this.currentThreadId = threadId;\n      log.debug(`created new thread ${threadId}`);\n    } else if (this.currentThreadId) {\n      // Add episodes to current thread\n      const thread = await this.loadThread(this.currentThreadId);\n      if (thread) {\n        for (const id of episodeIds) {\n          if (!thread.episodeIds.includes(id)) {\n            thread.episodeIds.push(id);\n          }\n        }\n        thread.updatedAt = turn.timestamp;\n        await this.saveThread(thread);\n      }\n    }\n\n    this.lastTurnTimestamp = turnTime;\n    this.lastSessionKey = turn.sessionKey ?? null;\n\n    return this.currentThreadId!;\n  }\n\n  /**\n   * Append persisted memory IDs to an existing thread.\n   * Keeps IDs unique and updates the thread timestamp.\n   */\n  async appendEpisodeIds(threadId: string, episodeIds: string[]): Promise<void> {\n    if (episodeIds.length === 0) return;\n    const thread = await this.loadThread(threadId);\n    if (!thread) return;\n\n    let changed = false;\n    for (const id of episodeIds) {\n      if (!thread.episodeIds.includes(id)) {\n        thread.episodeIds.push(id);\n        changed = true;\n      }\n    }\n    if (!changed) return;\n\n    thread.updatedAt = new Date().toISOString();\n    await this.saveThread(thread);\n  }\n\n  /**\n   * Update thread title based on accumulated content.\n   */\n  async updateThreadTitle(threadId: string, content: string): Promise<void> {\n    const thread = await this.loadThread(threadId);\n    if (!thread) return;\n\n    const keywords = extractKeywords(content);\n    const title = generateTitle(keywords);\n\n    if (title !== thread.title) {\n      thread.title = title;\n      thread.updatedAt = new Date().toISOString();\n      await this.saveThread(thread);\n      log.debug(`updated thread ${threadId} title: ${title}`);\n    }\n  }\n\n  /**\n   * Get all threads, sorted by updatedAt desc.\n   */\n  async getAllThreads(): Promise<ConversationThread[]> {\n    try {\n      const files = await readdir(this.threadsDir);\n      const threads: ConversationThread[] = [];\n\n      for (const file of files) {\n        if (!file.endsWith(\".json\")) continue;\n        const thread = await this.loadThread(file.replace(\".json\", \"\"));\n        if (thread) threads.push(thread);\n      }\n\n      return threads.sort(\n        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),\n      );\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Get a thread by ID.\n   */\n  async loadThread(threadId: string): Promise<ConversationThread | null> {\n    const filePath = path.join(this.threadsDir, `${threadId}.json`);\n    try {\n      const raw = await readFile(filePath, \"utf-8\");\n      return JSON.parse(raw) as ConversationThread;\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Save a thread.\n   */\n  async saveThread(thread: ConversationThread): Promise<void> {\n    await this.ensureDirectory();\n    const filePath = path.join(this.threadsDir, `${thread.id}.json`);\n    await writeFile(filePath, JSON.stringify(thread, null, 2), \"utf-8\");\n  }\n\n  /**\n   * Link two threads together.\n   */\n  async linkThreads(threadId1: string, threadId2: string): Promise<boolean> {\n    const thread1 = await this.loadThread(threadId1);\n    const thread2 = await this.loadThread(threadId2);\n\n    if (!thread1 || !thread2) return false;\n\n    // Add bidirectional links\n    if (!thread1.linkedThreadIds.includes(threadId2)) {\n      thread1.linkedThreadIds.push(threadId2);\n      await this.saveThread(thread1);\n    }\n\n    if (!thread2.linkedThreadIds.includes(threadId1)) {\n      thread2.linkedThreadIds.push(threadId1);\n      await this.saveThread(thread2);\n    }\n\n    return true;\n  }\n\n  /**\n   * Get the current thread ID (if any).\n   */\n  getCurrentThreadId(): string | null {\n    return this.currentThreadId;\n  }\n\n  /**\n   * Reset threading state (e.g., on plugin restart).\n   */\n  reset(): void {\n    this.currentThreadId = null;\n    this.lastTurnTimestamp = null;\n    this.lastSessionKey = null;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-UHGBNIOS.js

@@ -0,0 +1,205 @@
+// src/topics.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "it",
+  "they",
+  "them",
+  "their",
+  "what",
+  "which",
+  "who",
+  "how",
+  "when",
+  "where",
+  "why",
+  "and",
+  "but",
+  "or",
+  "if",
+  "because",
+  "so",
+  "just",
+  "about",
+  "like",
+  "also",
+  "very",
+  "really",
+  "here",
+  "there",
+  "now",
+  "then",
+  "only",
+  "even",
+  "still",
+  "already",
+  "always",
+  "never",
+  "often",
+  "sometimes",
+  "usually",
+  "well",
+  "much",
+  "more",
+  "most",
+  "some",
+  "any",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "many",
+  "other",
+  "same",
+  "such",
+  "own",
+  "than",
+  "too",
+  "very",
+  "just",
+  "over",
+  "under",
+  "again",
+  "further",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "user",
+  "agent",
+  "memory",
+  "fact",
+  "preference",
+  "using",
+  "used",
+  "use"
+]);
+function extractTerms(content) {
+  return content.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+}
+function extractTopics(memories, topN = 50) {
+  if (memories.length === 0) return [];
+  const docFreq = /* @__PURE__ */ new Map();
+  const termFreqPerDoc = [];
+  for (const memory of memories) {
+    const terms = extractTerms(memory.content);
+    const termFreq = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      termFreq.set(term, (termFreq.get(term) ?? 0) + 1);
+    }
+    for (const term of termFreq.keys()) {
+      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
+    }
+    termFreqPerDoc.push(termFreq);
+  }
+  const totalDocs = memories.length;
+  const tfidfScores = /* @__PURE__ */ new Map();
+  for (let i = 0; i < memories.length; i++) {
+    const termFreq = termFreqPerDoc[i];
+    const totalTerms = [...termFreq.values()].reduce((a, b) => a + b, 0);
+    for (const [term, count] of termFreq) {
+      const tf = count / totalTerms;
+      const df = docFreq.get(term) ?? 1;
+      const idf = Math.log(totalDocs / df);
+      const tfidf = tf * idf;
+      const existing = tfidfScores.get(term);
+      if (existing) {
+        existing.score += tfidf;
+        existing.count += count;
+      } else {
+        tfidfScores.set(term, { score: tfidf, count });
+      }
+    }
+  }
+  const topics = [...tfidfScores.entries()].map(([term, { score, count }]) => ({ term, score, count })).sort((a, b) => b.score - a.score).slice(0, topN);
+  return topics;
+}
+function findTrendingTopics(currentTopics, previousTopics, threshold = 0.5) {
+  const prevMap = new Map(previousTopics.map((t) => [t.term, t.score]));
+  const currMap = new Map(currentTopics.map((t) => [t.term, t.score]));
+  const rising = [];
+  const falling = [];
+  for (const topic of currentTopics) {
+    const prevScore = prevMap.get(topic.term) ?? 0;
+    const change = topic.score - prevScore;
+    if (change > threshold) {
+      rising.push({ ...topic, score: change });
+    }
+  }
+  for (const topic of previousTopics) {
+    const currScore = currMap.get(topic.term) ?? 0;
+    const change = topic.score - currScore;
+    if (change > threshold && currScore < topic.score * 0.5) {
+      falling.push({ ...topic, score: change });
+    }
+  }
+  return {
+    rising: rising.sort((a, b) => b.score - a.score).slice(0, 10),
+    falling: falling.sort((a, b) => b.score - a.score).slice(0, 10)
+  };
+}
+
+export {
+  extractTopics,
+  findTrendingTopics
+};
+//# sourceMappingURL=chunk-UHGBNIOS.js.map

package/dist/chunk-UHGBNIOS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/topics.ts"],"sourcesContent":["/**\n * Topic Extraction (Phase 4B)\n *\n * Extract key topics from all memories using TF-IDF weighting.\n * Runs as a batch process during consolidation.\n */\n\nimport type { MemoryFile, TopicScore } from \"./types.js\";\n\n/** Stop words to exclude from topic extraction */\nconst STOP_WORDS = new Set([\n  \"a\", \"an\", \"the\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\",\n  \"have\", \"has\", \"had\", \"do\", \"does\", \"did\", \"will\", \"would\", \"could\",\n  \"should\", \"may\", \"might\", \"must\", \"shall\", \"can\", \"need\", \"to\", \"of\",\n  \"in\", \"for\", \"on\", \"with\", \"at\", \"by\", \"from\", \"as\", \"into\", \"through\",\n  \"during\", \"before\", \"after\", \"above\", \"below\", \"between\", \"this\", \"that\",\n  \"these\", \"those\", \"i\", \"me\", \"my\", \"we\", \"our\", \"you\", \"your\", \"he\",\n  \"she\", \"it\", \"they\", \"them\", \"their\", \"what\", \"which\", \"who\", \"how\",\n  \"when\", \"where\", \"why\", \"and\", \"but\", \"or\", \"if\", \"because\", \"so\",\n  \"just\", \"about\", \"like\", \"also\", \"very\", \"really\", \"here\", \"there\",\n  \"now\", \"then\", \"only\", \"even\", \"still\", \"already\", \"always\", \"never\",\n  \"often\", \"sometimes\", \"usually\", \"well\", \"much\", \"more\", \"most\", \"some\",\n  \"any\", \"all\", \"each\", \"every\", \"both\", \"few\", \"many\", \"other\", \"same\",\n  \"such\", \"own\", \"than\", \"too\", \"very\", \"just\", \"over\", \"under\", \"again\",\n  \"further\", \"once\", \"here\", \"there\", \"when\", \"where\", \"why\", \"how\",\n  \"user\", \"agent\", \"memory\", \"fact\", \"preference\", \"using\", \"used\", \"use\",\n]);\n\n/**\n * Extract terms from content.\n * Returns normalized lowercase terms >= 3 chars.\n */\nfunction extractTerms(content: string): string[] {\n  return content\n    .toLowerCase()\n    .replace(/[^a-z0-9\\s-]/g, \" \")\n    .split(/\\s+/)\n    .filter((w) => w.length >= 3 && !STOP_WORDS.has(w));\n}\n\n/**\n * Calculate TF-IDF scores for terms across all memories.\n *\n * TF (term frequency) = count of term in document / total terms in document\n * IDF (inverse document frequency) = log(total documents / documents containing term)\n * TF-IDF = TF * IDF\n *\n * Terms with high TF-IDF are frequent in specific memories but rare overall.\n */\nexport function extractTopics(\n  memories: MemoryFile[],\n  topN: number = 50,\n): TopicScore[] {\n  if (memories.length === 0) return [];\n\n  // Count term frequency per document and document frequency\n  const docFreq = new Map<string, number>(); // term -> number of documents containing it\n  const termFreqPerDoc: Map<string, number>[] = []; // per-doc term frequencies\n\n  for (const memory of memories) {\n    const terms = extractTerms(memory.content);\n    const termFreq = new Map<string, number>();\n\n    for (const term of terms) {\n      termFreq.set(term, (termFreq.get(term) ?? 0) + 1);\n    }\n\n    // Track which terms appear in this document\n    for (const term of termFreq.keys()) {\n      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);\n    }\n\n    termFreqPerDoc.push(termFreq);\n  }\n\n  const totalDocs = memories.length;\n\n  // Calculate TF-IDF for each term\n  const tfidfScores = new Map<string, { score: number; count: number }>();\n\n  for (let i = 0; i < memories.length; i++) {\n    const termFreq = termFreqPerDoc[i];\n    const totalTerms = [...termFreq.values()].reduce((a, b) => a + b, 0);\n\n    for (const [term, count] of termFreq) {\n      const tf = count / totalTerms;\n      const df = docFreq.get(term) ?? 1;\n      const idf = Math.log(totalDocs / df);\n      const tfidf = tf * idf;\n\n      const existing = tfidfScores.get(term);\n      if (existing) {\n        existing.score += tfidf;\n        existing.count += count;\n      } else {\n        tfidfScores.set(term, { score: tfidf, count });\n      }\n    }\n  }\n\n  // Convert to array and sort by score\n  const topics: TopicScore[] = [...tfidfScores.entries()]\n    .map(([term, { score, count }]) => ({ term, score, count }))\n    .sort((a, b) => b.score - a.score)\n    .slice(0, topN);\n\n  return topics;\n}\n\n/**\n * Compare two topic lists to find trending changes.\n * Returns topics that are new or significantly increased.\n */\nexport function findTrendingTopics(\n  currentTopics: TopicScore[],\n  previousTopics: TopicScore[],\n  threshold: number = 0.5,\n): { rising: TopicScore[]; falling: TopicScore[] } {\n  const prevMap = new Map(previousTopics.map((t) => [t.term, t.score]));\n  const currMap = new Map(currentTopics.map((t) => [t.term, t.score]));\n\n  const rising: TopicScore[] = [];\n  const falling: TopicScore[] = [];\n\n  for (const topic of currentTopics) {\n    const prevScore = prevMap.get(topic.term) ?? 0;\n    const change = topic.score - prevScore;\n\n    if (change > threshold) {\n      rising.push({ ...topic, score: change });\n    }\n  }\n\n  for (const topic of previousTopics) {\n    const currScore = currMap.get(topic.term) ?? 0;\n    const change = topic.score - currScore;\n\n    if (change > threshold && currScore < topic.score * 0.5) {\n      falling.push({ ...topic, score: change });\n    }\n  }\n\n  return {\n    rising: rising.sort((a, b) => b.score - a.score).slice(0, 10),\n    falling: falling.sort((a, b) => b.score - a.score).slice(0, 10),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-UIYZ5T3I.js

@@ -0,0 +1,108 @@
+import {
+  BoxBuilder
+} from "./chunk-M5KEYE5E.js";
+import {
+  StorageManager
+} from "./chunk-QWUUMMIK.js";
+import {
+  getCachedEpisodeMap,
+  setCachedEpisodeMap
+} from "./chunk-ESSMF2FR.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.js";
+
+// src/verified-recall.ts
+function createReadOnlyBoxBuilder(memoryDir) {
+  return new BoxBuilder(memoryDir, {
+    memoryBoxesEnabled: true,
+    traceWeaverEnabled: false,
+    boxTopicShiftThreshold: 0.35,
+    boxTimeGapMs: 30 * 60 * 1e3,
+    boxMaxMemories: 50,
+    traceWeaverLookbackDays: 7,
+    traceWeaverOverlapThreshold: 0.4
+  });
+}
+function scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens) {
+  const matchedFields = /* @__PURE__ */ new Set();
+  let score = 0;
+  const topicMatches = countRecallTokenOverlap(queryTokens, box.topics.join(" "));
+  if (topicMatches > 0) {
+    score += topicMatches * 3;
+    matchedFields.add("topics");
+  }
+  const goalMatches = countRecallTokenOverlap(queryTokens, box.goal);
+  if (goalMatches > 0) {
+    score += goalMatches * 4;
+    matchedFields.add("goal");
+  }
+  const toolMatches = countRecallTokenOverlap(queryTokens, box.toolsUsed?.join(" "));
+  if (toolMatches > 0) {
+    score += toolMatches * 2;
+    matchedFields.add("toolsUsed");
+  }
+  let episodeContentMatches = 0;
+  for (const memory of verifiedMemories) {
+    episodeContentMatches += countRecallTokenOverlap(queryTokens, memory.content);
+  }
+  if (episodeContentMatches > 0) {
+    score += episodeContentMatches * 4;
+    matchedFields.add("episodeContent");
+  }
+  return { score, matchedFields };
+}
+function resolveVerifiedEpisodeMemoriesFromMap(memoryById, memoryIds) {
+  const verified = [];
+  for (const memoryId of memoryIds) {
+    try {
+      const memory = memoryById.get(memoryId);
+      if (!memory) continue;
+      if (memory.frontmatter.status === "archived") continue;
+      if (memory.frontmatter.memoryKind !== "episode") continue;
+      verified.push(memory);
+    } catch {
+    }
+  }
+  return verified;
+}
+async function searchVerifiedEpisodes(options) {
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
+  if (queryTokens.size === 0 || options.maxResults <= 0) return [];
+  const storage = new StorageManager(options.memoryDir);
+  const version = storage.getMemoryStatusVersion();
+  let verifiedMemoryById = getCachedEpisodeMap(storage.dir, version);
+  if (!verifiedMemoryById) {
+    const allMemories = await storage.readAllMemories();
+    verifiedMemoryById = setCachedEpisodeMap(storage.dir, allMemories, version);
+  }
+  const boxes = await createReadOnlyBoxBuilder(options.memoryDir).readRecentBoxes(Math.max(1, Math.floor(options.boxRecallDays ?? 3))).catch(() => []);
+  const candidates = [];
+  for (const box of boxes) {
+    const verifiedMemories = resolveVerifiedEpisodeMemoriesFromMap(verifiedMemoryById, box.memoryIds);
+    if (verifiedMemories.length === 0) continue;
+    const { score, matchedFields } = scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens);
+    if (score <= 0) continue;
+    candidates.push({
+      box,
+      score,
+      matchedFields,
+      verifiedMemories
+    });
+  }
+  return candidates.map((candidate) => ({
+    box: candidate.box,
+    score: candidate.score,
+    verifiedEpisodeCount: candidate.verifiedMemories.length,
+    verifiedMemoryIds: candidate.verifiedMemories.map((memory) => memory.frontmatter.id),
+    matchedFields: [...candidate.matchedFields].sort()
+  })).sort(
+    (left, right) => right.score - left.score || right.verifiedEpisodeCount - left.verifiedEpisodeCount || right.box.sealedAt.localeCompare(left.box.sealedAt)
+  ).slice(0, options.maxResults);
+}
+
+export {
+  searchVerifiedEpisodes
+};
+//# sourceMappingURL=chunk-UIYZ5T3I.js.map

package/dist/chunk-UIYZ5T3I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/verified-recall.ts"],"sourcesContent":["import { BoxBuilder, type BoxFrontmatter } from \"./boxes.js\";\nimport { getCachedEpisodeMap, setCachedEpisodeMap } from \"./memory-cache.js\";\nimport { StorageManager } from \"./storage.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { countRecallTokenOverlap, normalizeRecallTokens } from \"./recall-tokenization.js\";\n\nexport interface VerifiedEpisodeResult {\n  box: BoxFrontmatter;\n  score: number;\n  verifiedEpisodeCount: number;\n  verifiedMemoryIds: string[];\n  matchedFields: string[];\n}\n\ninterface VerifiedEpisodeCandidate {\n  box: BoxFrontmatter;\n  score: number;\n  matchedFields: Set<string>;\n  verifiedMemories: MemoryFile[];\n}\n\nfunction createReadOnlyBoxBuilder(memoryDir: string): BoxBuilder {\n  return new BoxBuilder(memoryDir, {\n    memoryBoxesEnabled: true,\n    traceWeaverEnabled: false,\n    boxTopicShiftThreshold: 0.35,\n    boxTimeGapMs: 30 * 60 * 1000,\n    boxMaxMemories: 50,\n    traceWeaverLookbackDays: 7,\n    traceWeaverOverlapThreshold: 0.4,\n  });\n}\n\nfunction scoreVerifiedEpisodeCandidate(box: BoxFrontmatter, verifiedMemories: MemoryFile[], queryTokens: Set<string>) {\n  const matchedFields = new Set<string>();\n  let score = 0;\n\n  const topicMatches = countRecallTokenOverlap(queryTokens, box.topics.join(\" \"));\n  if (topicMatches > 0) {\n    score += topicMatches * 3;\n    matchedFields.add(\"topics\");\n  }\n\n  const goalMatches = countRecallTokenOverlap(queryTokens, box.goal);\n  if (goalMatches > 0) {\n    score += goalMatches * 4;\n    matchedFields.add(\"goal\");\n  }\n\n  const toolMatches = countRecallTokenOverlap(queryTokens, box.toolsUsed?.join(\" \"));\n  if (toolMatches > 0) {\n    score += toolMatches * 2;\n    matchedFields.add(\"toolsUsed\");\n  }\n\n  let episodeContentMatches = 0;\n  for (const memory of verifiedMemories) {\n    episodeContentMatches += countRecallTokenOverlap(queryTokens, memory.content);\n  }\n  if (episodeContentMatches > 0) {\n    score += episodeContentMatches * 4;\n    matchedFields.add(\"episodeContent\");\n  }\n\n  return { score, matchedFields };\n}\n\nfunction resolveVerifiedEpisodeMemoriesFromMap(\n  memoryById: ReadonlyMap<string, MemoryFile>,\n  memoryIds: string[],\n): MemoryFile[] {\n  const verified: MemoryFile[] = [];\n  for (const memoryId of memoryIds) {\n    try {\n      const memory = memoryById.get(memoryId);\n      if (!memory) continue;\n      if (memory.frontmatter.status === \"archived\") continue;\n      if (memory.frontmatter.memoryKind !== \"episode\") continue;\n      verified.push(memory);\n    } catch {\n      // fail-open: malformed or unreadable memories should not abort recall\n    }\n  }\n  return verified;\n}\n\nexport async function searchVerifiedEpisodes(options: {\n  memoryDir: string;\n  query: string;\n  maxResults: number;\n  boxRecallDays?: number;\n}): Promise<VerifiedEpisodeResult[]> {\n  const queryTokens = new Set(normalizeRecallTokens(options.query, [\"what\", \"which\"]));\n  if (queryTokens.size === 0 || options.maxResults <= 0) return [];\n\n  const storage = new StorageManager(options.memoryDir);\n  const version = storage.getMemoryStatusVersion();\n\n  // Use derived episode cache to avoid O(146K) filter+map on every call.\n  let verifiedMemoryById = getCachedEpisodeMap(storage.dir, version);\n  if (!verifiedMemoryById) {\n    const allMemories = await storage.readAllMemories();\n    verifiedMemoryById = setCachedEpisodeMap(storage.dir, allMemories, version);\n  }\n  const boxes = await createReadOnlyBoxBuilder(options.memoryDir)\n    .readRecentBoxes(Math.max(1, Math.floor(options.boxRecallDays ?? 3)))\n    .catch(() => [] as BoxFrontmatter[]);\n\n  const candidates: VerifiedEpisodeCandidate[] = [];\n  for (const box of boxes) {\n    const verifiedMemories = resolveVerifiedEpisodeMemoriesFromMap(verifiedMemoryById, box.memoryIds);\n    if (verifiedMemories.length === 0) continue;\n    const { score, matchedFields } = scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens);\n    if (score <= 0) continue;\n    candidates.push({\n      box,\n      score,\n      matchedFields,\n      verifiedMemories,\n    });\n  }\n\n  return candidates\n    .map((candidate) => ({\n      box: candidate.box,\n      score: candidate.score,\n      verifiedEpisodeCount: candidate.verifiedMemories.length,\n      verifiedMemoryIds: candidate.verifiedMemories.map((memory) => memory.frontmatter.id),\n      matchedFields: [...candidate.matchedFields].sort(),\n    }))\n    .sort(\n      (left, right) =>\n        right.score - left.score\n        || right.verifiedEpisodeCount - left.verifiedEpisodeCount\n        || right.box.sealedAt.localeCompare(left.box.sealedAt),\n    )\n    .slice(0, options.maxResults);\n}\n"],"mappings":"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","names":[]}