@eleboucher/pi-memini 0.5.11 → 0.6.0

package/dist/index.d.ts

@@ -31,6 +31,7 @@ export declare function floatEnv(name: string, def: number): number;
  */
 export declare function labelsEnv(name?: string): Set<string>;
 export declare function sanitizeNamespace(s: string): string;
+export declare function sanitizeNamespacePath(s: string): string;
 export declare function deriveNamespace(cwd: string | undefined): string;
 export interface ResolvedConfig {
     base_url: string;

package/dist/index.js

@@ -18,6 +18,7 @@
  * MEMINI_API_KEY stay in the environment. See ../README.md for the table.
  */
 import { Type } from "typebox";
+import { resolveNamespace } from "@memini/namespace-resolver";
 const DEFAULT_BASE_URL = "http://localhost:8080";
 const DEFAULT_TIMEOUT_MS = 30000;
 const DEFAULT_RECALL_LIMIT = 3;
@@ -72,6 +73,17 @@ export function sanitizeNamespace(s) {
         .replace(/[^A-Za-z0-9._-]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+// sanitizeNamespacePath sanitizes a hierarchical namespace per segment,
+// preserving the "/" separators the resolver's tenant paths carry
+// (work/memini must not flatten to work-memini — the other integrations keep
+// the separator, and flattening would split memory across integrations).
+export function sanitizeNamespacePath(s) {
+    return String(s)
+        .split("/")
+        .map(sanitizeNamespace)
+        .filter(Boolean)
+        .join("/");
+}
 // deriveNamespace scopes memory to the project: the basename of the working
 // directory, the same scheme memini auto-resolves from a git repo. Returns ""
 // when no path is given.
@@ -86,14 +98,37 @@ export function deriveNamespace(cwd) {
 // testing.
 export function resolveConfig(env, cwd) {
     const e = env || {};
-    const namespace = e.MEMINI_NAMESPACE || deriveNamespace(cwd) || DEFAULT_NAMESPACE;
+    const nsEnv = (e.MEMINI_NAMESPACE || "").trim();
+    let namespace;
+    if (nsEnv) {
+        // MEMINI_NAMESPACE wins and is used raw-trimmed (the server validates the
+        // header). Routing it through sanitizeNamespacePath would alter an explicit
+        // value — the canonical resolver returns it untouched.
+        namespace = nsEnv;
+    }
+    else if (cwd) {
+        const { namespace: resolvedNs } = resolveNamespace({
+            cwd,
+            env: e,
+            integration: "pi",
+        });
+        // Per-segment sanitize: resolver output may be a tenant path (work/memini).
+        namespace = sanitizeNamespacePath(resolvedNs) || DEFAULT_NAMESPACE;
+    }
+    else {
+        // No explicit namespace and no cwd to resolve against.
+        namespace = DEFAULT_NAMESPACE;
+    }
     const recall_limit = (() => {
         const n = Number(e.MEMINI_RECALL_LIMIT);
         return Number.isFinite(n) && n >= 0 ? n : DEFAULT_RECALL_LIMIT;
     })();
     return {
         base_url: e.MEMINI_BASE_URL || e.MEMINI_URL || DEFAULT_BASE_URL,
-        namespace: sanitizeNamespace(namespace) || DEFAULT_NAMESPACE,
+        // namespace is already resolved above (raw-trimmed on the env path,
+        // per-segment sanitized on the resolver path); re-sanitizing here would
+        // flatten tenant separators.
+        namespace: namespace || DEFAULT_NAMESPACE,
         recall: envBool(e.MEMINI_RECALL, true),
         capture: envBool(e.MEMINI_CAPTURE, true),
         recall_limit,
@@ -417,6 +452,12 @@ export default function meminiExtension(pi) {
                 "current workspace state and the user's instructions):",
             ...fit.items,
         ];
+        // /v1/search sets `degraded: "keyword_only"` (plus a `note`) when the query
+        // embed was unavailable and it fell back to keyword-only matching; both are
+        // already on `result`, so surfacing them is a one-line addition.
+        if (result?.degraded) {
+            lines.push(`[memini: ${result.note || "semantic search unavailable — results are keyword-only and may be incomplete"}]`);
+        }
         if (fit.dropped > 0)
             lines.push(`[... ${fit.dropped} item(s) truncated by token budget]`);
         return {
@@ -447,7 +488,6 @@ export default function meminiExtension(pi) {
             metadata.session_id = sid;
         const stored = await client.postJson("/v1/memories", {
             content: buildTurnContent(userText, assistantText),
-            tier: "episodic",
             tags: ["pi"],
             metadata,
         });
@@ -467,7 +507,11 @@ export default function meminiExtension(pi) {
     pi.registerTool({
         name: "memory_recall",
         label: "Recall memory",
-        description: "Recall relevant memories from long-term memory (memini) via hybrid (semantic + keyword) search.",
+        description: "Recall relevant memories from long-term memory (memini) via hybrid (semantic + keyword) search. " +
+            "Call before starting work that may have history: editing an unfamiliar file, debugging a recurring " +
+            "issue, or when asked what's known about something. A degraded:\"keyword_only\" field in the result " +
+            "means semantic search was unavailable and results came from keyword matching alone — treat as " +
+            "incomplete, not exhaustive.",
         parameters: Type.Object({
             query: Type.String({ description: "What to search for" }),
             limit: Type.Optional(Type.Number({ description: "Max results (default 3)" })),
@@ -488,7 +532,9 @@ export default function meminiExtension(pi) {
                 tier: r?.memory?.tier || "",
                 score: typeof r?.score === "number" ? r.score : 0,
             }));
-            return text({ results });
+            // /v1/search already carries `degraded`/`note` on `res`; pass them through
+            // rather than dropping them silently.
+            return text(res?.degraded ? { results, degraded: res.degraded, note: res.note } : { results });
         },
     });
     pi.registerTool({
@@ -519,7 +565,9 @@ export default function meminiExtension(pi) {
     pi.registerTool({
         name: "memory_remember",
         label: "Remember",
-        description: "Store a durable fact, decision, or preference in long-term memory (memini).",
+        description: "Store a durable fact, decision, or preference in long-term memory (memini). Call proactively when " +
+            "the user says 'remember this', after an architectural decision (capture the why), or after " +
+            "discovering a non-obvious bug or convention. Keep memories atomic — one self-contained fact per call.",
         parameters: Type.Object({
             content: Type.String({ description: "The fact to remember" }),
             tier: Type.Optional(Type.String({
@@ -548,8 +596,10 @@ export default function meminiExtension(pi) {
     pi.registerTool({
         name: "memory_forget",
         label: "Forget",
-        description: "Delete a memory from long-term memory (memini) by its id — use when a recalled memory is wrong, " +
-            "outdated, or poisoned. Get the id from memory_recall or memory_list. This is a soft delete (tombstone).",
+        description: "Permanently delete a memory from long-term memory (memini) by its id — use when a recalled memory " +
+            "is wrong, outdated, or poisoned. Get the id from memory_recall or memory_list. To correct a fact, " +
+            "forget the stale one and remember the corrected version — this integration talks to memini over " +
+            "REST, which has no partial-update endpoint.",
         parameters: Type.Object({
             id: Type.String({ description: "The id of the memory to forget (from memory_recall / memory_list)." }),
         }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleboucher/pi-memini",
-  "version": "0.5.11",
+  "version": "0.6.0",
   "description": "Shared cross-session memory for the Pi coding agent, backed by a memini service.",
   "files": [
     "dist"
@@ -12,6 +12,7 @@
     "typecheck": "tsc -p tsconfig.test.json"
   },
   "dependencies": {
+    "@memini/namespace-resolver": "workspace:*",
     "typebox": "^1.1.38"
   },
   "devDependencies": {