@getrift/rift 0.1.0-beta.19 → 0.1.0-beta.20

package/operator/swiftbar/render-menu.py

@@ -14,7 +14,7 @@ deliberately absent.
 Inputs (all via env, all optional — missing inputs degrade gracefully):
   RIFT_DOCTOR_JSON   `rift doctor --json` output (the verdict + one fix).
   RIFT_STATUS_JSON   `rift status --json` output (capture times, clients).
-  RIFT_MCP_JSON      `/stats/mcp-usage` body (memory-today delight metric).
+  RIFT_MCP_JSON      `/stats/mcp-usage` body (Memory stats: today/month/all).
   RIFT_HEALTH        "up" | "down" — coarse /health probe, used only when
                      the doctor report is unavailable (CLI not resolvable).
   RIFT_NODE_BIN      absolute node binary, for menu actions.
@@ -121,21 +121,62 @@ def fmt_tokens(n):
     return f"~{n} context tokens"
 
 
-def memory_today(mcp):
-    """Friendly 'memory today' row, or None when not available."""
-    if not isinstance(mcp, dict):
-        return None
-    today = mcp.get("today")
-    if not isinstance(today, dict):
-        return None
-    parts = []
-    hits = today.get("context_hits")
-    if isinstance(hits, int):
-        parts.append(f"{hits} useful recall" + ("" if hits == 1 else "s"))
-    tokens = today.get("context_tokens_delivered_estimate")
-    if isinstance(tokens, int):
+# Friendly labels for the three Memory windows, mapped to their keys in the
+# /stats/mcp-usage payload. Order is the render order. We deliberately skip
+# `week` — three periods stay glanceable; a fourth turns the menu into a
+# dashboard. A period absent from the payload is simply not rendered (we never
+# fabricate a number the backend didn't report), so an older daemon that only
+# emits `today` still renders cleanly.
+MEMORY_PERIODS = (("Today", "today"), ("This month", "month"), ("All time", "all_time"))
+
+
+def memory_window_row(label, hits, tokens):
+    """One '<Label>: N useful recalls · ~tokens' row, or a calm zero state."""
+    if hits <= 0:
+        return f"{label}: nothing yet"
+    parts = [f"{hits:,} useful recall" + ("" if hits == 1 else "s")]
+    if isinstance(tokens, int) and tokens > 0:
         parts.append(fmt_tokens(tokens))
-    return " · ".join(parts) if parts else None
+    return f"{label}: " + " · ".join(parts)
+
+
+def memory_section(mcp):
+    """Friendly 'Memory' section lines (header + period rows), or [].
+
+    Reads today / month / all-time recall + context-token counts straight
+    from /stats/mcp-usage and prints them in plain language. Returns [] when
+    the stats payload is missing or carries none of the expected windows, so
+    the menu degrades gracefully (section omitted, Rift still healthy) rather
+    than showing an error. A history with no recalls anywhere collapses to a
+    single calm line instead of three empty rows.
+    """
+    if not isinstance(mcp, dict):
+        return []
+    present = []
+    any_activity = False
+    for label, key in MEMORY_PERIODS:
+        window = mcp.get(key)
+        if not isinstance(window, dict):
+            continue
+        hits = window.get("context_hits")
+        if not isinstance(hits, int):
+            continue
+        tokens = window.get("context_tokens_delivered_estimate")
+        present.append((label, hits, tokens))
+        if hits > 0:
+            any_activity = True
+    if not present:
+        return []
+    # Collapse to a single calm line ONLY when every period is present and all
+    # are zero — that genuinely is "nothing recalled, ever". A partial payload
+    # (e.g. a legacy daemon emitting only `today`) must not claim all-time
+    # emptiness it can't see, so it falls through to the per-period rows
+    # ("Today: nothing yet") instead.
+    if not any_activity and len(present) == len(MEMORY_PERIODS):
+        return ["Memory", "Nothing recalled yet — Rift learns as you use it"]
+    return ["Memory"] + [
+        memory_window_row(label, hits, tokens) for label, hits, tokens in present
+    ]
 
 
 # --- Menu-action line builders -------------------------------------------
@@ -443,9 +484,11 @@ def render(doctor, status, mcp, health, now):
     # healthy or warning
     lines.append("Rift is working")
     lines += render_capture_rows(friend, now)
-    mem = memory_today(mcp)
-    if mem:
-        lines.append(f"Memory today: {mem}")
+
+    mem_rows = memory_section(mcp)
+    if mem_rows:
+        lines.append("---")
+        lines += mem_rows
 
     client_rows = render_client_rows(status, doctor)
     if client_rows:

package/operator/swiftbar/rift.10s.sh

@@ -36,27 +36,57 @@ while [[ -L "$SOURCE" ]]; do
 done
 SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
 RIFT_HOME_DEFAULT="${HOME}/Library/Application Support/Rift"
-LOG_DIR="${RIFT_LOG_DIR:-${RIFT_HOME_DEFAULT}/logs}"
+
+# Packaged (.pkg) install layout — bundled Node + app tree under Rift home,
+# a bash CLI shim at ~/.rift/bin/rift, daemon logs under ~/Library/Logs/Rift.
+# Detect it so the menu bar works on a BARE Mac with NO env injection: the
+# `rift menubar install` env (RIFT_BIN/NODE_BIN) does NOT persist into the
+# installed plugin, so the plugin must self-resolve these paths every tick.
+PACKAGED_NODE="${RIFT_HOME_DEFAULT}/node/bin/node"
+PACKAGED_JS="${RIFT_HOME_DEFAULT}/app/dist/src/cli/index.js"
+PACKAGED_SHIM="${HOME}/.rift/bin/rift"
+if [[ -f "$PACKAGED_JS" && -x "$PACKAGED_NODE" ]]; then
+  PACKAGED_LOG_DIR="${HOME}/Library/Logs/Rift"
+else
+  PACKAGED_LOG_DIR=""
+fi
+
+LOG_DIR="${RIFT_LOG_DIR:-${PACKAGED_LOG_DIR:-${RIFT_HOME_DEFAULT}/logs}}"
 DATA_DIR="${RIFT_DATA_DIR:-${RIFT_HOME_DEFAULT}/data}"
 RENDERER="$SCRIPT_DIR/render-menu.py"
 
 # Resolve the rift CLI. SwiftBar invokes shell commands with a stripped
-# PATH, so menu actions need absolute paths end-to-end. The npm-installed
-# `rift` is a symlink to a JS file with a `#!/usr/bin/env node` shebang —
-# executing it directly under a stripped PATH fails with `env: node: No
-# such file or directory`. So we resolve:
-#   - RIFT_BIN: the on-PATH `rift` launcher (diagnostics + fallback).
-#   - RIFT_JS:  the real JS entrypoint behind RIFT_BIN's symlink chain,
-#     to pass as node's first arg.
-#   - NODE_BIN: an absolute node binary, so actions don't depend on PATH.
-RIFT_BIN="${RIFT_BIN:-}"
+# PATH, so menu actions need absolute paths end-to-end. We resolve:
+#   - NODE_BIN: an absolute node binary (bundled Node preferred), so actions
+#     don't depend on PATH and work on a Mac with no system Node.
+#   - RIFT_JS:  the real JS entrypoint to pass as node's first arg. NEVER the
+#     bash shim — `node <bash-file>` fails — so we accept only a *.js target
+#     and prefer the packaged app entrypoint directly.
+#   - RIFT_BIN: an executable `rift` launcher (diagnostics + fallback). The
+#     packaged shim is a valid launcher when run DIRECTLY (it is not JS).
 # REPO_ROOT only resolves to anything in a dev checkout; default it to empty
 # so the dev-only candidate below is a harmless no-op under `set -u` on
-# packaged (npm) installs, where it is never set. (Without this, the whole
-# candidate list fails to expand and the plugin crashes on every tick.)
+# packaged/npm installs, where it is never set.
 REPO_ROOT="${REPO_ROOT:-}"
+
+NODE_BIN="${NODE_BIN:-}"
+if [[ -z "$NODE_BIN" ]]; then
+  for candidate in \
+    "$PACKAGED_NODE" \
+    "/opt/homebrew/bin/node" \
+    "/usr/local/bin/node" \
+    "/usr/bin/node"; do
+    if [[ -x "$candidate" ]]; then
+      NODE_BIN="$candidate"
+      break
+    fi
+  done
+fi
+
+RIFT_BIN="${RIFT_BIN:-}"
 if [[ -z "$RIFT_BIN" ]]; then
   for candidate in \
+    "$PACKAGED_SHIM" \
     "/opt/homebrew/bin/rift" \
     "/usr/local/bin/rift" \
     "$HOME/.npm-global/bin/rift" \
@@ -69,8 +99,15 @@ if [[ -z "$RIFT_BIN" ]]; then
   done
 fi
 
-RIFT_JS=""
-if [[ -n "$RIFT_BIN" ]]; then
+RIFT_JS="${RIFT_JS:-}"
+# Packaged app entrypoint is authoritative when present.
+if [[ -z "$RIFT_JS" && -f "$PACKAGED_JS" ]]; then
+  RIFT_JS="$PACKAGED_JS"
+fi
+# Otherwise follow RIFT_BIN's symlink chain to the real entrypoint — but
+# only accept a *.js target, so a bash launcher (the packaged shim, or an
+# on-PATH wrapper) is never handed to `node` as a script.
+if [[ -z "$RIFT_JS" && -n "$RIFT_BIN" ]]; then
   target="$RIFT_BIN"
   while [[ -L "$target" ]]; do
     link_dir="$(cd -P "$(dirname "$target")" && pwd)"
@@ -81,24 +118,11 @@ if [[ -n "$RIFT_BIN" ]]; then
       target="$link_dir/$link_target"
     fi
   done
-  if [[ -f "$target" ]]; then
+  if [[ -f "$target" && "$target" == *.js ]]; then
     RIFT_JS="$target"
   fi
 fi
 
-NODE_BIN="${NODE_BIN:-}"
-if [[ -z "$NODE_BIN" ]]; then
-  for candidate in \
-    "/opt/homebrew/bin/node" \
-    "/usr/local/bin/node" \
-    "/usr/bin/node"; do
-    if [[ -x "$candidate" ]]; then
-      NODE_BIN="$candidate"
-      break
-    fi
-  done
-fi
-
 # Run a rift subcommand, preferring node + JS entrypoint (PATH-independent),
 # falling back to the launcher. Prints stdout; swallows stderr. Returns the
 # command's exit code, or 127 when rift can't be resolved at all.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getrift/rift",
-  "version": "0.1.0-beta.19",
+  "version": "0.1.0-beta.20",
   "description": "Local-first personal memory + reasoning infrastructure with an MCP interface.",
   "homepage": "https://getrift.dev",
   "license": "UNLICENSED",