@remnic/core 1.1.11 → 1.1.13

package/dist/chunk-W4RVMTHR.js

@@ -0,0 +1,372 @@
+import {
+  encodeStoragePathSegment,
+  encodeStoragePathSegmentWithHash,
+  isSafeLegacyPathSegment,
+  resolveSafeStoragePath
+} from "./chunk-FF4KLI5W.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/threading.ts
+import { readdir, readFile, writeFile, mkdir, stat } from "fs/promises";
+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(", ");
+}
+function isConversationThread(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.id === "string" && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && Array.isArray(candidate.episodeIds) && Array.isArray(candidate.linkedThreadIds);
+}
+function parseConversationThread(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return isConversationThread(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+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 });
+  }
+  encodedThreadFileName(threadId) {
+    return `${encodeStoragePathSegment(threadId)}.json`;
+  }
+  collisionSafeThreadFileName(threadId) {
+    return `${encodeStoragePathSegmentWithHash(threadId)}.json`;
+  }
+  legacyThreadFileName(threadId) {
+    if (!isSafeLegacyPathSegment(threadId)) return void 0;
+    const legacyFile = `${threadId}.json`;
+    return legacyFile === this.encodedThreadFileName(threadId) ? void 0 : legacyFile;
+  }
+  async threadCandidateStatus(filePath, threadId) {
+    try {
+      if (!(await stat(filePath)).isFile()) return "mismatches";
+      const thread = parseConversationThread(await readFile(filePath, "utf-8"));
+      if (!thread) return "invalid";
+      return thread.id === threadId ? "matches" : "mismatches";
+    } catch (err) {
+      const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+      if (code === "ENOENT") return "missing";
+      throw err;
+    }
+  }
+  async threadFilePathForWrite(threadId) {
+    const encodedPath = await resolveSafeStoragePath(
+      this.threadsDir,
+      this.encodedThreadFileName(threadId)
+    );
+    const encodedStatus = await this.threadCandidateStatus(encodedPath, threadId);
+    if (encodedStatus === "matches") return encodedPath;
+    const legacyFile = this.legacyThreadFileName(threadId);
+    if (legacyFile) {
+      const legacyPath = await resolveSafeStoragePath(this.threadsDir, legacyFile);
+      if (await this.threadCandidateStatus(legacyPath, threadId) === "matches") {
+        return legacyPath;
+      }
+    }
+    if (encodedStatus === "missing") return encodedPath;
+    const collisionSafePath = await resolveSafeStoragePath(
+      this.threadsDir,
+      this.collisionSafeThreadFileName(threadId)
+    );
+    const collisionSafeStatus = await this.threadCandidateStatus(collisionSafePath, threadId);
+    if (collisionSafeStatus === "mismatches") {
+      throw new Error(`thread storage path collision for thread id: ${threadId}`);
+    }
+    return collisionSafePath;
+  }
+  /**
+   * 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 threadsById = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const raw = await readFile(
+            await resolveSafeStoragePath(this.threadsDir, file),
+            "utf-8"
+          );
+          const thread = parseConversationThread(raw);
+          if (!thread) continue;
+          const legacyFile = this.legacyThreadFileName(thread.id);
+          const storagePriority = file === this.encodedThreadFileName(thread.id) ? 3 : file === this.collisionSafeThreadFileName(thread.id) ? 2 : legacyFile && file === legacyFile ? 1 : 0;
+          const current = threadsById.get(thread.id);
+          if (!current || storagePriority > current.storagePriority) {
+            threadsById.set(thread.id, { thread, storagePriority });
+          }
+        } catch {
+        }
+      }
+      return [...threadsById.values()].map(({ thread }) => thread).sort(
+        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get a thread by ID.
+   */
+  async loadThread(threadId) {
+    const candidates = [
+      this.encodedThreadFileName(threadId),
+      this.legacyThreadFileName(threadId),
+      this.collisionSafeThreadFileName(threadId)
+    ];
+    for (const file of candidates) {
+      if (!file) continue;
+      try {
+        const filePath = await resolveSafeStoragePath(this.threadsDir, file);
+        const raw = await readFile(filePath, "utf-8");
+        const thread = parseConversationThread(raw);
+        if (thread?.id === threadId) return thread;
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Save a thread.
+   */
+  async saveThread(thread) {
+    await this.ensureDirectory();
+    const filePath = await this.threadFilePathForWrite(thread.id);
+    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-W4RVMTHR.js.map

package/dist/chunk-W4RVMTHR.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, stat } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport type { BufferTurn, ConversationThread } from \"./types.js\";\nimport {\n  encodeStoragePathSegment,\n  encodeStoragePathSegmentWithHash,\n  isSafeLegacyPathSegment,\n  resolveSafeStoragePath,\n} from \"./storage-paths.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\nfunction isConversationThread(value: unknown): value is ConversationThread {\n  if (value === null || typeof value !== \"object\") return false;\n  const candidate = value as Partial<ConversationThread>;\n  return (\n    typeof candidate.id === \"string\" &&\n    typeof candidate.title === \"string\" &&\n    typeof candidate.createdAt === \"string\" &&\n    typeof candidate.updatedAt === \"string\" &&\n    Array.isArray(candidate.episodeIds) &&\n    Array.isArray(candidate.linkedThreadIds)\n  );\n}\n\nfunction parseConversationThread(raw: string): ConversationThread | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    return isConversationThread(parsed) ? parsed : null;\n  } catch {\n    return null;\n  }\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  private encodedThreadFileName(threadId: string): string {\n    return `${encodeStoragePathSegment(threadId)}.json`;\n  }\n\n  private collisionSafeThreadFileName(threadId: string): string {\n    return `${encodeStoragePathSegmentWithHash(threadId)}.json`;\n  }\n\n  private legacyThreadFileName(threadId: string): string | undefined {\n    if (!isSafeLegacyPathSegment(threadId)) return undefined;\n    const legacyFile = `${threadId}.json`;\n    return legacyFile === this.encodedThreadFileName(threadId) ? undefined : legacyFile;\n  }\n\n  private async threadCandidateStatus(\n    filePath: string,\n    threadId: string,\n  ): Promise<\"missing\" | \"matches\" | \"invalid\" | \"mismatches\"> {\n    try {\n      if (!(await stat(filePath)).isFile()) return \"mismatches\";\n      const thread = parseConversationThread(await readFile(filePath, \"utf-8\"));\n      if (!thread) return \"invalid\";\n      return thread.id === threadId ? \"matches\" : \"mismatches\";\n    } catch (err) {\n      const code =\n        err && typeof err === \"object\" && \"code\" in err\n          ? (err as { code?: string }).code\n          : undefined;\n      if (code === \"ENOENT\") return \"missing\";\n      throw err;\n    }\n  }\n\n  private async threadFilePathForWrite(threadId: string): Promise<string> {\n    const encodedPath = await resolveSafeStoragePath(\n      this.threadsDir,\n      this.encodedThreadFileName(threadId),\n    );\n    const encodedStatus = await this.threadCandidateStatus(encodedPath, threadId);\n    if (encodedStatus === \"matches\") return encodedPath;\n\n    const legacyFile = this.legacyThreadFileName(threadId);\n    if (legacyFile) {\n      const legacyPath = await resolveSafeStoragePath(this.threadsDir, legacyFile);\n      if ((await this.threadCandidateStatus(legacyPath, threadId)) === \"matches\") {\n        return legacyPath;\n      }\n    }\n\n    if (encodedStatus === \"missing\") return encodedPath;\n\n    const collisionSafePath = await resolveSafeStoragePath(\n      this.threadsDir,\n      this.collisionSafeThreadFileName(threadId),\n    );\n    const collisionSafeStatus = await this.threadCandidateStatus(collisionSafePath, threadId);\n    if (collisionSafeStatus === \"mismatches\") {\n      throw new Error(`thread storage path collision for thread id: ${threadId}`);\n    }\n\n    return collisionSafePath;\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 threadsById = new Map<\n        string,\n        { thread: ConversationThread; storagePriority: number }\n      >();\n\n      for (const file of files) {\n        if (!file.endsWith(\".json\")) continue;\n        try {\n          const raw = await readFile(\n            await resolveSafeStoragePath(this.threadsDir, file),\n            \"utf-8\",\n          );\n          const thread = parseConversationThread(raw);\n          if (!thread) continue;\n\n          const legacyFile = this.legacyThreadFileName(thread.id);\n          const storagePriority =\n            file === this.encodedThreadFileName(thread.id)\n              ? 3\n              : file === this.collisionSafeThreadFileName(thread.id)\n                ? 2\n                : legacyFile && file === legacyFile\n                  ? 1\n                  : 0;\n          const current = threadsById.get(thread.id);\n          if (!current || storagePriority > current.storagePriority) {\n            threadsById.set(thread.id, { thread, storagePriority });\n          }\n        } catch {\n          // skip unreadable or malformed thread files\n        }\n      }\n\n      return [...threadsById.values()].map(({ thread }) => thread).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 candidates = [\n      this.encodedThreadFileName(threadId),\n      this.legacyThreadFileName(threadId),\n      this.collisionSafeThreadFileName(threadId),\n    ];\n    for (const file of candidates) {\n      if (!file) continue;\n      try {\n        const filePath = await resolveSafeStoragePath(this.threadsDir, file);\n        const raw = await readFile(filePath, \"utf-8\");\n        const thread = parseConversationThread(raw);\n        if (thread?.id === threadId) return thread;\n      } catch {\n        // try the next candidate\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Save a thread.\n   */\n  async saveThread(thread: ConversationThread): Promise<void> {\n    await this.ensureDirectory();\n    const filePath = await this.threadFilePathForWrite(thread.id);\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-WEHSQBFR.js

@@ -0,0 +1,188 @@
+// src/transfer/types.ts
+import { z } from "zod";
+var ExportManifestV1Schema = z.object({
+  format: z.literal("openclaw-engram-export"),
+  schemaVersion: z.literal(1),
+  createdAt: z.string(),
+  pluginVersion: z.string(),
+  includesTranscripts: z.boolean(),
+  files: z.array(
+    z.object({
+      path: z.string(),
+      sha256: z.string(),
+      bytes: z.number().int().nonnegative()
+    })
+  )
+});
+var ExportMemoryRecordV1Schema = z.object({
+  path: z.string(),
+  content: z.string()
+});
+var ExportBundleV1Schema = z.object({
+  manifest: ExportManifestV1Schema,
+  records: z.array(ExportMemoryRecordV1Schema)
+});
+var CAPSULE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?!-))*[A-Za-z0-9]$|^[A-Za-z0-9]$/;
+var CapsuleIdSchema = z.string().min(1, "capsule.id must not be empty").max(64, "capsule.id must be 64 characters or fewer").regex(
+  CAPSULE_ID_PATTERN,
+  "capsule.id must be alphanumeric with single dashes (no spaces, no leading/trailing dashes)"
+);
+var SemverLikeSchema = z.string().min(1, "capsule.version must not be empty").regex(
+  /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,
+  "capsule.version must be a semver-like string (e.g. 1.0.0)"
+);
+function isSafePosixRelativePathPrefix(value) {
+  if (value.startsWith("/") || value.includes("\\")) return false;
+  const segments = value.split("/");
+  return segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+var CapsuleRetrievalPolicySchema = z.object({
+  /**
+   * Per-tier weight overrides applied during recall when the capsule is the
+   * active scope. Keys are tier names (e.g. `bm25`, `vector`, `graph`); values
+   * are non-negative finite multipliers. The set of valid keys is left open
+   * for now so future tiers do not break older manifests.
+   */
+  tierWeights: z.record(
+    z.string().min(1),
+    z.number().finite().nonnegative()
+  ),
+  /**
+   * Whether the direct-answer fast path is allowed when this capsule is
+   * active. Operators may disable it for capsules whose contents should
+   * always flow through the full retrieval pipeline.
+   */
+  directAnswerEnabled: z.boolean()
+});
+var CapsuleIncludesSchema = z.object({
+  taxonomy: z.boolean(),
+  identityAnchors: z.boolean(),
+  peerProfiles: z.boolean(),
+  procedural: z.boolean()
+});
+var CapsuleParentSchema = z.object({
+  capsuleId: CapsuleIdSchema,
+  version: SemverLikeSchema,
+  /**
+   * Posix-relative path prefix under the fork's memory root where the parent
+   * capsule's records were placed. Typically `forks/<parent-capsule-id>`.
+   * Must be a non-empty string with no leading slash.
+   */
+  forkRoot: z.string().min(1, "capsule.parent.forkRoot must not be empty").refine(isSafePosixRelativePathPrefix, {
+    message: "capsule.parent.forkRoot must be a normalized posix-relative path with no traversal segments"
+  })
+});
+var CapsuleBlockSchema = z.object({
+  id: CapsuleIdSchema,
+  version: SemverLikeSchema,
+  /**
+   * Taxonomy schema version the capsule was authored against. Free-form for
+   * now; later PRs may tighten this to a known taxonomy registry.
+   */
+  schemaVersion: z.string().min(1, "capsule.schemaVersion must not be empty"),
+  /**
+   * Optional reference to the parent capsule this one was forked or derived
+   * from. `null` (not `undefined`) is the explicit "no parent" sentinel so
+   * that round-trips through JSON do not silently drop the field.
+   *
+   * @deprecated Prefer {@link parent} (structured). This field is preserved
+   *   for backward compatibility with V2 manifests written before PR 4/6.
+   */
+  parentCapsule: z.string().min(1).nullable(),
+  /**
+   * Structured fork-lineage pointer added in PR 4/6. When present, this
+   * capsule is a fork of the described parent. `null` is the explicit
+   * "not a fork" sentinel — round-trips through JSON cleanly without
+   * silently dropping the field.
+   *
+   * Defaults to `null` so that V2 manifests written before PR 4/6 (which
+   * omit this field) still parse without error. This preserves backward
+   * compatibility with the existing `makeV2Manifest()` test fixtures and
+   * any in-the-wild V2 archives produced by PR 2/6 and PR 3/6.
+   *
+   * Invariant: when `parent` is non-null, `parentCapsule` SHOULD equal
+   * `parent.capsuleId` for backward compatibility with readers that only
+   * understand the legacy field. `forkCapsule()` sets both.
+   */
+  parent: CapsuleParentSchema.nullable().default(null),
+  description: z.string(),
+  retrievalPolicy: CapsuleRetrievalPolicySchema,
+  includes: CapsuleIncludesSchema
+});
+var ExportManifestV2Schema = z.object({
+  format: z.literal("openclaw-engram-export"),
+  schemaVersion: z.literal(2),
+  createdAt: z.string(),
+  pluginVersion: z.string(),
+  includesTranscripts: z.boolean(),
+  files: z.array(
+    z.object({
+      path: z.string(),
+      sha256: z.string(),
+      bytes: z.number().int().nonnegative()
+    })
+  ),
+  capsule: CapsuleBlockSchema
+});
+var ExportBundleV2Schema = z.object({
+  manifest: ExportManifestV2Schema,
+  records: z.array(ExportMemoryRecordV1Schema)
+});
+function parseExportManifest(input) {
+  const version = typeof input === "object" && input !== null ? input.schemaVersion : void 0;
+  if (version === 2) {
+    const manifest = ExportManifestV2Schema.parse(input);
+    return {
+      capsuleVersion: 2,
+      manifest,
+      capsule: manifest.capsule
+    };
+  }
+  if (version === 1) {
+    const manifest = ExportManifestV1Schema.parse(input);
+    return { capsuleVersion: 1, manifest, capsule: null };
+  }
+  const v1 = ExportManifestV1Schema.safeParse(input);
+  if (v1.success) {
+    return { capsuleVersion: 1, manifest: v1.data, capsule: null };
+  }
+  const v2 = ExportManifestV2Schema.safeParse(input);
+  if (v2.success) {
+    return {
+      capsuleVersion: 2,
+      manifest: v2.data,
+      capsule: v2.data.capsule
+    };
+  }
+  throw v2.error;
+}
+function parseExportBundle(input) {
+  if (typeof input !== "object" || input === null) {
+    ExportBundleV1Schema.parse(input);
+    throw new Error("unreachable");
+  }
+  const manifestRaw = input.manifest;
+  const normalized = parseExportManifest(manifestRaw);
+  if (normalized.capsuleVersion === 2) {
+    const bundle2 = ExportBundleV2Schema.parse(input);
+    return { capsuleVersion: 2, bundle: bundle2, capsule: bundle2.manifest.capsule };
+  }
+  const bundle = ExportBundleV1Schema.parse(input);
+  return { capsuleVersion: 1, bundle, capsule: null };
+}
+
+export {
+  ExportManifestV1Schema,
+  ExportMemoryRecordV1Schema,
+  ExportBundleV1Schema,
+  CAPSULE_ID_PATTERN,
+  CapsuleRetrievalPolicySchema,
+  CapsuleIncludesSchema,
+  CapsuleParentSchema,
+  CapsuleBlockSchema,
+  ExportManifestV2Schema,
+  ExportBundleV2Schema,
+  parseExportManifest,
+  parseExportBundle
+};
+//# sourceMappingURL=chunk-WEHSQBFR.js.map

package/dist/chunk-WEHSQBFR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transfer/types.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const ExportManifestV1Schema = z.object({\n  format: z.literal(\"openclaw-engram-export\"),\n  schemaVersion: z.literal(1),\n  createdAt: z.string(),\n  pluginVersion: z.string(),\n  includesTranscripts: z.boolean(),\n  files: z.array(\n    z.object({\n      path: z.string(),\n      sha256: z.string(),\n      bytes: z.number().int().nonnegative(),\n    }),\n  ),\n});\n\nexport type ExportManifestV1 = z.infer<typeof ExportManifestV1Schema>;\n\nexport const ExportMemoryRecordV1Schema = z.object({\n  path: z.string(),\n  content: z.string(),\n});\n\nexport type ExportMemoryRecordV1 = z.infer<typeof ExportMemoryRecordV1Schema>;\n\nexport const ExportBundleV1Schema = z.object({\n  manifest: ExportManifestV1Schema,\n  records: z.array(ExportMemoryRecordV1Schema),\n});\n\nexport type ExportBundleV1 = z.infer<typeof ExportBundleV1Schema>;\n\n// ---------------------------------------------------------------------------\n// V2 capsule manifest (issue #676 PR 1/6)\n// ---------------------------------------------------------------------------\n//\n// The V2 manifest extends V1 with a `capsule` block describing a reusable,\n// shareable bundle of memory state (\"capsule\"). This PR introduces ONLY the\n// schema and a backward-compatible reader. Actual export/import pipelines and\n// CLI surfaces are deferred to subsequent PRs (2/6 through 6/6).\n\n/**\n * Allowed pattern for a user-chosen capsule id.\n *\n * - lowercase or uppercase alphanumerics and dashes\n * - must start and end with an alphanumeric (no leading/trailing dashes)\n * - no consecutive dashes\n * - 1..64 characters\n *\n * The constraints are intentionally narrow so capsule ids round-trip cleanly\n * through filesystem paths, URLs, and registry slugs without escaping.\n */\nexport const CAPSULE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?!-))*[A-Za-z0-9]$|^[A-Za-z0-9]$/;\n\nconst CapsuleIdSchema = z\n  .string()\n  .min(1, \"capsule.id must not be empty\")\n  .max(64, \"capsule.id must be 64 characters or fewer\")\n  .regex(\n    CAPSULE_ID_PATTERN,\n    \"capsule.id must be alphanumeric with single dashes (no spaces, no leading/trailing dashes)\",\n  );\n\n/**\n * Permissive semver-ish validator. We accept the common subset\n * `MAJOR.MINOR.PATCH` with optional pre-release / build suffixes. This is\n * intentionally looser than full semver 2.0 so capsule authors can use simple\n * versions like `1.0.0` or `0.1.0-rc.1` without pulling in a parser.\n */\nconst SemverLikeSchema = z\n  .string()\n  .min(1, \"capsule.version must not be empty\")\n  .regex(\n    /^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$/,\n    \"capsule.version must be a semver-like string (e.g. 1.0.0)\",\n  );\n\nfunction isSafePosixRelativePathPrefix(value: string): boolean {\n  if (value.startsWith(\"/\") || value.includes(\"\\\\\")) return false;\n  const segments = value.split(\"/\");\n  return segments.every((segment) => segment !== \"\" && segment !== \".\" && segment !== \"..\");\n}\n\nexport const CapsuleRetrievalPolicySchema = z.object({\n  /**\n   * Per-tier weight overrides applied during recall when the capsule is the\n   * active scope. Keys are tier names (e.g. `bm25`, `vector`, `graph`); values\n   * are non-negative finite multipliers. The set of valid keys is left open\n   * for now so future tiers do not break older manifests.\n   */\n  tierWeights: z.record(\n    z.string().min(1),\n    z.number().finite().nonnegative(),\n  ),\n  /**\n   * Whether the direct-answer fast path is allowed when this capsule is\n   * active. Operators may disable it for capsules whose contents should\n   * always flow through the full retrieval pipeline.\n   */\n  directAnswerEnabled: z.boolean(),\n});\n\nexport type CapsuleRetrievalPolicy = z.infer<typeof CapsuleRetrievalPolicySchema>;\n\nexport const CapsuleIncludesSchema = z.object({\n  taxonomy: z.boolean(),\n  identityAnchors: z.boolean(),\n  peerProfiles: z.boolean(),\n  procedural: z.boolean(),\n});\n\nexport type CapsuleIncludes = z.infer<typeof CapsuleIncludesSchema>;\n\n/**\n * Structured linkage to the capsule that was forked to produce this one.\n *\n * - `capsuleId`  — the `id` field from the parent capsule's manifest block.\n * - `version`    — the `version` field from the parent capsule's manifest block\n *                  at the time the fork was taken.\n * - `forkRoot`   — the posix-relative directory prefix under which the parent's\n *                  records were planted inside the fork's memory root, e.g.\n *                  `forks/parent-id`. Stored here so downstream tooling can\n *                  locate the imported parent tree without re-parsing paths.\n */\nexport const CapsuleParentSchema = z.object({\n  capsuleId: CapsuleIdSchema,\n  version: SemverLikeSchema,\n  /**\n   * Posix-relative path prefix under the fork's memory root where the parent\n   * capsule's records were placed. Typically `forks/<parent-capsule-id>`.\n   * Must be a non-empty string with no leading slash.\n   */\n  forkRoot: z\n    .string()\n    .min(1, \"capsule.parent.forkRoot must not be empty\")\n    .refine(isSafePosixRelativePathPrefix, {\n      message:\n        \"capsule.parent.forkRoot must be a normalized posix-relative path with no traversal segments\",\n    }),\n});\n\nexport type CapsuleParent = z.infer<typeof CapsuleParentSchema>;\n\nexport const CapsuleBlockSchema = z.object({\n  id: CapsuleIdSchema,\n  version: SemverLikeSchema,\n  /**\n   * Taxonomy schema version the capsule was authored against. Free-form for\n   * now; later PRs may tighten this to a known taxonomy registry.\n   */\n  schemaVersion: z.string().min(1, \"capsule.schemaVersion must not be empty\"),\n  /**\n   * Optional reference to the parent capsule this one was forked or derived\n   * from. `null` (not `undefined`) is the explicit \"no parent\" sentinel so\n   * that round-trips through JSON do not silently drop the field.\n   *\n   * @deprecated Prefer {@link parent} (structured). This field is preserved\n   *   for backward compatibility with V2 manifests written before PR 4/6.\n   */\n  parentCapsule: z.string().min(1).nullable(),\n  /**\n   * Structured fork-lineage pointer added in PR 4/6. When present, this\n   * capsule is a fork of the described parent. `null` is the explicit\n   * \"not a fork\" sentinel — round-trips through JSON cleanly without\n   * silently dropping the field.\n   *\n   * Defaults to `null` so that V2 manifests written before PR 4/6 (which\n   * omit this field) still parse without error. This preserves backward\n   * compatibility with the existing `makeV2Manifest()` test fixtures and\n   * any in-the-wild V2 archives produced by PR 2/6 and PR 3/6.\n   *\n   * Invariant: when `parent` is non-null, `parentCapsule` SHOULD equal\n   * `parent.capsuleId` for backward compatibility with readers that only\n   * understand the legacy field. `forkCapsule()` sets both.\n   */\n  parent: CapsuleParentSchema.nullable().default(null),\n  description: z.string(),\n  retrievalPolicy: CapsuleRetrievalPolicySchema,\n  includes: CapsuleIncludesSchema,\n});\n\nexport type CapsuleBlock = z.infer<typeof CapsuleBlockSchema>;\n\nexport const ExportManifestV2Schema = z.object({\n  format: z.literal(\"openclaw-engram-export\"),\n  schemaVersion: z.literal(2),\n  createdAt: z.string(),\n  pluginVersion: z.string(),\n  includesTranscripts: z.boolean(),\n  files: z.array(\n    z.object({\n      path: z.string(),\n      sha256: z.string(),\n      bytes: z.number().int().nonnegative(),\n    }),\n  ),\n  capsule: CapsuleBlockSchema,\n});\n\nexport type ExportManifestV2 = z.infer<typeof ExportManifestV2Schema>;\n\nexport const ExportBundleV2Schema = z.object({\n  manifest: ExportManifestV2Schema,\n  records: z.array(ExportMemoryRecordV1Schema),\n});\n\nexport type ExportBundleV2 = z.infer<typeof ExportBundleV2Schema>;\n\n// ---------------------------------------------------------------------------\n// Backward-compatible reader\n// ---------------------------------------------------------------------------\n\nexport type AnyExportManifest = ExportManifestV1 | ExportManifestV2;\nexport type AnyExportBundle = ExportBundleV1 | ExportBundleV2;\n\n/**\n * Normalized form returned by {@link parseExportManifest}. Callers that don't\n * care about the wire-format version can branch on `capsuleVersion` (1 or 2)\n * and trust that V1 manifests surface as `{ capsuleVersion: 1, capsule: null }`.\n */\nexport interface NormalizedExportManifest {\n  capsuleVersion: 1 | 2;\n  manifest: AnyExportManifest;\n  capsule: CapsuleBlock | null;\n}\n\n/**\n * Parse an unknown manifest payload as either V1 or V2.\n *\n * Dispatch is driven by `schemaVersion` so we surface the most relevant\n * validation error per branch. If `schemaVersion` is missing or unknown we\n * fall back to V1 first (the historical wire format) and only report the V2\n * error if both branches fail.\n */\nexport function parseExportManifest(input: unknown): NormalizedExportManifest {\n  const version =\n    typeof input === \"object\" && input !== null\n      ? (input as { schemaVersion?: unknown }).schemaVersion\n      : undefined;\n\n  if (version === 2) {\n    const manifest = ExportManifestV2Schema.parse(input);\n    return {\n      capsuleVersion: 2,\n      manifest,\n      capsule: manifest.capsule,\n    };\n  }\n\n  if (version === 1) {\n    const manifest = ExportManifestV1Schema.parse(input);\n    return { capsuleVersion: 1, manifest, capsule: null };\n  }\n\n  // Unknown / missing schemaVersion: try V1 then V2 so the reader stays\n  // forgiving for hand-authored payloads but still produces a clear error.\n  const v1 = ExportManifestV1Schema.safeParse(input);\n  if (v1.success) {\n    return { capsuleVersion: 1, manifest: v1.data, capsule: null };\n  }\n  const v2 = ExportManifestV2Schema.safeParse(input);\n  if (v2.success) {\n    return {\n      capsuleVersion: 2,\n      manifest: v2.data,\n      capsule: v2.data.capsule,\n    };\n  }\n  // Surface the V2 error since callers introducing capsules likely care most\n  // about that branch's diagnostics.\n  throw v2.error;\n}\n\n/**\n * Convenience: parse a full bundle (manifest + records) accepting either V1\n * or V2 manifests. Records currently share the V1 shape across both versions.\n */\nexport function parseExportBundle(input: unknown): {\n  capsuleVersion: 1 | 2;\n  bundle: AnyExportBundle;\n  capsule: CapsuleBlock | null;\n} {\n  if (typeof input !== \"object\" || input === null) {\n    // Defer to V1 schema so the user sees a familiar zod error.\n    ExportBundleV1Schema.parse(input);\n    throw new Error(\"unreachable\");\n  }\n  const manifestRaw = (input as { manifest?: unknown }).manifest;\n  const normalized = parseExportManifest(manifestRaw);\n  if (normalized.capsuleVersion === 2) {\n    const bundle = ExportBundleV2Schema.parse(input);\n    return { capsuleVersion: 2, bundle, capsule: bundle.manifest.capsule };\n  }\n  const bundle = ExportBundleV1Schema.parse(input);\n  return { capsuleVersion: 1, bundle, capsule: null };\n}\n"],"mappings":"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","names":["bundle"]}