@glassly/engine 0.3.5-dev.772 → 0.3.5-dev.776

package/src/services/MemoryStore.ts

@@ -17,7 +17,14 @@
  * user-scoped keys so existing history survives the move.
  */
 
-import type {MemoryEntry, MemoryNoteSource, MemorySession, MemorySummary} from "@glassly/miniapp"
+import type {
+  MemoryBackup,
+  MemoryEntry,
+  MemoryImportResult,
+  MemoryNoteSource,
+  MemorySession,
+  MemorySummary,
+} from "@glassly/miniapp"
 
 import {searchMemoryEntries} from "../utils/memory/search"
 
@@ -91,6 +98,14 @@ export interface MemoryStats {
   oldestAt: number | null
 }
 
+/** Thrown by importBackup for anything that isn't a backup this build can read. */
+export class MemoryBackupError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "MemoryBackupError"
+  }
+}
+
 export function hourStartOf(ms: number): number {
   return Math.floor(ms / HOUR_MS) * HOUR_MS
 }
@@ -359,6 +374,65 @@ export class MemoryStore {
     return Math.max(...hours)
   }
 
+  /** The whole timeline as a backup file body (Settings > Memory, session.memory.exportFile). */
+  async exportBackup(): Promise<MemoryBackup> {
+    await this.ensureLoaded()
+    return {
+      format: "glassly-memory",
+      version: 1,
+      exportedAt: Date.now(),
+      entries: [...this.entries],
+      summaries: [...this.summaries].sort((a, b) => a.hourStart - b.hourStart),
+    }
+  }
+
+  /**
+   * Merge a backup into the timeline. Skips entries whose id is stored, notes
+   * whose text is already in the same hour, and hours that already have a
+   * summary. Throws MemoryBackupError when `data` isn't a memory backup.
+   */
+  async importBackup(data: unknown): Promise<MemoryImportResult> {
+    const backup = parseBackup(data)
+    await this.ensureLoaded()
+    const result: MemoryImportResult = {entries: 0, summaries: 0, skipped: 0}
+
+    const ids = new Set(this.entries.map((e) => e.id))
+    const noteKeys = new Set(this.entries.filter((e) => e.kind === "note").map(noteKey))
+    for (const entry of backup.entries) {
+      const key = entry.kind === "note" ? noteKey(entry) : null
+      if (ids.has(entry.id) || (key != null && noteKeys.has(key))) {
+        result.skipped++
+        continue
+      }
+      ids.add(entry.id)
+      if (key != null) noteKeys.add(key)
+      this.entries.push(entry)
+      result.entries++
+    }
+
+    const byHour = new Map(this.summaries.map((s) => [s.hourStart, s]))
+    for (const summary of backup.summaries) {
+      if (byHour.get(summary.hourStart)?.text.trim()) {
+        result.skipped++
+        continue
+      }
+      byHour.set(summary.hourStart, summary)
+      result.summaries++
+    }
+
+    if (result.entries > 0) {
+      this.entries.sort((a, b) => a.at - b.at)
+      this.prune()
+      await this.persistLog()
+    }
+    if (result.summaries > 0) {
+      this.summaries = [...byHour.values()].sort((a, b) => a.hourStart - b.hourStart).slice(-MEMORY_BOUNDS.maxSummaries)
+      await this.persistSummaries()
+    }
+    if (result.entries > 0 || result.summaries > 0) this.emitChanged()
+    return result
+  }
+
   /** Plain-text export of a scope, for the OS share sheet. */
   async exportText(scope: "session" | "day" | "all", at?: number): Promise<string> {
     const sessions = (await this.sessionList()).filter((s) => {
@@ -563,10 +637,45 @@ function parseArray(raw: unknown): unknown[] {
 function normalize(text: string): string {
   return text
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, " ")
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
     .trim()
 }
 
+function noteKey(entry: MemoryEntry): string {
+  return `${hourStartOf(entry.at)}:${normalize(entry.text)}`
+}
+
+function parseBackup(data: unknown): {entries: MemoryEntry[]; summaries: MemorySummary[]} {
+  const raw = data as Record<string, unknown> | null
+  if (!raw || typeof raw !== "object" || raw.format !== "glassly-memory" || !Array.isArray(raw.entries)) {
+    throw new MemoryBackupError("Not a Glassly memory backup")
+  }
+  if (typeof raw.version !== "number" || raw.version > 1) {
+    throw new MemoryBackupError(`Unsupported memory backup version ${String(raw.version)}`)
+  }
+  const entries: MemoryEntry[] = []
+  for (const v of raw.entries) {
+    if (!isEntry(v) || !v.id || !v.text.trim() || !Number.isFinite(v.at)) continue
+    entries.push({
+      id: v.id,
+      kind: v.kind,
+      text: v.text.trim(),
+      at: v.at,
+      speakerId: typeof v.speakerId === "string" ? v.speakerId : null,
+      ...(typeof v.resolvedSpeakerName === "string" && v.resolvedSpeakerName
+        ? {resolvedSpeakerName: v.resolvedSpeakerName}
+        : {}),
+      language: typeof v.language === "string" ? v.language : null,
+      ...(v.kind === "note" ? {source: v.source === "voice" || v.source === "auto" ? v.source : "ui"} : {}),
+    })
+  }
+  const summaries = (Array.isArray(raw.summaries) ? raw.summaries : [])
+    .filter(isSummary)
+    .filter((s) => s.text.trim() && Number.isFinite(s.hourStart))
+    .map((s) => ({hourStart: s.hourStart, text: s.text, createdAt: s.createdAt}))
+  return {entries, summaries}
+}
+
 function isEntry(v: unknown): v is MemoryEntry {
   if (!v || typeof v !== "object") return false
   const e = v as Record<string, unknown>

package/src/services/memoryBackupFile.ts

@@ -0,0 +1,50 @@
+/**
+ * Memory backup files: the share-sheet export and file-picker import behind
+ * Settings > Memory and session.memory.exportFile/importFile.
+ */
+
+import type {MemoryExportResult, MemoryImportResult} from "@glassly/miniapp"
+import {File, Paths} from "expo-file-system"
+import {Platform} from "react-native"
+import Share from "react-native-share"
+
+import {MemoryBackupError} from "./MemoryStore"
+import {memoryStore} from "./memoryStoreInstance"
+
+// Some Android document providers report .json files as octet-stream.
+const PICK_MIME_TYPES =
+  Platform.OS === "android" ? ["application/json", "application/octet-stream"] : ["application/json"]
+
+export async function exportMemoryFile(): Promise<MemoryExportResult> {
+  const backup = await memoryStore.exportBackup()
+  const filename = `glassly-memory-${localDate(backup.exportedAt)}.json`
+  const file = new File(Paths.cache, filename)
+  file.writeSync(JSON.stringify(backup))
+  try {
+    await Share.open({url: file.uri, type: "application/json", filename, title: "Glassly memory"})
+    return {success: true}
+  } catch (error: any) {
+    // react-native-share rejects when the user dismisses the sheet.
+    if (error?.message?.includes("User did not share")) return {success: false, cancelled: true}
+    throw error
+  }
+}
+
+/** Resolves null when the user cancels the picker. */
+export async function importMemoryFile(): Promise<MemoryImportResult | null> {
+  const picked = await File.pickFileAsync({mimeTypes: PICK_MIME_TYPES})
+  if (picked.canceled) return null
+  let data: unknown
+  try {
+    data = JSON.parse(await picked.result.text())
+  } catch {
+    throw new MemoryBackupError("Not a Glassly memory backup")
+  }
+  return memoryStore.importBackup(data)
+}
+
+function localDate(ms: number): string {
+  const d = new Date(ms)
+  const pad = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
+}