memgres 0.13.0__tar.gz → 0.13.2__tar.gz

{memgres-0.13.0 → memgres-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memgres
-Version: 0.13.0
+Version: 0.13.2
 Summary: Drop-in memory for AI agents: one Postgres, lexical + semantic recall, diff-versioned history, GDPR-erasable.
 Author: mozgsml
 License-Expression: MIT

{memgres-0.13.0 → memgres-0.13.2}/memgres/_version.py

@@ -8,4 +8,4 @@ here at release; nowhere else carries the number.
 PEP 440: a ``.devN`` suffix marks an unreleased build ahead of the last tag.
 """
 
-__version__ = "0.13.0"
+__version__ = "0.13.2"

{memgres-0.13.0 → memgres-0.13.2}/memgres/migrations/0023_relink_after_parser_fix.sql

@@ -13,4 +13,17 @@
 --
 -- Additive by nature — an older client reading this database is no worse off
 -- than it was, so the compatibility floor does not move.
-UPDATE memgres_meta SET links_built = false;
+-- ONCE. Every migration file runs again at every start (they are meant to be
+-- idempotent), and a bare UPDATE here cleared the flag on every start — so every
+-- start rebuilt the whole link graph, and two servers starting together raced on
+-- it. The marker column makes the clearing happen the first time only; on a
+-- database that has been through this file before, it happens one last time.
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                   WHERE table_schema = current_schema() AND table_name = 'memgres_meta'
+                     AND column_name = 'relinked_after_0023') THEN
+        ALTER TABLE memgres_meta ADD COLUMN relinked_after_0023 boolean NOT NULL DEFAULT true;
+        UPDATE memgres_meta SET links_built = false;
+    END IF;
+END $$;

{memgres-0.13.0 → memgres-0.13.2}/memgres/relink.py

@@ -20,6 +20,12 @@ _log = logging.getLogger("memgres.relink")
 
 BATCH = 500
 
+# One rebuild at a time across processes. Two servers starting together (the MCP
+# door and the REST/panel door) both found the flag clear and rebuilt at once,
+# and one of them died on the other's rows. A session-level advisory lock: held
+# for the rebuild, gone with the connection if the process is.
+LOCK_KEY = 0x6D656D67_6C6E6B   # "memglnk"
+
 
 class _NoEmbedder:
     """Stands in for an embedder so `Store` does not build the real one. The
@@ -55,11 +61,32 @@ def rebuild(conn, cfg, *, force: bool = False) -> int:
     the flag false — so the server came up serving a link graph that was perfectly
     empty while saying it had built one. Owning the commit here means the work is
     durable when this returns, whatever the caller does next."""
+    with conn.cursor() as cur:
+        cur.execute("SELECT pg_try_advisory_lock(%s)", (LOCK_KEY,))
+        mine = cur.fetchone()[0]
+    if not mine:
+        conn.commit()
+        _log.info("the link index is being rebuilt by another process; not starting a second pass")
+        return 0
+    try:
+        return _rebuild(conn, cfg, force=force)
+    finally:
+        try:
+            with conn.cursor() as cur:
+                cur.execute("SELECT pg_advisory_unlock(%s)", (LOCK_KEY,))
+            conn.commit()
+        except Exception:          # a broken connection releases the lock by closing
+            pass
+
+
+def _rebuild(conn, cfg, *, force: bool) -> int:
     from .store import Store
     with conn.cursor() as cur:
+        # read under the lock: another process may have just finished
         cur.execute("SELECT links_built FROM memgres_meta")
         row = cur.fetchone()
         if row and row[0] and not force:
+            conn.commit()
             return 0
 
     # `_sync_links` touches neither embeddings nor vectors; passing a

{memgres-0.13.0 → memgres-0.13.2}/memgres/web/admission.py

@@ -88,8 +88,10 @@ def _request(cur, provider: Provider, claims: dict, suggested: Optional[str]) ->
     if verified_email(claims) is None:
         # A request an administrator must judge needs at least an address the
         # provider vouches for; without one, anyone who can make accounts at an
-        # open provider could fill the queue with nobodies.
-        return Outcome("denied", reason="no_account")
+        # open provider could fill the queue with nobodies. Said as it is: the
+        # person can fix this at the provider, and "no account" would send them
+        # to the wrong place.
+        return Outcome("denied", reason="email_unverified")
     cur.execute("DELETE FROM signin_request WHERE status <> 'pending' "
                 "AND decided_at < now() - make_interval(days => %s)", (REJECTION_MEMORY_DAYS * 3,))
     cur.execute("SELECT count(*), count(*) FILTER (WHERE provider = %s) FROM signin_request "
@@ -193,6 +195,10 @@ def admit(conn, cfg, provider: Provider, claims: dict, *, link_user_id: Optional
 
         # ─── nobody ─────────────────────────────────────────────────────────
         if provider.on_no_match == "deny":
+            # with a confirmed address this could have matched an account; say
+            # what is missing rather than that nothing exists
+            if email is None and provider.on_email_match != "deny":
+                return Outcome("denied", reason="email_unverified")
             return Outcome("denied", reason="no_account")
         if provider.on_no_match == "pending":
             return _request(cur, provider, claims, None)

{memgres-0.13.0 → memgres-0.13.2}/memgres/web/auth_routes.py

@@ -57,8 +57,12 @@ def mount(app, cfg, pool, panel, providers, fetch=None) -> None:
         starts.fail(key)
         state, nonce, browser = secrets.token_urlsafe(32), secrets.token_urlsafe(32), secrets.token_urlsafe(32)
         verifier, challenge = new_pkce()
+        # Linking asks the provider to show its account chooser: a browser often
+        # holds another session there (a service admin, a colleague's), and the
+        # provider would otherwise hand that one back without asking.
         url = client.authorize_url(redirect_uri=_redirect_uri(request, pid), state=state,
-                                   nonce=nonce, challenge=challenge)
+                                   nonce=nonce, challenge=challenge,
+                                   prompt="select_account" if link_session else None)
         with pool.connection() as conn, conn.transaction(), conn.cursor() as cur:
             cur.execute("DELETE FROM oidc_flow WHERE expires_at < now()")
             cur.execute("SELECT count(*) FROM oidc_flow")
@@ -166,7 +170,10 @@ def mount(app, cfg, pool, panel, providers, fetch=None) -> None:
         except psycopg.errors.UniqueViolation:
             # two callbacks linking the same sign-in at the same moment: one wins
             return _go(f"{back}?auth=denied_taken")
-        log.info("oidc %s: %s%s", pid, outcome.kind, f" ({outcome.reason})" if outcome.reason else "")
+        # a refusal is what an administrator will be asked about: log its reason
+        # (never the person's email) where the default log level shows it
+        (log.warning if outcome.kind == "denied" else log.info)(
+            "oidc %s: %s%s", pid, outcome.kind, f" ({outcome.reason})" if outcome.reason else "")
         if outcome.kind == "signed_in":
             r = _go("/memory")
             panel["set_cookie"](r, sid)

{memgres-0.13.0 → memgres-0.13.2}/memgres/web/oidc.py

@@ -126,13 +126,15 @@ class Client:
 
     # ─── the flow ───────────────────────────────────────────────────────────
     def authorize_url(self, *, redirect_uri: str, state: str, nonce: str, challenge: str,
-                      login_hint: Optional[str] = None) -> str:
+                      login_hint: Optional[str] = None, prompt: Optional[str] = None) -> str:
         meta = self.metadata()
         q = {"response_type": "code", "client_id": self.p.client_id, "redirect_uri": redirect_uri,
              "scope": " ".join(self.p.scopes), "state": state, "nonce": nonce,
              "code_challenge": challenge, "code_challenge_method": "S256"}
         if login_hint:
             q["login_hint"] = login_hint
+        if prompt:
+            q["prompt"] = prompt
         sep = "&" if "?" in meta["authorization_endpoint"] else "?"
         return meta["authorization_endpoint"] + sep + urllib.parse.urlencode(q)
 

{memgres-0.13.0 → memgres-0.13.2}/memgres/web/routes.py

@@ -12,6 +12,7 @@ Two rules keep a browser session from widening what an attacker can reach:
   ``SameSite=Strict`` as well; that is the second lock, not the only one.
 """
 
+import logging
 import threading
 import time
 from pathlib import Path
@@ -75,6 +76,27 @@ class _Throttle:
             self._fails.pop(key, None)
 
 
+class _ScrubSignInQuery(logging.Filter):
+    """Keep the query string of /ui/auth/* out of the access log.
+
+    The provider's redirect back carries a one-time code and the state. Both are
+    spent by the time the line is written and useless without the PKCE verifier,
+    but a log is kept and copied, and there is no reason for them to be in it."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        args = record.args
+        if isinstance(args, tuple) and len(args) >= 3 and isinstance(args[2], str) \
+                and args[2].startswith("/ui/auth/") and "?" in args[2]:
+            record.args = args[:2] + (args[2].split("?", 1)[0] + "?…",) + args[3:]
+        return True
+
+
+def _scrub_access_log() -> None:
+    access = logging.getLogger("uvicorn.access")
+    if not any(isinstance(f, _ScrubSignInQuery) for f in access.filters):
+        access.addFilter(_ScrubSignInQuery())
+
+
 def mount(app, cfg, pool, make_store, *, oidc_fetch=None) -> None:
     from fastapi import Body, HTTPException, Request, Response
     from fastapi.responses import FileResponse, RedirectResponse
@@ -83,6 +105,7 @@ def mount(app, cfg, pool, make_store, *, oidc_fetch=None) -> None:
     from . import oidc_config
     cookie_name = "__Host-memgres_session" if cfg.web_cookie_secure else "memgres_session"
     throttle = _Throttle()
+    _scrub_access_log()
     # read at startup: a broken provider file stops the server rather than
     # leaving a sign-in door that half-works
     providers = oidc_config.load(cfg.oidc_config, key_mode=cfg.key_mode)
@@ -172,17 +195,19 @@ def mount(app, cfg, pool, make_store, *, oidc_fetch=None) -> None:
         return FileResponse(shell, media_type="text/html",
                             headers={"Cache-Control": "no-cache"})
 
+    # HEAD too: a page answers HEAD as it answers GET (RFC 9110), and uptime
+    # checks use it — a 405 there reads as "the panel is down"
     for p in APP_PATHS:
-        app.add_api_route(p, _page, methods=["GET"], include_in_schema=False)
+        app.add_api_route(p, _page, methods=["GET", "HEAD"], include_in_schema=False)
 
-    @app.get("/signin", include_in_schema=False)
+    @app.api_route("/signin", methods=["GET", "HEAD"], include_in_schema=False)
     def signin_page():
         with pool.connection() as conn:
             if not sessions.admin_has_linked_signin(conn):
                 return RedirectResponse("/signin/admin?from=signin", status_code=307)
         return _page()
 
-    @app.get("/signin/admin", include_in_schema=False)
+    @app.api_route("/signin/admin", methods=["GET", "HEAD"], include_in_schema=False)
     def signin_admin_page():
         return _page()
 

{memgres-0.13.0 → memgres-0.13.2}/memgres/web/static/app.css

@@ -96,7 +96,8 @@
   .search input::placeholder { color: var(--muted); }
   .search svg { position: absolute; left: 11px; top: 50%; transform: translateY(-50%); }
 
-  .workspace { display: grid; grid-template-columns: minmax(0, 1fr) 360px; gap: 10px; min-height: 0; }
+  .workspace { display: grid; grid-template-columns: minmax(0, 1fr) 12px var(--insp-w, 360px); gap: 0; min-height: 0; }
+  .workspace.with-results { grid-template-columns: minmax(0, 1fr) 310px 12px var(--insp-w, 360px); }
   .stage { position: relative; min-height: 0; border-radius: 14px; overflow: hidden; background: radial-gradient(1200px 800px at 50% 50%, #182038 0%, var(--canvas) 55%, #0f1424 100%); box-shadow: inset 0 0 0 1px var(--line-soft); }
   .viz-host { position: absolute; inset: 0; }
   .stagebar { position: absolute; left: 10px; right: 10px; top: 10px; z-index: 4; display: flex; flex-wrap: wrap; align-items: center; gap: 8px; pointer-events: none; }
@@ -304,10 +305,15 @@
   .snips button[aria-selected="true"] { color: var(--bright); background: var(--panel-2); }
   .toast { position: fixed; left: 50%; bottom: calc(22px + env(safe-area-inset-bottom, 0px)); transform: translateX(-50%); z-index: 60; background: var(--panel-2); color: var(--bright); padding: 9px 14px; border-radius: 10px; box-shadow: 0 0 0 1px var(--line), 0 12px 30px rgba(0,0,0,.45); font-size: 13px; max-width: calc(100% - 32px); box-sizing: border-box; }
 
-  @media (max-width: 1100px) { .workspace { grid-template-columns: minmax(0, 1fr) 320px; } }
+  @media (max-width: 1100px) {
+    .workspace { grid-template-columns: minmax(0, 1fr) 12px var(--insp-w, 320px); }
+    .workspace.with-results { grid-template-columns: minmax(0, 1fr) 280px 12px var(--insp-w, 320px); }
+  }
   @media (max-width: 960px) {
     body { overflow: auto; }
-    .workspace { grid-template-columns: 1fr; grid-template-rows: minmax(380px, 1fr) auto; }
+    .workspace, .workspace.with-results { grid-template-columns: 1fr; grid-template-rows: minmax(380px, 1fr) auto auto; gap: 10px; }
+    .splitter { display: none; }
+    .results { margin-left: 0 !important; max-height: 50vh; }
     .inspector { max-height: none; }
     .gate { grid-template-columns: 1fr; grid-template-rows: 200px auto; height: auto; min-height: 100%; }
     .word { font-size: 32px; }
@@ -432,3 +438,54 @@ a.person:hover { color: var(--focus); box-shadow: inset 0 -1px 0 var(--focus); }
 .perm-badge.role { color: var(--admin); box-shadow: inset 0 0 0 1px rgba(255,162,76,.45); }
 .every-list { max-height: min(60vh, 520px); overflow: auto; }
 .shell.collapsed .visiting-h, .shell.collapsed .every-link, .shell.collapsed .spaceitem .forget { display: none; }
+
+/* the sign-in picture can be pulled about; the words over it stay out of the way */
+.gate-art canvas { touch-action: none; }
+.gate-art .words { pointer-events: none; }
+
+/* ─── search results column, the record panel's edge, markdown bodies ─── */
+.results { margin-left: 10px; min-height: 0; overflow: auto; border-radius: 14px; background: var(--panel); box-shadow: inset 0 0 0 1px var(--line-soft); padding: 14px; display: flex; flex-direction: column; gap: 10px; }
+.res-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 8px; }
+.res-head b { display: block; color: var(--bright); font-weight: 600; font-size: 14px; margin-top: 4px; overflow-wrap: anywhere; }
+.res-wait { display: flex; align-items: center; gap: 10px; color: var(--muted); font-size: 13px; padding: 6px 2px; }
+.list.stale { opacity: .5; transition: opacity .15s; }
+.list button[aria-current="true"] { background: var(--panel-2); box-shadow: inset 0 0 0 1px var(--line); }
+.spinner { width: 14px; height: 14px; border-radius: 50%; border: 2px solid var(--line); border-top-color: var(--focus); animation: spin .8s linear infinite; flex: none; box-sizing: border-box; }
+@keyframes spin { to { transform: rotate(360deg); } }
+.search.busy svg { visibility: hidden; }
+.search.busy::before { content: ""; position: absolute; left: 10px; top: 50%; width: 14px; height: 14px; margin-top: -7px; border-radius: 50%; border: 2px solid var(--line); border-top-color: var(--focus); animation: spin .8s linear infinite; box-sizing: border-box; }
+
+.splitter { cursor: col-resize; position: relative; touch-action: none; outline: none; }
+.splitter::after { content: ""; position: absolute; top: 18%; bottom: 18%; left: 50%; width: 2px; margin-left: -1px; border-radius: 2px; background: transparent; transition: background .15s; }
+.splitter:hover::after, .splitter.on::after, .splitter:focus-visible::after { background: var(--focus); }
+
+.body.md { white-space: normal; overflow-wrap: anywhere; }
+.body.md > :first-child { margin-top: 0; }
+.body.md > :last-child { margin-bottom: 0; }
+.body.md p { margin: .55em 0; }
+.body.md h1, .body.md h2, .body.md h3, .body.md h4, .body.md h5, .body.md h6 { color: var(--bright); line-height: 1.3; margin: 1.1em 0 .45em; font-weight: 600; }
+.body.md h1 { font-size: 1.25em; } .body.md h2 { font-size: 1.15em; } .body.md h3 { font-size: 1.05em; } .body.md h4, .body.md h5, .body.md h6 { font-size: 1em; }
+.body.md ul, .body.md ol { margin: .5em 0; padding-left: 1.35em; }
+.body.md li { margin: .2em 0; }
+.body.md li > p { margin: .2em 0; }
+.body.md strong { color: var(--bright); font-weight: 600; }
+.body.md a { color: var(--focus); text-underline-offset: 3px; }
+.body.md blockquote { margin: .6em 0; padding: .1em 0 .1em 12px; border-left: 3px solid var(--line); color: var(--muted); }
+.body.md hr { border: 0; border-top: 1px solid var(--line); margin: 1em 0; }
+.body.md pre { background: var(--canvas); border-radius: 8px; padding: 10px 12px; overflow-x: auto; margin: .6em 0; }
+.body.md pre code { background: none; padding: 0; font-size: 12px; line-height: 1.55; white-space: pre; }
+.body.md table { display: block; overflow-x: auto; max-width: 100%; border-collapse: collapse; margin: .7em 0; font-size: 12.5px; width: max-content; }
+.body.md th, .body.md td { border: 1px solid var(--line); padding: 5px 9px; white-space: normal; vertical-align: top; text-align: left; min-width: 60px; }
+.body.md th { background: var(--canvas); color: var(--bright); font-weight: 600; font-size: 12.5px; }
+.body.md tr:last-child td { border-bottom: 1px solid var(--line); }
+.body.md input[type=checkbox] { margin-right: 6px; }
+.body.md .md-img { color: var(--muted); font-style: italic; }
+
+/* the space's own node */
+.node.hubnode .hub-ring { fill: none; stroke-width: 1.4; opacity: .5; stroke-linejoin: round; }
+.node.hubnode .ring.hub { stroke-width: 3.2; fill-opacity: .22; }
+.node.hubnode .halo { opacity: .12; stroke-width: 18; }
+.node.hubnode.sel .halo { opacity: .22; }
+@media (prefers-reduced-motion: reduce) { .spinner, .search.busy::before { animation-duration: 2.4s; } }
+/* the results header — the query and × — stays put while the list scrolls under it */
+.results > .res-head { position: sticky; top: -14px; z-index: 2; margin: -14px -14px 0; padding: 14px 14px 10px; background: var(--panel); border-radius: 14px 14px 0 0; box-shadow: 0 1px 0 var(--line-soft); }

memgres-0.13.2/memgres/web/static/js/gate.js

@@ -0,0 +1,237 @@
+// /signin (providers) and /signin/admin (a token, for administrators).
+
+import { post, ApiError } from "./api.js";
+import { applyStatic, t } from "./i18n.js";
+import { $, esc, hexPath, PALETTE, reducedMotion, rnd } from "./ui.js";
+
+let raf = null;
+
+export function showGate({ path, options, onSignedIn }) {
+  $("#shell").hidden = true;
+  $("#gate").hidden = false;
+  const admin = path.startsWith("/signin/admin");
+  $("#door-main").hidden = admin;
+  $("#door-admin").hidden = !admin;
+  if (admin) {
+    const redirected = new URLSearchParams(location.search).get("from") === "signin" || options.admin_redirect;
+    $("#redirected").hidden = !redirected;
+    $("#admin-back").hidden = redirected;
+    $("#admin-err").hidden = true;
+    const form = $("#door-admin");
+    form.onsubmit = async (e) => {
+      e.preventDefault();
+      const input = $("#admin-token"), err = $("#admin-err"), btn = $("#admin-go");
+      const token = input.value.trim();
+      if (!token) { err.textContent = t("gate.admin.empty"); err.hidden = false; return; }
+      btn.disabled = true;
+      try {
+        const session = await post("/session/token", { token });
+        input.value = "";
+        stopArt();
+        onSignedIn(session);
+      } catch (ex) {
+        err.textContent = ex instanceof ApiError && ex.status === 429 ? t("gate.admin.throttled")
+          : ex instanceof ApiError && ex.status === 403 ? t("gate.admin.refused") : t("err.network");
+        err.hidden = false;
+      } finally {
+        btn.disabled = false;
+      }
+    };
+    setTimeout(() => $("#admin-token").focus(), 0);
+  } else {
+    renderProviders(options.providers || []);
+    const result = new URLSearchParams(location.search).get("auth");
+    const note = $("#auth-note");
+    note.hidden = !result;
+    if (result) {
+      note.className = "auth-note " + (result === "pending" ? "wait" : "bad");
+      note.textContent = t("auth." + result) === "auth." + result ? t("auth.failed") : t("auth." + result);
+    }
+  }
+  applyStatic($("#gate"));
+  startArt();
+}
+
+function renderProviders(providers) {
+  const box = $("#providers");
+  if (!providers.length) {
+    box.innerHTML = `<div class="empty-prov">${esc(t("gate.noProviders"))}</div>`;
+    return;
+  }
+  box.innerHTML = providers.map((p) => `<a class="prov-btn" href="/ui/auth/${encodeURIComponent(p.id)}/start">
+      <span class="prov">${esc((p.label || p.id).slice(0, 3))}</span>
+      <span><b>${esc(t("gate.continueWith", { name: p.label || p.id }))}</b>${p.hint ? `<small>${esc(p.hint)}</small>` : ""}</span></a>`).join("");
+}
+
+export function hideGate() {
+  stopArt();
+  $("#gate").hidden = true;
+}
+
+// ─── the picture on the left: a memory you can pull about ──────────────────
+// A small tree like a real space — a root, a handful of branches, records under
+// them, a few links across — laid out by d3-force. Any hexagon but the root can be
+// dragged, and its neighbours follow on their links. The layout is settled before
+// the first frame, so it never opens as a tangle.
+let art = null;
+
+function buildGraph() {
+  const nodes = [{ id: 0, r: 34, c: "#62e38d", depth: 0, fx: 0, fy: 0 }];
+  const links = [];
+  const add = (parent, depth, r, c, bare) => {
+    const n = { id: nodes.length, r, c, depth, bare, ph: rnd("ph" + nodes.length) * 6.28 };
+    nodes.push(n);
+    links.push({ source: parent.id, target: n.id, depth });
+    return n;
+  };
+  const hubs = 9;
+  for (let h = 0; h < hubs; h++) {
+    const c = PALETTE[h % PALETTE.length];
+    const hub = add(nodes[0], 1, 13 + rnd("hr" + h) * 7, c, h % 4 === 3);
+    const kids = 4 + Math.floor(rnd("hk" + h) * 5);
+    for (let k = 0; k < kids; k++) {
+      const key = `${h}.${k}`;
+      const child = add(hub, 2, 6 + rnd("cr" + key) ** 2 * 8, c, rnd("cb" + key) < 0.14);
+      if (rnd("cg" + key) < 0.32) {
+        const grand = 1 + Math.floor(rnd("gn" + key) * 3);
+        for (let g = 0; g < grand; g++) add(child, 3, 4.5 + rnd("gr" + key + g) * 3.5, c, false);
+      }
+    }
+  }
+  // a few links across branches, the way records cite each other
+  const leaves = nodes.filter((n) => n.depth >= 2);
+  for (let x = 0; x < 12; x++) {
+    const a = leaves[Math.floor(rnd("xa" + x) * leaves.length)], b = leaves[Math.floor(rnd("xb" + x) * leaves.length)];
+    if (a !== b && a.c !== b.c) links.push({ source: a.id, target: b.id, depth: 9, cross: true });
+  }
+  return { nodes, links };
+}
+
+function startArt() {
+  stopArt();
+  const d3 = window.d3, cv = $("#gate-canvas");
+  if (!d3 || !cv) return;
+  const ctx = cv.getContext("2d"), still = reducedMotion();
+  const { nodes, links } = buildGraph();
+  // The layout lives in a fixed circle and is scaled to whatever room the page
+  // gives it, so a phone shows the same picture smaller rather than a cropped one.
+  const bound = 260;
+  const contain = () => {
+    for (const n of nodes) {
+      if (n.fx != null && n.depth === 0) continue;
+      const d = Math.hypot(n.x, n.y), lim = bound - n.r;
+      if (d > lim) { n.x *= lim / d; n.y *= lim / d; n.vx *= 0.5; n.vy *= 0.5; }
+    }
+  };
+  const sim = d3.forceSimulation(nodes)
+    .force("link", d3.forceLink(links).id((n) => n.id)
+      .distance((l) => l.cross ? 150 : l.depth === 1 ? 118 : l.depth === 2 ? 40 : 24)
+      .strength((l) => l.cross ? 0.02 : 0.7))
+    .force("charge", d3.forceManyBody().strength((n) => n.depth === 0 ? -400 : -26 - n.r * 3).distanceMax(240))
+    .force("collide", d3.forceCollide((n) => n.r + 4).iterations(2))
+    .force("contain", contain)
+    .stop();
+  nodes.forEach((n, i) => { if (i) { const a = rnd("ia" + i) * 6.28, d = 60 + rnd("id" + i) * 160; n.x = Math.cos(a) * d; n.y = Math.sin(a) * d; } });
+  for (let i = 0; i < 320; i++) sim.tick();
+  sim.alphaTarget(0).alpha(0);
+  sim.on("tick", () => {});                         // ticks run on d3's own timer only while dragging
+
+  const view = { cx: 0, cy: 0, dpr: 1, k: 1 };
+  const toGraph = (e) => {
+    const r = cv.getBoundingClientRect();
+    return [(e.clientX - r.left - view.cx) / view.k, (e.clientY - r.top - view.cy) / view.k];
+  };
+  const hit = ([x, y]) => {
+    let best = null, bestD = Infinity;
+    for (const n of nodes) {
+      if (n.depth === 0) continue;
+      const d = Math.hypot(n.x - x, n.y - y);
+      if (d < n.r + 8 / view.k && d < bestD) { best = n; bestD = d; }
+    }
+    return best;
+  };
+  let dragged = null;
+  const onDown = (e) => {
+    const n = hit(toGraph(e));
+    if (!n) return;
+    dragged = n;
+    n.fx = n.x; n.fy = n.y;
+    cv.setPointerCapture(e.pointerId);
+    cv.style.cursor = "grabbing";
+    sim.alphaTarget(0.25).restart();
+    e.preventDefault();
+  };
+  const onMove = (e) => {
+    const p = toGraph(e);
+    if (!dragged) { cv.style.cursor = hit(p) ? "grab" : ""; return; }
+    const d = Math.hypot(p[0], p[1]), lim = bound - dragged.r;
+    const k = d > lim ? lim / d : 1;
+    dragged.fx = p[0] * k; dragged.fy = p[1] * k;
+  };
+  const onUp = (e) => {
+    if (!dragged) return;
+    dragged.fx = dragged.fy = null;
+    dragged = null;
+    cv.style.cursor = hit(toGraph(e)) ? "grab" : "";
+    sim.alphaTarget(0);
+  };
+  cv.addEventListener("pointerdown", onDown);
+  cv.addEventListener("pointermove", onMove);
+  cv.addEventListener("pointerup", onUp);
+  cv.addEventListener("pointercancel", onUp);
+
+  const hex = (x, y, R, draw) => { ctx.save(); ctx.translate(x, y); draw(new Path2D(hexPath(R))); ctx.restore(); };
+  const frame = (time) => {
+    const dpr = view.dpr = Math.min(2, devicePixelRatio || 1);
+    const cw = cv.clientWidth, ch = cv.clientHeight;
+    if (cv.width !== cw * dpr || cv.height !== ch * dpr) { cv.width = cw * dpr; cv.height = ch * dpr; }
+    view.cx = cw / 2; view.cy = ch * 0.42;
+    view.k = Math.min(1.15, Math.min(cw * 0.47, ch * 0.41) / bound);
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, cw, ch);
+    ctx.translate(view.cx, view.cy);
+    ctx.scale(view.k, view.k);
+    // a gentle drift, drawn only — the layout itself stays where it settled
+    const pos = (n) => (still || n === dragged || n.depth === 0) ? [n.x, n.y]
+      : [n.x + Math.sin(time / 2600 + n.ph) * 2.2, n.y + Math.cos(time / 3100 + n.ph) * 2.2];
+    for (const l of links) {
+      const [x1, y1] = pos(l.source), [x2, y2] = pos(l.target);
+      ctx.globalAlpha = l.cross ? 0.22 : 0.4;
+      ctx.strokeStyle = l.cross ? "#aeb6d6" : l.target.c;
+      ctx.lineWidth = l.cross ? 1 : 1.3;
+      ctx.setLineDash(l.cross ? [3, 6] : []);
+      ctx.beginPath(); ctx.moveTo(x1, y1);
+      ctx.quadraticCurveTo((x1 + x2) / 2 + (y2 - y1) * 0.12, (y1 + y2) / 2 - (x2 - x1) * 0.12, x2, y2);
+      ctx.stroke();
+    }
+    ctx.setLineDash([]);
+    for (const n of nodes) {
+      if (n.depth === 0) continue;
+      const [x, y] = pos(n);
+      hex(x, y, n.r, (path) => {
+        ctx.strokeStyle = n.c; ctx.fillStyle = n.c; ctx.lineWidth = n === dragged ? 2.6 : 1.8;
+        ctx.setLineDash(n.bare ? [3, 4] : []);
+        ctx.globalAlpha = n.bare ? 0.04 : n === dragged ? 0.3 : 0.15; ctx.fill(path);
+        ctx.globalAlpha = 1; ctx.stroke(path);
+      });
+    }
+    ctx.setLineDash([]);
+    ctx.globalAlpha = 1;
+    hex(0, 0, nodes[0].r, (p) => { ctx.fillStyle = "#121829"; ctx.strokeStyle = "#62e38d"; ctx.lineWidth = 2.4; ctx.fill(p); ctx.stroke(p); });
+    raf = requestAnimationFrame(frame);
+  };
+  raf = requestAnimationFrame(frame);
+  art = { sim, cv, off: () => {
+    cv.removeEventListener("pointerdown", onDown);
+    cv.removeEventListener("pointermove", onMove);
+    cv.removeEventListener("pointerup", onUp);
+    cv.removeEventListener("pointercancel", onUp);
+    cv.style.cursor = "";
+  } };
+}
+
+function stopArt() {
+  if (raf) cancelAnimationFrame(raf);
+  raf = null;
+  if (art) { art.sim.stop(); art.off(); art = null; }
+}

memgres-0.13.2/memgres/web/static/js/md.js

@@ -0,0 +1,46 @@
+// A record's body as Markdown: headings, lists, tables, code, links — and the
+// memory's own [[path]] links, which open the record they name.
+//
+// Bodies are written by agents and people, so nothing in them runs: raw HTML is
+// shown as text, only http(s)/mailto links are kept (and open in a new tab),
+// images are not fetched, and the result goes through DOMPurify as well.
+
+import { Marked } from "../vendor/marked.esm.js";
+import DOMPurify from "../vendor/purify.es.js";
+import { esc } from "./ui.js";
+
+let wikilink = (target, label) => esc(label);
+
+const md = new Marked({ gfm: true, breaks: true, async: false });
+md.use({
+  extensions: [{
+    name: "wikilink",
+    level: "inline",
+    start(src) { const i = src.indexOf("[["); return i < 0 ? undefined : i; },
+    tokenizer(src) {
+      const m = /^\[\[([^\]|#\n]+)(?:#[^\]|\n]*)?(?:\|([^\]\n]*))?\]\]/.exec(src);
+      if (m) return { type: "wikilink", raw: m[0], target: m[1].trim(), label: (m[2] || m[1]).trim() };
+    },
+    renderer(token) { return wikilink(token.target, token.label); },
+  }],
+  renderer: {
+    html(token) { return esc(token.text); },
+    link({ href, title, tokens }) {
+      const text = this.parser.parseInline(tokens);
+      if (!/^(https?:|mailto:)/i.test(href || "")) return text;
+      return `<a href="${esc(href)}" target="_blank" rel="noopener noreferrer nofollow"${title ? ` title="${esc(title)}"` : ""}>${text}</a>`;
+    },
+    image({ text }) { return text ? `<span class="md-img">[${esc(text)}]</span>` : ""; },
+  },
+});
+
+// `link(target, label)` returns the HTML for one [[…]] link.
+export function renderMarkdown(body, { link } = {}) {
+  wikilink = link || ((t, label) => esc(label));
+  try {
+    const html = md.parse(String(body ?? ""));
+    return DOMPurify.sanitize(html, { ADD_ATTR: ["target"], FORBID_TAGS: ["style", "form", "input", "textarea", "select"] });
+  } finally {
+    wikilink = (t, label) => esc(label);
+  }
+}