mem-os-python 1.6.27__py3-none-any.whl

memos/_js/tamper-log.js

@@ -0,0 +1,327 @@
+/**
+ * Tamper-evident mutation log.
+ *
+ * Every memory mutation (store / import / update / forget) appends one
+ * entry to an append-only, hash-chained log stored alongside the nodes
+ * in the same database. `verifyTamperLog()` recomputes the chain and —
+ * with the deep check — cross-checks each node's current full state
+ * against the latest log entry, so it detects:
+ *
+ * - edited, deleted, or reordered log rows (chain linkage breaks),
+ * - nodes edited/deleted directly in the DB without a log entry
+ *   (state-hash mismatch / missing-entry mismatch),
+ * - nodes resurrected after a `forget` entry.
+ *
+ * Honest threat model: the log is tamper-*evident*, not tamper-*proof*.
+ * An attacker with full write access to the database file can rewrite
+ * the entire chain from genesis and the log alone cannot tell. What
+ * stops that is an externally anchored checkpoint: `memos log
+ * checkpoint` prints the tip hash; write it down (paper, another
+ * machine, a signed commit) and `memos log verify --expect <hash>`
+ * later proves the chain still ends where you left it. Without an
+ * external anchor, a full-chain rewrite is undetectable — by anyone,
+ * with any local-only scheme.
+ */
+import { createHash } from "node:crypto";
+/** Fixed `prevHash` for the first entry — a domain-separated constant. */
+export const GENESIS_PREV = "memos-tamper-log-genesis-v1:" +
+    createHash("sha256").update("memos-tamper-log-genesis-v1").digest("hex");
+export function sha256hex(s) {
+    return createHash("sha256").update(s, "utf8").digest("hex");
+}
+/**
+ * Canonical JSON: object keys sorted recursively, arrays in order.
+ * Two equal states always serialize to the same string regardless of
+ * insertion order — required for a stable hash.
+ */
+export function canonicalJson(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        const keys = Object.keys(value).sort();
+        return `{${keys
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+/**
+ * Hash of a node's full mutable state at mutation time. Covers content,
+ * summary, type, tags (sorted), importance, namespace, metadata,
+ * provenance/source, validity window, TTL, and creation/update
+ * timestamps — everything a mutation could change. Deliberately excludes
+ * `accessCount`/`lastAccessed`: reads bump those without a log entry,
+ * so hashing them would false-positive on every retrieval.
+ */
+export function nodeHash(node) {
+    // The SQLite adapter folds top-level `confidence`/`evidenceCount`
+    // into the metadata JSON blob on write (and reads them back out of
+    // it), so hash the folded form: that way the in-memory node passed
+    // to the logger and the node read back from the DB hash identically.
+    const metadata = { ...(node.metadata ?? {}) };
+    if (node.confidence !== undefined && metadata.confidence === undefined) {
+        metadata.confidence = node.confidence;
+    }
+    if (node.evidenceCount !== undefined &&
+        metadata.evidenceCount === undefined) {
+        metadata.evidenceCount = node.evidenceCount;
+    }
+    const state = [
+        node.id,
+        node.content,
+        node.summary,
+        node.type,
+        [...(node.tags ?? [])].sort().join("\u0000"),
+        String(node.importance),
+        node.namespace ?? "",
+        canonicalJson(metadata),
+        String(node.source ?? ""),
+        canonicalJson(node.provenance ?? null),
+        String(node.validFrom ?? ""),
+        String(node.validTo ?? ""),
+        String(node.expiresAt ?? ""),
+        String(node.createdAt),
+        String(node.updatedAt),
+    ].join("\u0001");
+    return sha256hex("memos-node-state-v1:" + state);
+}
+/**
+ * First-day entry hash (v1): content-only, seq not bound. Kept solely
+ * to verify rows written before the full-state format; see the
+ * migration in SQLiteStorage init.
+ */
+function legacyEntryHash(e) {
+    return sha256hex([
+        "memos-tamper-entry-v1",
+        e.ts,
+        e.op,
+        e.nodeId,
+        e.contentHash,
+        e.prevHash,
+    ].join("|"));
+}
+/** First-day content hash, for the legacy cross-check. */
+function legacyContentHash(content) {
+    return sha256hex("memos-node-content-v1:" + content);
+}
+/**
+ * Hash of one log entry. The chain position `seq` is bound into the
+ * hash, so an entry cannot be replayed at a different position without
+ * invalidating it. Canonical field order and a versioned prefix make
+ * the serialization unambiguous — no JSON key-ordering games.
+ */
+export function entryHash(e) {
+    return sha256hex([
+        "memos-tamper-entry-v2",
+        String(e.seq),
+        String(e.ts),
+        e.op,
+        e.nodeId,
+        e.nodeHash,
+        e.prevHash,
+    ].join("|"));
+}
+/**
+ * Append one mutation to the log. Fail-open: when the storage adapter
+ * doesn't implement the log, or the write fails, the mutation itself
+ * is never blocked — the log is evidence, not a gate. The adapter
+ * assigns the chain position atomically (tip lookup, seq allocation,
+ * hash, insert in one transaction).
+ */
+export async function appendTamperEntry(storage, op, node, ts = Date.now()) {
+    if (!storage.appendTamperEntry || !storage.readTamperLog)
+        return;
+    try {
+        await storage.appendTamperEntry({
+            ts,
+            op,
+            nodeId: node.id,
+            nodeHash: nodeHash(node),
+        });
+    }
+    catch {
+        // Fail-open: a logging failure must never break the write path.
+    }
+}
+/**
+ * Verify the log: chain integrity (seq continuity, prev-hash linkage,
+ * entry-hash recomputation) plus a deep cross-check of every node's
+ * current content against its latest log entry.
+ *
+ * `expectTip` anchors the chain to an externally recorded checkpoint:
+ * verification fails unless the current tip hash equals it.
+ */
+export async function verifyTamperLog(storage, opts = {}) {
+    const empty = {
+        ok: true,
+        supported: true,
+        entriesChecked: 0,
+        unloggedNodes: 0,
+        legacyEntries: 0,
+        issues: [],
+        tipHash: null,
+    };
+    if (!storage.readTamperLog) {
+        return { ...empty, supported: false };
+    }
+    let entries;
+    try {
+        entries = await storage.readTamperLog();
+    }
+    catch {
+        return { ...empty, supported: false };
+    }
+    const result = {
+        ...empty,
+        entriesChecked: entries.length,
+        tipHash: entries.length > 0 ? entries[entries.length - 1].entryHash : null,
+    };
+    const fail = (issue) => {
+        result.ok = false;
+        result.issues.push(issue);
+    };
+    // --- Chain integrity -------------------------------------------------
+    let prev = GENESIS_PREV;
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        const expectedSeq = i + 1;
+        if (e.seq !== expectedSeq) {
+            fail({
+                kind: "broken_chain",
+                seq: e.seq,
+                detail: `sequence break at row ${i + 1}: expected seq ${expectedSeq}, found ${e.seq} (rows deleted or reordered)`,
+            });
+            break;
+        }
+        if (e.prevHash !== prev) {
+            fail({
+                kind: "broken_chain",
+                seq: e.seq,
+                detail: `prevHash mismatch at seq ${e.seq}: chain was edited or reordered`,
+            });
+            break;
+        }
+        const recomputed = entryHash({
+            seq: e.seq,
+            ts: e.ts,
+            op: e.op,
+            nodeId: e.nodeId,
+            nodeHash: e.nodeHash,
+            prevHash: e.prevHash,
+        });
+        let legacy = false;
+        if (recomputed !== e.entryHash) {
+            // Fall back to the first-day v1 format (content-only, seq
+            // unbound). A v2 row can never verify as v1 — the domain
+            // prefixes differ — so this only ever matches genuine old rows.
+            const legacyRecomputed = legacyEntryHash({
+                ts: e.ts,
+                op: e.op,
+                nodeId: e.nodeId,
+                contentHash: e.nodeHash,
+                prevHash: e.prevHash,
+            });
+            if (legacyRecomputed === e.entryHash) {
+                legacy = true;
+                result.legacyEntries += 1;
+            }
+        }
+        if (!legacy && recomputed !== e.entryHash) {
+            fail({
+                kind: "broken_chain",
+                seq: e.seq,
+                nodeId: e.nodeId,
+                detail: `entry hash mismatch at seq ${e.seq}: row was edited in place`,
+            });
+            break;
+        }
+        prev = e.entryHash;
+    }
+    // --- Deep cross-check: DB state vs latest log entry per node ---------
+    if (result.ok && typeof storage.queryNodes === "function") {
+        const latest = new Map();
+        const legacyNodes = new Set();
+        // Re-derive legacy status per entry (same v1 fallback as above).
+        for (const e of entries) {
+            latest.set(e.nodeId, e);
+            const v2 = entryHash({
+                seq: e.seq,
+                ts: e.ts,
+                op: e.op,
+                nodeId: e.nodeId,
+                nodeHash: e.nodeHash,
+                prevHash: e.prevHash,
+            });
+            if (v2 !== e.entryHash &&
+                legacyEntryHash({
+                    ts: e.ts,
+                    op: e.op,
+                    nodeId: e.nodeId,
+                    contentHash: e.nodeHash,
+                    prevHash: e.prevHash,
+                }) === e.entryHash) {
+                legacyNodes.add(e.nodeId);
+            }
+        }
+        try {
+            const rows = await storage.queryNodes({ limit: 100_000 });
+            const live = new Map();
+            for (const r of rows)
+                live.set(r.node.id, r.node);
+            for (const [nodeId, entry] of latest) {
+                const node = live.get(nodeId);
+                if (entry.op === "forget") {
+                    if (node) {
+                        fail({
+                            kind: "resurrected",
+                            seq: entry.seq,
+                            nodeId,
+                            detail: `node ${nodeId.slice(0, 8)} has a forget entry (seq ${entry.seq}) but still exists in the DB`,
+                        });
+                    }
+                    continue;
+                }
+                if (!node) {
+                    fail({
+                        kind: "deleted_without_log",
+                        seq: entry.seq,
+                        nodeId,
+                        detail: `node ${nodeId.slice(0, 8)} is gone from the DB but its latest log entry (seq ${entry.seq}, op ${entry.op}) is not a forget`,
+                    });
+                    continue;
+                }
+                // Legacy v1 rows recorded a content-only hash: cross-check
+                // content, not full state.
+                const expected = legacyNodes.has(nodeId)
+                    ? legacyContentHash(node.content)
+                    : nodeHash(node);
+                if (expected !== entry.nodeHash) {
+                    fail({
+                        kind: "content_mismatch",
+                        seq: entry.seq,
+                        nodeId,
+                        detail: `node ${nodeId.slice(0, 8)} state does not match its latest log entry (seq ${entry.seq}, op ${entry.op}): edited without logging`,
+                    });
+                }
+            }
+            for (const nodeId of live.keys()) {
+                if (!latest.has(nodeId))
+                    result.unloggedNodes += 1;
+            }
+        }
+        catch {
+            // Deep check is best-effort; chain verification above stands alone.
+        }
+    }
+    // --- External checkpoint anchor --------------------------------------
+    if (opts.expectTip && result.tipHash !== opts.expectTip) {
+        fail({
+            kind: "tip_mismatch",
+            detail: `tip hash ${result.tipHash ?? "(empty log)"} does not match the expected checkpoint ${opts.expectTip}: the chain was rewritten after the checkpoint`,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=tamper-log.js.map

memos/_js/tamper-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tamper-log.js","sourceRoot":"","sources":["../src/tamper-log.ts"],"names":[],"mappings":"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"}

memos/_js/temporal.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Deterministic temporal parsing for MemOS — no LLM on any path.
+ *
+ * Why hand-rolled instead of `chrono`:
+ * - `npm install chrono` resolves to a *timezone-offset* library, not a
+ *   date parser (the parser lives in `chrono-node`).
+ * - `chrono-node` (v2.10.1, evaluated 2026-09-19) is zero-dependency and
+ *   dual CJS/ESM with types, but ships ~7MB of locale data and its
+ *   weekday/time-of-day defaults ("at 3pm" at 18:00 silently rolls to
+ *   tomorrow, multi-expression sentences need ad-hoc disambiguation)
+ *   would still need a deterministic wrapper for MemOS's exact phrase
+ *   set. A minimal hand-rolled parser is smaller, has zero dependencies,
+ *   and every rule below is explicit and testable. Revisit if the phrase
+ *   set grows beyond the documented grammar.
+ *
+ * Grammar (all case-insensitive, evaluated against an explicit `now`):
+ * - Relative: "in 2 hours", "in 3 days", "3 days later"
+ * - Day words: "today", "tonight" (= today 21:00), "tomorrow"
+ * - Weekdays: "Monday", "on Monday", "this Thursday", "next Friday",
+ *   "last Friday"
+ * - Month/day: "Sept 24", "September 24th" (year-less → yearCertain=false)
+ * - ISO: "2026-09-24"
+ * - Times: "at 3pm", "at 2:30pm", "at 15:00", "noon", "midnight"
+ *   (a bare time attaches to today, rolling to tomorrow when past)
+ * - Date+time adjacency merges: "tomorrow at 2pm", "at 3pm tomorrow"
+ *
+ * Deterministic rules (documented, no guessing):
+ * 1. When several temporal expressions occur, the LAST one wins — this
+ *    mirrors how speakers refine ("tomorrow, on Monday" → Monday).
+ * 2. Adjacent date+date ("tomorrow on Monday") refines to the second date.
+ * 3. Adjacent date+time merges into one datetime.
+ * 4. Bare/"on" weekday = next occurrence strictly after today;
+ *    "this <day>" = upcoming occurrence including today; "next <day>" =
+ *    next occurrence strictly after today; "last <day>" = most recent
+ *    past occurrence.
+ * 5. Day-grain results resolve to local start-of-day 00:00 (an all-day
+ *    event starts when the day starts), except "tonight" → 21:00.
+ *
+ * @module @memos/temporal
+ */
+/** Temporal resolution of a parsed expression. */
+export type TemporalGrain = "day" | "hour" | "minute";
+export interface ParsedTemporal {
+    /** Resolved local datetime. */
+    at: Date;
+    /** Resolution: day (date only), hour, or minute. */
+    grain: TemporalGrain;
+    /** The exact source text that produced this parse. */
+    text: string;
+    /** False when the expression carried no year ("Sept 24", "June 1"). */
+    yearCertain: boolean;
+}
+/** A bare relative offset ("3 days later") awaiting an anchor. */
+export interface TemporalDuration {
+    years: number;
+    months: number;
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    /** The exact source text that produced this duration. */
+    text: string;
+}
+/**
+ * Parse the temporal expression(s) in free text.
+ *
+ * Deterministic given `now`: no system clock reads, no randomness, no LLM.
+ * When several expressions occur, the LAST one wins (speaker-refinement
+ * rule); adjacent date+time pairs merge ("tomorrow at 2pm"), and adjacent
+ * date+date pairs refine to the second ("tomorrow on Monday" → Monday).
+ *
+ * @param text — Free text possibly containing a temporal expression.
+ * @param now  — Reference time; ALL resolution is relative to this.
+ * @returns The parsed expression, or null when none is found.
+ */
+export declare function parseTemporal(text: string, now: Date): ParsedTemporal | null;
+/**
+ * Parse a bare relative offset ("3 days later", "in 2 hours") as a
+ * DURATION — no anchor applied. Used for event updates ("moved 3 days
+ * later"), where the anchor is the event's current datetime, NOT now.
+ *
+ * @param text — Free text possibly containing a relative offset.
+ * @returns The duration, or null when no offset is found.
+ */
+export declare function parseDuration(text: string): TemporalDuration | null;
+/**
+ * Apply a duration to an anchor date (calendar-aware for months/years).
+ * Deterministic: same anchor + same duration = same result.
+ */
+export declare function addDuration(anchor: Date, d: TemporalDuration): Date;
+//# sourceMappingURL=temporal.d.ts.map

memos/_js/temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../src/temporal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,EAAE,EAAE,IAAI,CAAC;IACT,oDAAoD;IACpD,KAAK,EAAE,aAAa,CAAC;IACrB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;CACd;AAsWD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,cAAc,GAAG,IAAI,CAqG5E;AAKD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA0CnE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAYnE"}