@pi-unipi/memory 2.0.13 → 2.1.1

package/mempalace.ts

@@ -0,0 +1,260 @@
+/**
+ * @unipi/memory — MemPalace backend client
+ *
+ * Detects and auto-installs MemPalace (via uv), then invokes the bundled
+ * Python bridge (bridge/mempalace_bridge.py) once per operation using the
+ * MemPalace venv python. Each call is a synchronous spawnSync that prints
+ * one JSON line.
+ *
+ * If MemPalace or uv is unavailable, all operations return null so the
+ * storage layer can fall back to the legacy SQLite path. Memory must never
+ * hard-fail because the backend is missing.
+ */
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+
+/** Default MemPalace palace path. */
+export const DEFAULT_PALACE = path.join(os.homedir(), ".mempalace", "palace");
+
+const INSTALL_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-install");
+const MIGRATED_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-migrated");
+/** Flag written after a successful ping, so subsequent sessions can skip
+ *  the ~0.5s Python cold-start sanity check. Stale after PING_VERIFIED_TTL_MS. */
+const PING_VERIFIED_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-ping-verified");
+const PING_VERIFIED_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+
+/** Path to the bundled bridge script. */
+const BRIDGE_PATH = path.join(dirname(fileURLToPath(import.meta.url)), "bridge", "mempalace_bridge.py");
+
+function dirname(p: string): string {
+  return path.dirname(p);
+}
+
+export interface BridgeResponse<T> {
+  ok: boolean;
+  result?: T;
+  error?: string;
+}
+
+export interface MempalaceRecord {
+  id: string;
+  title: string;
+  content: string;
+  tags: string[];
+  project: string;
+  type: "preference" | "decision" | "pattern" | "summary";
+  created: string;
+  updated: string;
+}
+
+export interface MempalaceSearchResult extends MempalaceRecord {
+  score: number;
+  snippet: string;
+}
+
+export interface MempalaceListItem {
+  id: string;
+  title: string;
+  type: string;
+}
+
+export interface MempalaceListItemAll extends MempalaceListItem {
+  project: string;
+}
+
+export interface MempalaceInstall {
+  python: string;
+  version: string;
+}
+
+/** Check whether a binary is on PATH. */
+function which(bin: string): string | null {
+  try {
+    const res = spawnSync(bin, ["--version"], { encoding: "utf-8", timeout: 5000 });
+    if (res.status === 0 || res.stdout || res.stderr) return bin;
+  } catch { /* ignore */ }
+  // Fallback: `which`
+  try {
+    const res = spawnSync("which", [bin], { encoding: "utf-8" });
+    if (res.status === 0) return res.stdout.trim() || null;
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Locate the MemPalace venv python after a `uv tool install mempalace`.
+ * Uses `uv tool dir` to find the venv root.
+ */
+function findVenvPython(): string | null {
+  try {
+    const res = spawnSync("uv", ["tool", "dir"], { encoding: "utf-8", timeout: 5000 });
+    if (res.status !== 0 || !res.stdout.trim()) return null;
+    const candidate = path.join(res.stdout.trim(), "mempalace", "bin", "python");
+    if (fs.existsSync(candidate)) return candidate;
+    // Some platforms use Scripts/ on Windows — not relevant here but be safe.
+    const win = path.join(res.stdout.trim(), "mempalace", "Scripts", "python.exe");
+    if (fs.existsSync(win)) return win;
+  } catch { /* ignore */ }
+  return null;
+}
+
+/** Read a cached install record. */
+function readCachedInstall(): MempalaceInstall | null {
+  try {
+    if (fs.existsSync(INSTALL_FLAG)) {
+      const parsed = JSON.parse(fs.readFileSync(INSTALL_FLAG, "utf-8"));
+      if (parsed && parsed.python && fs.existsSync(parsed.python)) {
+        return parsed;
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/** Persist an install record so we don't re-detect every session. */
+function writeCachedInstall(install: MempalaceInstall): void {
+  try {
+    fs.mkdirSync(path.dirname(INSTALL_FLAG), { recursive: true });
+    fs.writeFileSync(INSTALL_FLAG, JSON.stringify(install, null, 2), "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Detect mempalace version via the venv python. */
+function detectVersion(python: string): string {
+  try {
+    const res = spawnSync(python, ["-c", "import mempalace; print(getattr(mempalace,'__version__','unknown'))"], { encoding: "utf-8", timeout: 5000 });
+    return (res.stdout || "").trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Ensure MemPalace is installed and return the venv python path.
+ * Auto-installs via `uv tool install mempalace` if missing and uv is
+ * available. Returns null if MemPalace cannot be made available (caller
+ * should fall back to legacy SQLite storage).
+ */
+export function ensureMempalace(): MempalaceInstall | null {
+  const cached = readCachedInstall();
+  if (cached) return cached;
+
+  // 1. Already installed via uv tool? Locate venv python.
+  let python = findVenvPython();
+
+  // 2. If not, and uv is available, install it.
+  if (!python && which("uv")) {
+    try {
+      const res = spawnSync("uv", ["tool", "install", "mempalace"], {
+        encoding: "utf-8",
+        timeout: 180_000, // first install downloads deps + embedding model
+      });
+      if (res.status === 0) {
+        python = findVenvPython();
+      }
+    } catch { /* ignore — fall back */ }
+  }
+
+  if (!python) return null;
+
+  const version = detectVersion(python);
+  const install = { python, version };
+  writeCachedInstall(install);
+  return install;
+}
+
+/** Drop the cached install record (forces re-detection next session). */
+export function invalidateInstallCache(): void {
+  try { if (fs.existsSync(INSTALL_FLAG)) fs.unlinkSync(INSTALL_FLAG); } catch { /* ignore */ }
+  invalidatePingVerified();
+}
+
+/** Was the palace ping-verified recently enough to trust without re-pinging? */
+export function isPingVerified(): boolean {
+  try {
+    if (!fs.existsSync(PING_VERIFIED_FLAG)) return false;
+    const ts = Number.parseInt(fs.readFileSync(PING_VERIFIED_FLAG, "utf-8").trim(), 10);
+    if (!Number.isFinite(ts)) return false;
+    return Date.now() - ts < PING_VERIFIED_TTL_MS;
+  } catch { return false; }
+}
+
+/** Mark the palace as ping-verified (written after a successful ping). */
+export function markPingVerified(): void {
+  try {
+    fs.mkdirSync(path.dirname(PING_VERIFIED_FLAG), { recursive: true });
+    fs.writeFileSync(PING_VERIFIED_FLAG, String(Date.now()), "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Drop the ping-verified flag (forces a real ping next session). */
+export function invalidatePingVerified(): void {
+  try { if (fs.existsSync(PING_VERIFIED_FLAG)) fs.unlinkSync(PING_VERIFIED_FLAG); } catch { /* ignore */ }
+}
+
+/** Has the one-way legacy migration been completed? */
+export function isMigrated(): boolean {
+  return fs.existsSync(MIGRATED_FLAG);
+}
+
+/** Mark the one-way legacy migration complete. */
+export function markMigrated(): void {
+  try {
+    fs.mkdirSync(path.dirname(MIGRATED_FLAG), { recursive: true });
+    fs.writeFileSync(MIGRATED_FLAG, new Date().toISOString(), "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Force re-migration by clearing the flag. */
+export function clearMigratedFlag(): void {
+  try { if (fs.existsSync(MIGRATED_FLAG)) fs.unlinkSync(MIGRATED_FLAG); } catch { /* ignore */ }
+}
+
+/**
+ * Run one bridge command synchronously. Returns the parsed result, or null
+ * on any failure (timeout, non-zero exit, bad JSON, ok=false).
+ */
+export function runBridge<T = unknown>(
+  install: MempalaceInstall,
+  palace: string,
+  cmd: string,
+  args: Record<string, unknown> = {},
+): T | null {
+  let argsJson: string;
+  try {
+    argsJson = JSON.stringify(args);
+  } catch {
+    return null;
+  }
+  let res;
+  try {
+    res = spawnSync(install.python, [BRIDGE_PATH, palace, cmd, argsJson], {
+      encoding: "utf-8",
+      timeout: 60_000,
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+  if (res.error || res.status !== 0) {
+    return null;
+  }
+  const out = (res.stdout || "").trim();
+  if (!out) return null;
+  try {
+    const parsed = JSON.parse(out) as BridgeResponse<T>;
+    if (!parsed.ok) return null;
+    return (parsed.result ?? null) as T | null;
+  } catch {
+    return null;
+  }
+}
+
+/** Ping the bridge — returns true if the backend is alive. */
+export function ping(install: MempalaceInstall, palace: string): boolean {
+  return runBridge<string>(install, palace, "ping") === "pong";
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.0.13",
-  "description": "Persistent cross-session memory with vector search for Pi coding agent",
+  "version": "2.1.1",
+  "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -21,6 +21,7 @@
     "pi-coding-agent",
     "unipi",
     "memory",
+    "mempalace",
     "vector-search",
     "sqlite-vec"
   ],
@@ -32,6 +33,8 @@
     "settings.ts",
     "tools.ts",
     "commands.ts",
+    "mempalace.ts",
+    "bridge/mempalace_bridge.py",
     "tui/**/*",
     "skills/**/*",
     "README.md"
@@ -40,11 +43,11 @@
     "better-sqlite3": "^12.9.0",
     "sqlite-vec": "^0.1.9",
     "js-yaml": "^4.1.0",
-    "@pi-unipi/core": "2.0.13",
-    "@pi-unipi/info-screen": "2.0.13"
+    "@pi-unipi/core": "2.1.1",
+    "@pi-unipi/info-screen": "2.1.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
     "typebox": "^1.1.38"
   },
   "devDependencies": {