@pi-unipi/unipi 2.14.2 → 2.16.0

package/packages/memory/mempalace.ts

@@ -18,6 +18,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { fileURLToPath } from "node:url";
+import { loadEmbeddingConfig } from "./settings.js";
 
 /** Default MemPalace palace path. */
 export const DEFAULT_PALACE = path.join(os.homedir(), ".mempalace", "palace");
@@ -458,3 +459,187 @@ export function runBridgeAsync<T = unknown>(
 export function ping(install: MempalaceInstall, palace: string): boolean {
   return runBridge<string>(install, palace, "ping") === "pong";
 }
+
+// ── Auto-update (TTL-gated PyPI check + `uv tool upgrade`) ────────────────
+
+/** Update check state file — records the last check so we hit PyPI ~daily. */
+const UPDATE_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-update");
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+const PYPI_URL = "https://pypi.org/pypi/mempalace/json";
+
+export interface MempalaceUpdateState {
+  checkedAt: number;
+  latestVersion: string;
+}
+
+export interface MempalaceUpdateOutcome {
+  checked: boolean;
+  updated: boolean;
+  currentVersion?: string;
+  latestVersion?: string;
+  reason?: "disabled" | "not-installed" | "recent" | "lookup-failed" | "up-to-date" | "uv-missing" | "upgrade-failed";
+}
+
+/** Read the cached update-check state (null when missing/corrupt). */
+export function readUpdateState(flagPath = UPDATE_FLAG): MempalaceUpdateState | null {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(flagPath, "utf-8")) as MempalaceUpdateState;
+    if (typeof parsed?.checkedAt !== "number" || typeof parsed?.latestVersion !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/** Persist the update-check state atomically. */
+export function writeUpdateState(state: MempalaceUpdateState, flagPath = UPDATE_FLAG): void {
+  try {
+    fs.mkdirSync(path.dirname(flagPath), { recursive: true });
+    const temp = `${flagPath}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(state, null, 2), "utf-8");
+    fs.renameSync(temp, flagPath);
+  } catch { /* ignore */ }
+}
+
+/** Is a PyPI lookup due? (no state yet, or the TTL has elapsed) */
+export function isUpdateCheckDue(
+  flagPath = UPDATE_FLAG,
+  now = Date.now(),
+  ttlMs = UPDATE_CHECK_TTL_MS,
+): boolean {
+  const state = readUpdateState(flagPath);
+  if (!state) return true;
+  return now - state.checkedAt >= ttlMs;
+}
+
+/** Numeric dotted-version compare: >0 if a is newer, <0 if older, 0 if equal. */
+export function compareVersions(a: string, b: string): number {
+  const pa = String(a ?? "").trim().split(".");
+  const pb = String(b ?? "").trim().split(".");
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const na = Number.parseInt(pa[i] ?? "0", 10) || 0;
+    const nb = Number.parseInt(pb[i] ?? "0") || 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+
+/** Latest MemPalace version on PyPI, or null on any failure. */
+export async function fetchLatestMempalaceVersion(
+  fetchImpl: typeof fetch = fetch,
+): Promise<string | null> {
+  try {
+    const res = await fetchImpl(PYPI_URL, { signal: AbortSignal.timeout(8_000) });
+    if (!res.ok) return null;
+    const body = (await res.json()) as { info?: { version?: string } };
+    return typeof body?.info?.version === "string" ? body.info.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Is the opt-in MemPalace daemon currently running? */
+function daemonRunning(): boolean {
+  try {
+    const res = spawnSync("mempalace", ["daemon", "status"], { encoding: "utf-8", timeout: 10_000 });
+    return /is running/i.test(res.stdout || "");
+  } catch {
+    return false;
+  }
+}
+
+/** Fire-and-forget process run; resolves null on spawn failure or non-zero exit. */
+function runProcess(bin: string, args: string[], timeoutMs: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(bin, args, { stdio: ["ignore", "ignore", "ignore"] });
+    } catch {
+      resolve(false);
+      return;
+    }
+    let settled = false;
+    const finish = (ok: boolean) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(ok);
+    };
+    const timer = setTimeout(() => {
+      try { child.kill(); } catch { /* already gone */ }
+      finish(false);
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", () => finish(false));
+    child.on("close", (code) => finish(code === 0));
+  });
+}
+
+/**
+ * Upgrade MemPalace via `uv tool install --upgrade`. The daemon (if running)
+ * is stopped first and restarted after, so the long-lived process picks up
+ * the new venv instead of straddling versions.
+ */
+async function upgradeMempalace(): Promise<boolean> {
+  if (!which("uv")) return false;
+  const wasRunning = daemonRunning();
+  if (wasRunning) await runProcess("mempalace", ["daemon", "stop"], 30_000);
+  const upgraded = await runProcess("uv", ["tool", "upgrade", "mempalace"], 300_000);
+  if (wasRunning) await runProcess("mempalace", ["daemon", "start"], 30_000);
+  return upgraded;
+}
+
+export interface MempalaceUpdateOptions {
+  /** Skip the TTL gate and force a PyPI lookup. */
+  force?: boolean;
+  /** Injectable fetch for tests. */
+  fetchImpl?: typeof fetch;
+  /** Override "now" for TTL math (tests). */
+  now?: number;
+}
+
+/**
+ * Keep the user's MemPalace install current.
+ *
+ * TTL-gated (~daily) PyPI lookup; when a newer release exists and the install
+ * came from uv, runs `uv tool upgrade mempalace` in the background. Never
+ * throws — callers fire-and-forget this from session_start.
+ */
+export async function maybeAutoUpdateMempalace(
+  options: MempalaceUpdateOptions = {},
+): Promise<MempalaceUpdateOutcome> {
+  const now = options.now ?? Date.now();
+  if (loadEmbeddingConfig().mempalaceAutoUpdate === false) {
+    return { checked: false, updated: false, reason: "disabled" };
+  }
+  const install = readCachedInstall();
+  if (!install) return { checked: false, updated: false, reason: "not-installed" };
+
+  if (!options.force && !isUpdateCheckDue(UPDATE_FLAG, now, UPDATE_CHECK_TTL_MS)) {
+    return { checked: false, updated: false, reason: "recent" };
+  }
+
+  const latest = await fetchLatestMempalaceVersion(options.fetchImpl).catch(() => null);
+  const previous = readUpdateState()?.latestVersion ?? "";
+  writeUpdateState({ checkedAt: now, latestVersion: latest ?? previous });
+  if (!latest) {
+    return { checked: true, updated: false, currentVersion: install.version, reason: "lookup-failed" };
+  }
+
+  const current = detectVersion(install.python);
+  if (compareVersions(latest, current) <= 0) {
+    return { checked: true, updated: false, currentVersion: current, latestVersion: latest, reason: "up-to-date" };
+  }
+
+  const upgraded = await upgradeMempalace();
+  if (!upgraded) {
+    return { checked: true, updated: false, currentVersion: current, latestVersion: latest, reason: "upgrade-failed" };
+  }
+
+  // Refresh the cached install record so the new version is used next bridge call.
+  const python = findVenvPython();
+  if (python) writeCachedInstall({ python, version: detectVersion(python) });
+  invalidatePingVerified();
+  return { checked: true, updated: true, currentVersion: current, latestVersion: latest };
+}

package/packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.14.2",
+  "version": "2.16.0",
   "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -39,8 +39,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "2.14.2",
-    "@pi-unipi/info-screen": "2.14.2",
+    "@pi-unipi/core": "2.16.0",
+    "@pi-unipi/info-screen": "2.16.0",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {

package/packages/memory/settings.ts

@@ -26,6 +26,8 @@ export interface EmbeddingConfig {
   lastModel?: string;
   /** Whether to show migration warning on startup */
   suppressMigrationWarning?: boolean;
+  /** Keep the MemPalace backend current via a daily PyPI check + uv upgrade */
+  mempalaceAutoUpdate?: boolean;
 }
 
 /** Default configuration */
@@ -34,6 +36,7 @@ const DEFAULT_CONFIG: EmbeddingConfig = {
   model: "openai/text-embedding-3-small",
   dimensions: 384,
   suppressMigrationWarning: false,
+  mempalaceAutoUpdate: true,
 };
 
 /** Known embedding models on OpenRouter */

package/packages/memory/tui/settings-tui.ts

@@ -83,6 +83,13 @@ export async function showMemorySettings(ctx: ExtensionCommandContext): Promise<
       description: "Embedding dimensions (lower = faster, less storage)",
     });
 
+    // MemPalace auto-update
+    options.push({
+      label: `⬆️ MemPalace Auto-Update: ${config.mempalaceAutoUpdate === false ? "Off" : "On"}`,
+      value: "__toggle_autoupdate__",
+      description: "Daily PyPI check; upgrades the backend via uv when a newer MemPalace ships",
+    });
+
     // Re-embed
     if (ready && hasModelChanged()) {
       options.push({
@@ -145,6 +152,13 @@ export async function showMemorySettings(ctx: ExtensionCommandContext): Promise<
         saveEmbeddingConfig(cfg);
         ui.notify("Migration warning suppressed.", "info");
         break;
+      case "__toggle_autoupdate__": {
+        const autoCfg = loadEmbeddingConfig();
+        autoCfg.mempalaceAutoUpdate = autoCfg.mempalaceAutoUpdate === false;
+        saveEmbeddingConfig(autoCfg);
+        ui.notify(`MemPalace auto-update ${autoCfg.mempalaceAutoUpdate ? "enabled" : "disabled"}.`, "info");
+        break;
+      }
     }
   }
 }

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.14.2",
+  "version": "2.16.0",
   "description": "Lifecycle layer for project-level goals — MILESTONES.md tracking, session hooks, auto-sync",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.14.2"
+    "@pi-unipi/core": "2.16.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/notify/README.md

@@ -61,6 +61,22 @@ Desktop notifications via [node-notifier](https://github.com/mikaelbr/node-notif
 
 Zero configuration — works out of the box. Set `native.suppressWhenFocused` to `true` to skip native notifications when the active/focused window is already Pi.
 
+### Silence after input
+
+After a terminal keypress, listed platforms stay quiet for `windowMs`. Default: **off**, native only, 10s. Edit in `/unipi:notify-settings` → Platforms (Quiet after activity + channel chips), or in `~/.unipi/config/notify/config.json`:
+
+```json
+{
+  "silenceAfterInput": {
+    "enabled": true,
+    "windowMs": 10000,
+    "platforms": ["native"]
+  }
+}
+```
+
+Add `gotify`, `telegram`, or `ntfy` to `platforms` to silence those channels too. Empty `platforms` silences all enabled platforms (same as `events.*.platforms`).
+
 ### Gotify
 
 Self-hosted push notification server:

package/packages/notify/activity.ts

@@ -0,0 +1,100 @@
+/**
+ * @pi-unipi/notify — Recent terminal-input activity
+ *
+ * Tracks the last interactive keypress so dispatch can silence selected
+ * platforms while the user is at the keyboard.
+ */
+
+import type {
+  NotifyConfig,
+  NotifyPlatform,
+  SilenceAfterInputConfig,
+} from "./types.js";
+
+/** Known platform names — unknown strings are dropped when merging config. */
+const VALID_PLATFORMS: ReadonlySet<NotifyPlatform> = new Set([
+  "native",
+  "gotify",
+  "telegram",
+  "ntfy",
+]);
+
+let lastInputAt = 0;
+
+/** Record a terminal keypress. `at` is injectable for tests. */
+export function noteInput(at: number = Date.now()): void {
+  lastInputAt = at;
+}
+
+/** Clear activity (session start/shutdown). */
+export function resetInputActivity(): void {
+  lastInputAt = 0;
+}
+
+/**
+ * Split already-enabled platforms into "send" vs "silenced by recent input".
+ * Does not look at platform `enabled` flags — caller filters those first.
+ * Empty `platforms` (while enabled) silences all incoming channels, matching
+ * `events.*.platforms: []` → all enabled.
+ */
+export function filterPlatformsAfterInput(
+  platforms: NotifyPlatform[],
+  config: Pick<NotifyConfig, "silenceAfterInput">,
+  now: number = Date.now(),
+): { send: NotifyPlatform[]; silenced: NotifyPlatform[] } {
+  const cfg = config.silenceAfterInput;
+  if (!shouldSilence(cfg, now)) {
+    return { send: platforms.slice(), silenced: [] };
+  }
+  if (cfg.platforms.length === 0) {
+    return { send: [], silenced: platforms.slice() };
+  }
+  const silent = new Set(cfg.platforms);
+  const send: NotifyPlatform[] = [];
+  const silenced: NotifyPlatform[] = [];
+  for (const platform of platforms) {
+    if (silent.has(platform)) silenced.push(platform);
+    else send.push(platform);
+  }
+  return { send, silenced };
+}
+
+/** Normalize a partial config blob against defaults. */
+export function mergeSilenceAfterInput(
+  loaded: Partial<SilenceAfterInputConfig> | undefined,
+  defaults: SilenceAfterInputConfig,
+): SilenceAfterInputConfig {
+  if (!loaded) {
+    return {
+      enabled: defaults.enabled,
+      windowMs: defaults.windowMs,
+      platforms: defaults.platforms.slice(),
+    };
+  }
+  const platforms = Array.isArray(loaded.platforms)
+    ? loaded.platforms.filter((p): p is NotifyPlatform =>
+        VALID_PLATFORMS.has(p as NotifyPlatform),
+      )
+    : defaults.platforms.slice();
+  const windowMs =
+    typeof loaded.windowMs === "number" &&
+    Number.isFinite(loaded.windowMs) &&
+    loaded.windowMs >= 0
+      ? loaded.windowMs
+      : defaults.windowMs;
+  return {
+    enabled: loaded.enabled ?? defaults.enabled,
+    windowMs,
+    platforms,
+  };
+}
+
+function shouldSilence(
+  cfg: SilenceAfterInputConfig | undefined,
+  now: number,
+): cfg is SilenceAfterInputConfig {
+  if (!cfg?.enabled) return false;
+  if (lastInputAt <= 0) return false;
+  if (now - lastInputAt >= cfg.windowMs) return false;
+  return true;
+}

package/packages/notify/events.ts

@@ -16,6 +16,7 @@ import { sendNtfyNotification } from "./platforms/ntfy.js";
 import { buildAskUserPromptMessage } from "./ask-user-prompt-message.js";
 import { buildPermissionPromptMessage } from "./permission-prompt-message.js";
 import { summarizeLastMessage } from "./summarize.js";
+import { filterPlatformsAfterInput } from "./activity.js";
 
 // Event emitted by @juicesharp/rpiv-ask-user-question before showing its UI.
 // Keep this as a local string until that package publishes an importable
@@ -182,8 +183,11 @@ export async function dispatchNotification(
     return false;
   });
 
+  const { send: platformsToSend, silenced: inputSilenced } =
+    filterPlatformsAfterInput(enabledPlatforms, config);
+
   const results = await Promise.all(
-    enabledPlatforms.map(async (platform) => {
+    platformsToSend.map(async (platform) => {
       try {
         const effectivePriority = await sendToPlatform(platform, title, message, config, cwd, priority);
         return { platform, success: true, ...(effectivePriority === undefined ? {} : { priority: effectivePriority }) };
@@ -202,6 +206,10 @@ export async function dispatchNotification(
     })
   );
 
+  for (const platform of inputSilenced) {
+    results.push({ platform, success: true, suppressed: true });
+  }
+
   const unsuppressed = results.filter((r) => !r.suppressed);
   const allSuccess = results.length > 0 && unsuppressed.every((r) => r.success);
   const suppressedPlatforms = results

package/packages/notify/index.ts

@@ -24,10 +24,14 @@ import {
   setSessionContext,
   clearSessionContext,
 } from "./events.js";
+import { noteInput, resetInputActivity } from "./activity.js";
 
 /** Package version */
 const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
+/** Unsubscribe for the interactive-mode keypress listener. */
+let unsubTerminalInput: (() => void) | undefined;
+
 export default function (pi: ExtensionAPI) {
 
   // Register tools and commands
@@ -37,6 +41,19 @@ export default function (pi: ExtensionAPI) {
   // Session lifecycle — register events and announce module
   pi.on("session_start", async (_event, ctx) => {
     setSessionContext(ctx);
+    resetInputActivity();
+    unsubTerminalInput?.();
+    unsubTerminalInput = undefined;
+    const onTerminalInput = ctx.ui?.onTerminalInput;
+    if (typeof onTerminalInput === "function") {
+      try {
+        unsubTerminalInput = onTerminalInput(() => {
+          noteInput();
+        });
+      } catch {
+        unsubTerminalInput = undefined;
+      }
+    }
     const cwd = process.cwd();
     const config = loadConfig();
     registerEventListeners(pi, config, cwd);
@@ -51,6 +68,9 @@ export default function (pi: ExtensionAPI) {
 
   // Cleanup on session shutdown
   pi.on("session_shutdown", async () => {
+    unsubTerminalInput?.();
+    unsubTerminalInput = undefined;
+    resetInputActivity();
     clearSessionContext();
     unregisterEventListeners();
   });

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.14.2",
+  "version": "2.16.0",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.14.2",
+    "@pi-unipi/core": "2.16.0",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/packages/notify/settings.ts

@@ -8,6 +8,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
 import { NOTIFY_DIRS } from "@pi-unipi/core";
+import { mergeSilenceAfterInput } from "./activity.js";
 import type { NotifyConfig } from "./types.js";
 
 /** Resolve config path (expands ~ to homedir) */
@@ -45,6 +46,11 @@ export const DEFAULT_CONFIG: NotifyConfig = {
     enabled: false,
     model: "openrouter/openai/gpt-oss-20b",
   },
+  silenceAfterInput: {
+    enabled: false,
+    windowMs: 10000,
+    platforms: ["native"],
+  },
 };
 
 /** Load config from disk, returning defaults if missing or invalid */
@@ -60,7 +66,10 @@ export function loadConfig(): NotifyConfig {
   } catch (_err) {
     // Config load failure — using defaults silently.
   }
-  return { ...DEFAULT_CONFIG };
+  // Deep copy: callers (e.g. the settings overlay) mutate the returned config.
+  // A shallow copy would share nested objects with DEFAULT_CONFIG and leak
+  // mutations into later loadConfig() calls (even after Esc/cancel).
+  return structuredClone(DEFAULT_CONFIG);
 }
 
 /** Save config to disk, creating directory if needed */
@@ -110,12 +119,17 @@ export function validateConfig(config: NotifyConfig): string[] {
 
 /** Merge loaded config with defaults to ensure all fields exist */
 function mergeWithDefaults(loaded: Partial<NotifyConfig>): NotifyConfig {
+  const base = structuredClone(DEFAULT_CONFIG);
   return {
-    defaultPlatforms: loaded.defaultPlatforms ?? DEFAULT_CONFIG.defaultPlatforms,
-    events: { ...DEFAULT_CONFIG.events, ...loaded.events },
-    native: { ...DEFAULT_CONFIG.native, ...loaded.native },
-    gotify: { ...DEFAULT_CONFIG.gotify, ...loaded.gotify },
-    telegram: { ...DEFAULT_CONFIG.telegram, ...loaded.telegram },
-    recap: { ...DEFAULT_CONFIG.recap, ...loaded.recap },
+    defaultPlatforms: loaded.defaultPlatforms ?? base.defaultPlatforms,
+    events: { ...base.events, ...loaded.events },
+    native: { ...base.native, ...loaded.native },
+    gotify: { ...base.gotify, ...loaded.gotify },
+    telegram: { ...base.telegram, ...loaded.telegram },
+    recap: { ...base.recap, ...loaded.recap },
+    silenceAfterInput: mergeSilenceAfterInput(
+      loaded.silenceAfterInput,
+      base.silenceAfterInput,
+    ),
   };
 }

package/packages/notify/skills/configure-notify/SKILL.md

@@ -62,6 +62,11 @@ Help users configure the `@pi-unipi/notify` notification system.
     "token": null,
     "priority": 3
   },
+  "silenceAfterInput": {
+    "enabled": false,
+    "windowMs": 10000,
+    "platforms": ["native"]
+  },
   "NOTE": "ntfy section is legacy — migrated to ntfy.json on first run"
 }
 ```
@@ -72,6 +77,24 @@ Help users configure the `@pi-unipi/notify` notification system.
 
 Desktop notifications via node-notifier. Works out of the box on Windows, macOS, Linux.
 
+### Silence after input
+
+Quiet listed platforms for `windowMs` after any terminal keypress. **Default: off.** Same `config.json` as other notify settings.
+
+```json
+"silenceAfterInput": {
+  "enabled": true,
+  "windowMs": 10000,
+  "platforms": ["native"]
+}
+```
+
+- `enabled` — master switch
+- `windowMs` — quiet window in milliseconds (default: 10000)
+- `platforms` — channels to silence (`native`, `gotify`, `telegram`, `ntfy`). Empty list silences all enabled platforms (same as `events.*.platforms`).
+
+TUI: `/unipi:notify-settings` → Platforms → Quiet after activity (Space), ←→ then Space for channels, +/− for the window (1s steps).
+
 ### Gotify (default: disabled)
 
 Self-hosted push notification server. Requires: