@pi-unipi/unipi 2.0.13 → 2.1.0

package/packages/memory/README.md

@@ -1,8 +1,10 @@
 # @pi-unipi/memory
 
-Persistent memory that survives across sessions. Stores facts, preferences, and decisions in SQLite with vector search, so the agent remembers what you told it last week.
+Persistent memory that survives across sessions. Stores facts, preferences, and decisions with semantic vector search, so the agent remembers what you told it last week.
 
-Two storage tiers: SQLite + sqlite-vec for vector similarity search, markdown files for human-readable memories you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
+**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with one-way auto-migration of any existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
+
+Two storage tiers: MemPalace (or SQLite) for vector similarity search, markdown files for a durable human-readable copy you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
 
 ## Commands
 
@@ -72,19 +74,61 @@ Examples:
 Memory has no configuration file. Storage paths are fixed:
 
 ```
-~/.unipi/memory/
+~/.unipi/memory/                 # UniPi memory root (legacy + markdown tier)
+├── .mempalace-install           # Cached MemPalace venv detection
+├── .mempalace-migrated          # One-way migration completion flag
 ├── global/
-│   ├── memory.db              # Global vector DB
+│   ├── memory.db              # Global vector DB (SQLite fallback)
 │   └── *.md                   # Global memory files
 └── <project_name>/
-    ├── memory.db              # Project vector DB
+    ├── memory.db              # Project vector DB (SQLite fallback)
     └── *.md                   # Project memory files
+
+~/.mempalace/palace/             # MemPalace palace (primary backend)
+```
+
+## MemPalace backend
+
+On first load, the memory package:
+1. Detects MemPalace; if missing and `uv` is available, runs
+   `uv tool install mempalace` once (caches the venv python path in
+   `~/.unipi/memory/.mempalace-install`).
+2. Pings the bridge to confirm the palace is usable.
+3. If `~/.unipi/memory/.mempalace-migrated` is absent, performs a one-way
+   read-only migration of every legacy memory (SQLite rows + markdown files
+   across all projects) into MemPalace drawers, then writes the flag.
+   Migration is idempotent (deterministic drawer IDs) and never deletes or
+   mutates legacy files.
+
+Each memory operation invokes a bundled Python bridge
+(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). The
+first MemPalace use on a machine also downloads the default ONNX embedding
+model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
+
+### Forcing re-detection / re-migration
+
+```bash
+rm ~/.unipi/memory/.mempalace-install    # re-detect MemPalace next session
+rm ~/.unipi/memory/.mempalace-migrated   # re-run one-way migration next session
 ```
 
+### Backend override
+
+Set `UNIPI_MEMPALACE_BACKEND` to force a MemPalace backend
+(`sqlite_exact`, `qdrant`, `pgvector`, default `chroma`).
+
+### Embedder identity
+
+MemPalace enforces embedder identity. If a palace was created with a
+different embedding model, writes are rejected — the package then falls
+back to SQLite for that session. Use `mempalace palace set-embedder`
+intentionally to realign, then remove the install cache to re-detect.
+
 ## Dependencies
 
-- `better-sqlite3` — SQLite database
-- `sqlite-vec` — Vector search extension
+- `mempalace` (Python, auto-installed via `uv`) — primary backend
+- `better-sqlite3` — SQLite fallback database
+- `sqlite-vec` — Vector search extension (fallback)
 - `js-yaml` — YAML frontmatter parsing
 - `@pi-unipi/core` — Shared utilities
 

package/packages/memory/index.ts

@@ -7,6 +7,8 @@
  * Auto-consolidates on compaction.
  */
 
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   UNIPI_EVENTS,
@@ -30,7 +32,7 @@ import { registerMemoryCommands } from "./commands.js";
 import { isEmbeddingReady, hasModelChanged } from "./settings.js";
 
 /** Package version */
-const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
 /** Storage instance for current project */
 let projectStorage: MemoryStorage | null = null;
@@ -170,11 +172,12 @@ export default function (pi: ExtensionAPI) {
       } catch (_err) {
         // Count unavailable — status bar shows 0.
       }
-      const vecReady = isEmbeddingReady();
-      const vecIcon = vecReady ? "⚡" : "📝";
+      const mempalaceActive = projectStorage?.isMempalace() ?? false;
+      const backendIcon = mempalaceActive ? "🧠" : (isEmbeddingReady() ? "⚡" : "📝");
+      const warn = hasModelChanged() ? " ⚠" : "";
       ctx.ui.setStatus(
         "unipi-memory",
-        `${vecIcon} mem ${projectCount}p/${projectCountAll}all${hasModelChanged() ? " ⚠" : ""}`
+        `${backendIcon} mem ${projectCount}p/${projectCountAll}all${warn}`
       );
     }
   });

package/packages/memory/mempalace.ts

@@ -0,0 +1,232 @@
+/**
+ * @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");
+
+/** 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 */ }
+}
+
+/** 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/packages/memory/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.0",
+  "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.0",
+    "@pi-unipi/info-screen": "2.1.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
     "typebox": "^1.1.38"
   },
   "devDependencies": {