@remnic/core 1.0.0

package/dist/chunk-TPB3I2AC.js

@@ -0,0 +1,403 @@
+// src/tmt.ts
+import * as fs from "fs";
+import * as path from "path";
+import { mkdir, readFile, writeFile, readdir } from "fs/promises";
+var TMT_DIR = "tmt";
+var TMT_LEVEL_INPUT_LIMITS = {
+  hour: { totalChars: 48e3, itemChars: 2e3, maxItems: 64 },
+  day: { totalChars: 64e3, itemChars: 1800, maxItems: 96 },
+  week: { totalChars: 72e3, itemChars: 1600, maxItems: 120 },
+  persona: { totalChars: 8e4, itemChars: 1600, maxItems: 120 }
+};
+function capTmtSummaryInputs(inputs, level) {
+  const { totalChars, itemChars, maxItems } = TMT_LEVEL_INPUT_LIMITS[level];
+  if (inputs.length === 0) return [];
+  const capped = [];
+  let usedChars = 0;
+  for (const raw of inputs) {
+    if (capped.length >= maxItems || usedChars >= totalChars) break;
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    const next = trimmed.length > itemChars ? `${trimmed.slice(0, itemChars - 1)}\u2026` : trimmed;
+    const separator = capped.length === 0 ? 0 : 2;
+    if (usedChars + separator + next.length > totalChars) break;
+    capped.push(next);
+    usedChars += separator + next.length;
+  }
+  if (capped.length > 0) return capped;
+  const fallback = inputs[0]?.trim() ?? "";
+  if (!fallback) return [];
+  return [fallback.length > itemChars ? `${fallback.slice(0, itemChars - 1)}\u2026` : fallback];
+}
+function tmtDir(baseDir) {
+  return path.join(baseDir, TMT_DIR);
+}
+function hourNodePath(baseDir, date, hour) {
+  return path.join(tmtDir(baseDir), date, `hour-${hour}.md`);
+}
+function dayNodePath(baseDir, date) {
+  return path.join(tmtDir(baseDir), date, "day.md");
+}
+function weekNodePath(baseDir, weekKey) {
+  return path.join(tmtDir(baseDir), `week-${weekKey}.md`);
+}
+function personaNodePath(baseDir) {
+  return path.join(tmtDir(baseDir), "persona.md");
+}
+function serialiseTmtNode(fm, summary) {
+  const yaml = [
+    "---",
+    `level: ${fm.level}`,
+    `periodStart: "${fm.periodStart}"`,
+    `periodEnd: "${fm.periodEnd}"`,
+    `memoryCount: ${fm.memoryCount}`,
+    `sourceIds: [${fm.sourceIds.map((id) => `"${id}"`).join(", ")}]`,
+    `builtAt: "${fm.builtAt}"`,
+    "---"
+  ].join("\n");
+  return `${yaml}
+
+${summary}
+`;
+}
+function parseIsoDate(iso) {
+  return iso.slice(0, 10);
+}
+function parseIsoHour(iso) {
+  return iso.slice(11, 13);
+}
+function isoWeekKey(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getUTCFullYear()}-${String(weekNo).padStart(2, "0")}`;
+}
+var TmtBuilder = class {
+  constructor(baseDir, cfg) {
+    this.baseDir = baseDir;
+    this.cfg = cfg;
+  }
+  baseDir;
+  cfg;
+  /**
+   * Called after each consolidation pass.
+   * Groups memories by hour, builds any missing hour nodes,
+   * then rolls up to day → week → persona if needed.
+   * All errors are caught and logged; never throws.
+   */
+  async maybeRebuildNodes(memories, summarize) {
+    if (!this.cfg.temporalMemoryTreeEnabled || memories.length === 0) return;
+    try {
+      await mkdir(tmtDir(this.baseDir), { recursive: true });
+      await this.buildHourNodes(memories, summarize);
+      await this.buildDayNodes(memories, summarize);
+      await this.buildWeekNodes(memories, summarize);
+      await this.buildPersonaNode(summarize);
+    } catch (err) {
+      console.warn(`[engram] tmt: rebuild failed (ignored): ${err}`);
+    }
+  }
+  async buildHourNodes(memories, summarize) {
+    const byHour = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      const date = parseIsoDate(m.created);
+      const hour = parseIsoHour(m.created);
+      const key = `${date}::${hour}`;
+      if (!byHour.has(key)) byHour.set(key, []);
+      byHour.get(key).push(m);
+    }
+    for (const [key, entries] of byHour) {
+      if (entries.length < this.cfg.tmtHourlyMinMemories) continue;
+      const [date, hour] = key.split("::");
+      const nodePath = hourNodePath(this.baseDir, date, hour);
+      let shouldBuild = !fs.existsSync(nodePath);
+      if (!shouldBuild) {
+        try {
+          const existing = await readFile(nodePath, "utf8");
+          const countMatch = existing.match(/memoryCount: (\d+)/);
+          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
+            shouldBuild = true;
+          }
+        } catch {
+          shouldBuild = true;
+        }
+      }
+      if (!shouldBuild) continue;
+      let summary;
+      try {
+        summary = await summarize(capTmtSummaryInputs(entries.map((e) => e.content), "hour"), "hour");
+      } catch (err) {
+        console.warn(`[engram] tmt: hour node summarize failed for ${key} (ignored): ${err}`);
+        continue;
+      }
+      const sortedCreated = entries.map((e) => e.created).sort();
+      const fm = {
+        level: "hour",
+        periodStart: sortedCreated[0],
+        periodEnd: sortedCreated[sortedCreated.length - 1],
+        memoryCount: entries.length,
+        sourceIds: entries.map((e) => e.id),
+        builtAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await mkdir(path.dirname(nodePath), { recursive: true });
+      await writeFile(nodePath, serialiseTmtNode(fm, summary), "utf8");
+    }
+  }
+  async buildDayNodes(memories, summarize) {
+    const byDate = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      const date = parseIsoDate(m.created);
+      if (!byDate.has(date)) byDate.set(date, []);
+      byDate.get(date).push(m);
+    }
+    for (const [date, entries] of byDate) {
+      const nodePath = dayNodePath(this.baseDir, date);
+      let shouldBuild = !fs.existsSync(nodePath);
+      if (!shouldBuild) {
+        try {
+          const existing = await readFile(nodePath, "utf8");
+          const countMatch = existing.match(/memoryCount: (\d+)/);
+          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
+            shouldBuild = true;
+          }
+        } catch {
+          shouldBuild = true;
+        }
+      }
+      if (!shouldBuild) continue;
+      const inputs = [];
+      const hourToEntries = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const h = parseIsoHour(e.created);
+        if (!hourToEntries.has(h)) hourToEntries.set(h, []);
+        hourToEntries.get(h).push(e);
+      }
+      for (const [h, hourEntries] of hourToEntries) {
+        const hPath = hourNodePath(this.baseDir, date, h);
+        if (fs.existsSync(hPath)) {
+          try {
+            const hContent = await readFile(hPath, "utf8");
+            const hSummary = hContent.replace(/^---[\s\S]*?---\n\n?/, "").trim();
+            if (hSummary) {
+              inputs.push(hSummary);
+              continue;
+            }
+          } catch {
+          }
+        }
+        inputs.push(...hourEntries.map((e) => e.content));
+      }
+      if (inputs.length === 0) inputs.push(...entries.map((e) => e.content));
+      let summary;
+      try {
+        summary = await summarize(capTmtSummaryInputs(inputs, "day"), "day");
+      } catch (err) {
+        console.warn(`[engram] tmt: day node summarize failed for ${date} (ignored): ${err}`);
+        continue;
+      }
+      const sortedCreated = entries.map((e) => e.created).sort();
+      const fm = {
+        level: "day",
+        periodStart: sortedCreated[0],
+        periodEnd: sortedCreated[sortedCreated.length - 1],
+        memoryCount: entries.length,
+        sourceIds: entries.map((e) => e.id),
+        builtAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await mkdir(path.dirname(nodePath), { recursive: true });
+      await writeFile(nodePath, serialiseTmtNode(fm, summary), "utf8");
+    }
+  }
+  /**
+   * Build or update week-level nodes from the day nodes already on disk.
+   * Groups memories by ISO week; for each week that has a day node but no
+   * (or stale) week node, reads day node summaries and builds a week node.
+   * Fail-open: errors per week are caught and skipped.
+   */
+  async buildWeekNodes(memories, summarize) {
+    const weekToEntries = /* @__PURE__ */ new Map();
+    for (const m of memories) {
+      const week = isoWeekKey(new Date(m.created));
+      if (!weekToEntries.has(week)) weekToEntries.set(week, []);
+      weekToEntries.get(week).push(m);
+    }
+    for (const [week, entries] of weekToEntries) {
+      const nodePath = weekNodePath(this.baseDir, week);
+      let shouldBuild = !fs.existsSync(nodePath);
+      if (!shouldBuild) {
+        try {
+          const existing = await readFile(nodePath, "utf8");
+          const countMatch = existing.match(/memoryCount: (\d+)/);
+          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
+            shouldBuild = true;
+          }
+        } catch {
+          shouldBuild = true;
+        }
+      }
+      if (!shouldBuild) continue;
+      try {
+        const dir = tmtDir(this.baseDir);
+        let allDirs = [];
+        try {
+          allDirs = await readdir(dir);
+        } catch {
+          continue;
+        }
+        const dateDirs = allDirs.filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+        const daySummaries = [];
+        for (const dateDir of dateDirs) {
+          const w = isoWeekKey(/* @__PURE__ */ new Date(dateDir + "T00:00:00Z"));
+          if (w !== week) continue;
+          const dayPath = dayNodePath(this.baseDir, dateDir);
+          if (fs.existsSync(dayPath)) {
+            try {
+              const content = await readFile(dayPath, "utf8");
+              const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
+              if (summary2) daySummaries.push(summary2);
+            } catch {
+            }
+          }
+        }
+        const inputs = daySummaries.length > 0 ? daySummaries : entries.map((e) => e.content);
+        const summary = await summarize(capTmtSummaryInputs(inputs, "week"), "week");
+        const sortedCreated = entries.map((e) => e.created).sort();
+        const fm = {
+          level: "week",
+          periodStart: sortedCreated[0],
+          periodEnd: sortedCreated[sortedCreated.length - 1],
+          memoryCount: entries.length,
+          sourceIds: entries.map((e) => e.id),
+          builtAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await mkdir(path.dirname(nodePath), { recursive: true });
+        await writeFile(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      } catch (err) {
+        console.warn(`[engram] tmt: week node build failed for ${week} (ignored): ${err}`);
+      }
+    }
+  }
+  /**
+   * Build or update the persona node from the most recent week-level summaries.
+   * Reads up to 4 recent week nodes and synthesizes a persona-level narrative.
+   * Fail-open: skips silently if no week nodes exist or summarize fails.
+   */
+  async buildPersonaNode(summarize) {
+    try {
+      const dir = tmtDir(this.baseDir);
+      let allFiles = [];
+      try {
+        allFiles = await readdir(dir);
+      } catch {
+        return;
+      }
+      const weekFiles = allFiles.filter((f) => /^week-\d{4}-\d{2}\.md$/.test(f)).sort().reverse().slice(0, 4);
+      if (weekFiles.length === 0) return;
+      const weekSummaries = [];
+      let totalCount = 0;
+      let earliestStart;
+      let latestEnd;
+      for (const f of weekFiles) {
+        try {
+          const content = await readFile(path.join(dir, f), "utf8");
+          const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
+          if (summary2) weekSummaries.push(summary2);
+          const countMatch = content.match(/memoryCount: (\d+)/);
+          if (countMatch) totalCount += parseInt(countMatch[1], 10);
+          const startMatch = content.match(/periodStart: "([^"]+)"/);
+          const endMatch = content.match(/periodEnd: "([^"]+)"/);
+          if (startMatch) {
+            if (!earliestStart || startMatch[1] < earliestStart) earliestStart = startMatch[1];
+          }
+          if (endMatch) {
+            if (!latestEnd || endMatch[1] > latestEnd) latestEnd = endMatch[1];
+          }
+        } catch {
+        }
+      }
+      if (weekSummaries.length === 0) return;
+      const nodePath = personaNodePath(this.baseDir);
+      let shouldBuild = !fs.existsSync(nodePath);
+      if (!shouldBuild) {
+        try {
+          const existing = await readFile(nodePath, "utf8");
+          const countMatch = existing.match(/memoryCount: (\d+)/);
+          if (!countMatch || parseInt(countMatch[1], 10) !== totalCount) {
+            shouldBuild = true;
+          }
+        } catch {
+          shouldBuild = true;
+        }
+      }
+      if (!shouldBuild) return;
+      const summary = await summarize(capTmtSummaryInputs(weekSummaries, "persona"), "persona");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const fm = {
+        level: "persona",
+        periodStart: earliestStart ?? now,
+        periodEnd: latestEnd ?? now,
+        memoryCount: totalCount,
+        sourceIds: [],
+        builtAt: now
+      };
+      await writeFile(nodePath, serialiseTmtNode(fm, summary), "utf8");
+    } catch (err) {
+      console.warn(`[engram] tmt: persona node build failed (ignored): ${err}`);
+    }
+  }
+  /**
+   * Return the summary text of the most relevant TMT node for a given prompt.
+   * Preference: day node for today > most recent day node.
+   * Returns null if no nodes exist or feature is disabled.
+   */
+  async getMostRelevantNode() {
+    if (!this.cfg.temporalMemoryTreeEnabled) return null;
+    try {
+      const dir = tmtDir(this.baseDir);
+      if (!fs.existsSync(dir)) return null;
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const todayDay = dayNodePath(this.baseDir, today);
+      if (fs.existsSync(todayDay)) {
+        const content = await readFile(todayDay, "utf8");
+        const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
+        if (summary) return { level: "day", summary };
+      }
+      let entries = [];
+      try {
+        entries = await readdir(dir);
+      } catch {
+        return null;
+      }
+      const dateDirs = entries.filter((e) => /^\d{4}-\d{2}-\d{2}$/.test(e)).sort().reverse();
+      for (const dateDir of dateDirs) {
+        const dayPath = dayNodePath(this.baseDir, dateDir);
+        if (fs.existsSync(dayPath)) {
+          const content = await readFile(dayPath, "utf8");
+          const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
+          if (summary) return { level: "day", summary };
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  TMT_DIR,
+  capTmtSummaryInputs,
+  tmtDir,
+  hourNodePath,
+  dayNodePath,
+  weekNodePath,
+  personaNodePath,
+  serialiseTmtNode,
+  parseIsoDate,
+  parseIsoHour,
+  isoWeekKey,
+  TmtBuilder
+};
+//# sourceMappingURL=chunk-TPB3I2AC.js.map

package/dist/chunk-TPB3I2AC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tmt.ts"],"sourcesContent":["/**\n * Temporal Memory Tree (TiMem-inspired, v8.2)\n *\n * Builds a hierarchy of summarised memory nodes:\n *   hour-HH.md → day.md → week-YYYY-WW.md → persona.md\n *\n * Stored under `<baseDir>/tmt/`.\n * All writes are fail-open: errors are caught and logged, never thrown.\n */\n\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { mkdir, readFile, writeFile, readdir } from \"node:fs/promises\";\n\nexport const TMT_DIR = \"tmt\";\n\nexport type TmtLevel = \"hour\" | \"day\" | \"week\" | \"persona\";\n\nexport interface TmtNodeFrontmatter {\n  level: TmtLevel;\n  periodStart: string; // ISO date-time\n  periodEnd: string;   // ISO date-time\n  memoryCount: number;\n  sourceIds: string[];\n  builtAt: string;     // ISO date-time\n}\n\nexport interface TmtConfig {\n  temporalMemoryTreeEnabled: boolean;\n  tmtHourlyMinMemories: number;   // default 3\n  tmtSummaryMaxTokens: number;    // default 300\n}\n\nexport interface MemoryEntry {\n  path: string;\n  id: string;\n  created: string; // ISO date-time\n  content: string;\n}\n\nconst TMT_LEVEL_INPUT_LIMITS: Record<TmtLevel, { totalChars: number; itemChars: number; maxItems: number }> = {\n  hour: { totalChars: 48_000, itemChars: 2_000, maxItems: 64 },\n  day: { totalChars: 64_000, itemChars: 1_800, maxItems: 96 },\n  week: { totalChars: 72_000, itemChars: 1_600, maxItems: 120 },\n  persona: { totalChars: 80_000, itemChars: 1_600, maxItems: 120 },\n};\n\nexport function capTmtSummaryInputs(inputs: string[], level: TmtLevel): string[] {\n  const { totalChars, itemChars, maxItems } = TMT_LEVEL_INPUT_LIMITS[level];\n  if (inputs.length === 0) return [];\n\n  const capped: string[] = [];\n  let usedChars = 0;\n\n  for (const raw of inputs) {\n    if (capped.length >= maxItems || usedChars >= totalChars) break;\n    const trimmed = raw.trim();\n    if (!trimmed) continue;\n\n    const next = trimmed.length > itemChars ? `${trimmed.slice(0, itemChars - 1)}…` : trimmed;\n    const separator = capped.length === 0 ? 0 : 2;\n    if (usedChars + separator + next.length > totalChars) break;\n    capped.push(next);\n    usedChars += separator + next.length;\n  }\n\n  if (capped.length > 0) return capped;\n  const fallback = inputs[0]?.trim() ?? \"\";\n  if (!fallback) return [];\n  return [fallback.length > itemChars ? `${fallback.slice(0, itemChars - 1)}…` : fallback];\n}\n\n// ── Path helpers ────────────────────────────────────────────────────────────\n\nexport function tmtDir(baseDir: string): string {\n  return path.join(baseDir, TMT_DIR);\n}\n\nexport function hourNodePath(baseDir: string, date: string, hour: string): string {\n  return path.join(tmtDir(baseDir), date, `hour-${hour}.md`);\n}\n\nexport function dayNodePath(baseDir: string, date: string): string {\n  return path.join(tmtDir(baseDir), date, \"day.md\");\n}\n\nexport function weekNodePath(baseDir: string, weekKey: string): string {\n  return path.join(tmtDir(baseDir), `week-${weekKey}.md`);\n}\n\nexport function personaNodePath(baseDir: string): string {\n  return path.join(tmtDir(baseDir), \"persona.md\");\n}\n\n// ── Frontmatter helpers ─────────────────────────────────────────────────────\n\nexport function serialiseTmtNode(fm: TmtNodeFrontmatter, summary: string): string {\n  const yaml = [\n    \"---\",\n    `level: ${fm.level}`,\n    `periodStart: \"${fm.periodStart}\"`,\n    `periodEnd: \"${fm.periodEnd}\"`,\n    `memoryCount: ${fm.memoryCount}`,\n    `sourceIds: [${fm.sourceIds.map((id) => `\"${id}\"`).join(\", \")}]`,\n    `builtAt: \"${fm.builtAt}\"`,\n    \"---\",\n  ].join(\"\\n\");\n  return `${yaml}\\n\\n${summary}\\n`;\n}\n\nexport function parseIsoDate(iso: string): string {\n  return iso.slice(0, 10); // YYYY-MM-DD\n}\n\nexport function parseIsoHour(iso: string): string {\n  return iso.slice(11, 13); // HH\n}\n\n// Returns ISO week key: YYYY-WW\nexport function isoWeekKey(date: Date): string {\n  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));\n  const dayNum = d.getUTCDay() || 7;\n  d.setUTCDate(d.getUTCDate() + 4 - dayNum);\n  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));\n  const weekNo = Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);\n  return `${d.getUTCFullYear()}-${String(weekNo).padStart(2, \"0\")}`;\n}\n\n// ── TmtBuilder ──────────────────────────────────────────────────────────────\n\nexport type SummarizeFn = (memories: string[], level: TmtLevel) => Promise<string>;\n\nexport class TmtBuilder {\n  constructor(\n    private readonly baseDir: string,\n    private readonly cfg: TmtConfig,\n  ) {}\n\n  /**\n   * Called after each consolidation pass.\n   * Groups memories by hour, builds any missing hour nodes,\n   * then rolls up to day → week → persona if needed.\n   * All errors are caught and logged; never throws.\n   */\n  async maybeRebuildNodes(\n    memories: MemoryEntry[],\n    summarize: SummarizeFn,\n  ): Promise<void> {\n    if (!this.cfg.temporalMemoryTreeEnabled || memories.length === 0) return;\n    try {\n      await mkdir(tmtDir(this.baseDir), { recursive: true });\n      await this.buildHourNodes(memories, summarize);\n      await this.buildDayNodes(memories, summarize);\n      await this.buildWeekNodes(memories, summarize);\n      await this.buildPersonaNode(summarize);\n    } catch (err) {\n      console.warn(`[engram] tmt: rebuild failed (ignored): ${err}`);\n    }\n  }\n\n  private async buildHourNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Group by date+hour\n    const byHour = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const date = parseIsoDate(m.created);\n      const hour = parseIsoHour(m.created);\n      const key = `${date}::${hour}`;\n      if (!byHour.has(key)) byHour.set(key, []);\n      byHour.get(key)!.push(m);\n    }\n\n    for (const [key, entries] of byHour) {\n      if (entries.length < this.cfg.tmtHourlyMinMemories) continue;\n      const [date, hour] = key.split(\"::\");\n      const nodePath = hourNodePath(this.baseDir, date, hour);\n\n      // Rebuild if missing or if more memories arrived for this hour\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {\n            shouldBuild = true; // more memories now — rebuild\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      let summary: string;\n      try {\n        summary = await summarize(capTmtSummaryInputs(entries.map((e) => e.content), \"hour\"), \"hour\");\n      } catch (err) {\n        console.warn(`[engram] tmt: hour node summarize failed for ${key} (ignored): ${err}`);\n        continue;\n      }\n      const sortedCreated = entries.map((e) => e.created).sort();\n      const fm: TmtNodeFrontmatter = {\n        level: \"hour\",\n        periodStart: sortedCreated[0],\n        periodEnd: sortedCreated[sortedCreated.length - 1],\n        memoryCount: entries.length,\n        sourceIds: entries.map((e) => e.id),\n        builtAt: new Date().toISOString(),\n      };\n      await mkdir(path.dirname(nodePath), { recursive: true });\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    }\n  }\n\n  private async buildDayNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Group by date\n    const byDate = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const date = parseIsoDate(m.created);\n      if (!byDate.has(date)) byDate.set(date, []);\n      byDate.get(date)!.push(m);\n    }\n\n    for (const [date, entries] of byDate) {\n      const nodePath = dayNodePath(this.baseDir, date);\n      // Rebuild day node if it doesn't exist or if memory count changed\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {\n            shouldBuild = true; // more memories now — rebuild\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      // Per-hour: use hour node summary if available, raw content otherwise\n      const inputs: string[] = [];\n      const hourToEntries = new Map<string, MemoryEntry[]>();\n      for (const e of entries) {\n        const h = parseIsoHour(e.created);\n        if (!hourToEntries.has(h)) hourToEntries.set(h, []);\n        hourToEntries.get(h)!.push(e);\n      }\n      for (const [h, hourEntries] of hourToEntries) {\n        const hPath = hourNodePath(this.baseDir, date, h);\n        if (fs.existsSync(hPath)) {\n          try {\n            const hContent = await readFile(hPath, \"utf8\");\n            const hSummary = hContent.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n            if (hSummary) { inputs.push(hSummary); continue; }\n          } catch { /* fall through to raw content */ }\n        }\n        inputs.push(...hourEntries.map((e) => e.content));\n      }\n      if (inputs.length === 0) inputs.push(...entries.map((e) => e.content));\n\n      let summary: string;\n      try {\n        summary = await summarize(capTmtSummaryInputs(inputs, \"day\"), \"day\");\n      } catch (err) {\n        console.warn(`[engram] tmt: day node summarize failed for ${date} (ignored): ${err}`);\n        continue;\n      }\n      const sortedCreated = entries.map((e) => e.created).sort();\n      const fm: TmtNodeFrontmatter = {\n        level: \"day\",\n        periodStart: sortedCreated[0],\n        periodEnd: sortedCreated[sortedCreated.length - 1],\n        memoryCount: entries.length,\n        sourceIds: entries.map((e) => e.id),\n        builtAt: new Date().toISOString(),\n      };\n      await mkdir(path.dirname(nodePath), { recursive: true });\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    }\n  }\n\n  /**\n   * Build or update week-level nodes from the day nodes already on disk.\n   * Groups memories by ISO week; for each week that has a day node but no\n   * (or stale) week node, reads day node summaries and builds a week node.\n   * Fail-open: errors per week are caught and skipped.\n   */\n  private async buildWeekNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Determine which ISO weeks appear in this memory batch\n    const weekToEntries = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const week = isoWeekKey(new Date(m.created));\n      if (!weekToEntries.has(week)) weekToEntries.set(week, []);\n      weekToEntries.get(week)!.push(m);\n    }\n\n    for (const [week, entries] of weekToEntries) {\n      const nodePath = weekNodePath(this.baseDir, week);\n\n      // Rebuild if missing or if memory count grew\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {\n            shouldBuild = true;\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      try {\n        // Collect day-node summaries for days that fall in this week\n        const dir = tmtDir(this.baseDir);\n        let allDirs: string[] = [];\n        try { allDirs = await readdir(dir); } catch { continue; }\n        const dateDirs = allDirs.filter((d) => /^\\d{4}-\\d{2}-\\d{2}$/.test(d));\n\n        const daySummaries: string[] = [];\n        for (const dateDir of dateDirs) {\n          const w = isoWeekKey(new Date(dateDir + \"T00:00:00Z\"));\n          if (w !== week) continue;\n          const dayPath = dayNodePath(this.baseDir, dateDir);\n          if (fs.existsSync(dayPath)) {\n            try {\n              const content = await readFile(dayPath, \"utf8\");\n              const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n              if (summary) daySummaries.push(summary);\n            } catch { /* skip */ }\n          }\n        }\n\n        // Fall back to raw memory content if no day summaries available\n        const inputs = daySummaries.length > 0 ? daySummaries : entries.map((e) => e.content);\n        const summary = await summarize(capTmtSummaryInputs(inputs, \"week\"), \"week\");\n        const sortedCreated = entries.map((e) => e.created).sort();\n        const fm: TmtNodeFrontmatter = {\n          level: \"week\",\n          periodStart: sortedCreated[0],\n          periodEnd: sortedCreated[sortedCreated.length - 1],\n          memoryCount: entries.length,\n          sourceIds: entries.map((e) => e.id),\n          builtAt: new Date().toISOString(),\n        };\n        await mkdir(path.dirname(nodePath), { recursive: true });\n        await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n      } catch (err) {\n        console.warn(`[engram] tmt: week node build failed for ${week} (ignored): ${err}`);\n      }\n    }\n  }\n\n  /**\n   * Build or update the persona node from the most recent week-level summaries.\n   * Reads up to 4 recent week nodes and synthesizes a persona-level narrative.\n   * Fail-open: skips silently if no week nodes exist or summarize fails.\n   */\n  private async buildPersonaNode(summarize: SummarizeFn): Promise<void> {\n    try {\n      const dir = tmtDir(this.baseDir);\n      let allFiles: string[] = [];\n      try { allFiles = await readdir(dir); } catch { return; }\n\n      const weekFiles = allFiles\n        .filter((f) => /^week-\\d{4}-\\d{2}\\.md$/.test(f))\n        .sort()\n        .reverse()\n        .slice(0, 4); // Use at most 4 recent weeks\n\n      if (weekFiles.length === 0) return;\n\n      const weekSummaries: string[] = [];\n      let totalCount = 0;\n      let earliestStart: string | undefined;\n      let latestEnd: string | undefined;\n      for (const f of weekFiles) {\n        try {\n          const content = await readFile(path.join(dir, f), \"utf8\");\n          const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n          if (summary) weekSummaries.push(summary);\n          const countMatch = content.match(/memoryCount: (\\d+)/);\n          if (countMatch) totalCount += parseInt(countMatch[1], 10);\n          const startMatch = content.match(/periodStart: \"([^\"]+)\"/);\n          const endMatch = content.match(/periodEnd: \"([^\"]+)\"/);\n          if (startMatch) {\n            if (!earliestStart || startMatch[1] < earliestStart) earliestStart = startMatch[1];\n          }\n          if (endMatch) {\n            if (!latestEnd || endMatch[1] > latestEnd) latestEnd = endMatch[1];\n          }\n        } catch { /* skip */ }\n      }\n\n      if (weekSummaries.length === 0) return;\n\n      const nodePath = personaNodePath(this.baseDir);\n\n      // Skip rebuild if persona node already reflects current week data\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) !== totalCount) {\n            shouldBuild = true;\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) return;\n\n      const summary = await summarize(capTmtSummaryInputs(weekSummaries, \"persona\"), \"persona\");\n\n      const now = new Date().toISOString();\n      const fm: TmtNodeFrontmatter = {\n        level: \"persona\",\n        periodStart: earliestStart ?? now,\n        periodEnd: latestEnd ?? now,\n        memoryCount: totalCount,\n        sourceIds: [],\n        builtAt: now,\n      };\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    } catch (err) {\n      console.warn(`[engram] tmt: persona node build failed (ignored): ${err}`);\n    }\n  }\n\n  /**\n   * Return the summary text of the most relevant TMT node for a given prompt.\n   * Preference: day node for today > most recent day node.\n   * Returns null if no nodes exist or feature is disabled.\n   */\n  async getMostRelevantNode(): Promise<{ level: TmtLevel; summary: string } | null> {\n    if (!this.cfg.temporalMemoryTreeEnabled) return null;\n    try {\n      const dir = tmtDir(this.baseDir);\n      if (!fs.existsSync(dir)) return null;\n\n      // Try today's day node first\n      const today = new Date().toISOString().slice(0, 10);\n      const todayDay = dayNodePath(this.baseDir, today);\n      if (fs.existsSync(todayDay)) {\n        const content = await readFile(todayDay, \"utf8\");\n        const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n        if (summary) return { level: \"day\", summary };\n      }\n\n      // Find most recent date directory\n      let entries: string[] = [];\n      try { entries = await readdir(dir); } catch { return null; }\n      const dateDirs = entries.filter((e) => /^\\d{4}-\\d{2}-\\d{2}$/.test(e)).sort().reverse();\n\n      for (const dateDir of dateDirs) {\n        const dayPath = dayNodePath(this.baseDir, dateDir);\n        if (fs.existsSync(dayPath)) {\n          const content = await readFile(dayPath, \"utf8\");\n          const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n          if (summary) return { level: \"day\", summary };\n        }\n      }\n      return null;\n    } catch {\n      return null;\n    }\n  }\n}\n"],"mappings":"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","names":["summary"]}