claude-mem-lite 2.62.1 → 2.63.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.62.1",
+      "version": "2.63.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.62.1",
+  "version": "2.63.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/install.mjs

@@ -280,6 +280,25 @@ function ok(msg) { console.log(`  ✓ ${msg}`); }
 function warn(msg) { console.log(`  ⚠ ${msg}`); }
 function fail(msg) { console.log(`  ✗ ${msg}`); }
 
+// Pure JSON-version field bumper for the release pipeline. Reads `filePath`,
+// walks `keyPath` (e.g. `['version']` or `['plugins', 0, 'version']`), and
+// rewrites only when the new value differs. Returns `{ changed, prev }` so
+// callers can log "X → Y" with the captured-before-mutation value — pre-2.63.0
+// the plugin.json branch in syncVersions logged "Y → Y" because it read the
+// field after assignment.
+export function bumpJsonField(filePath, keyPath, newVal) {
+  const json = JSON.parse(readFileSync(filePath, 'utf8'));
+  let parent = json;
+  for (let i = 0; i < keyPath.length - 1; i++) parent = parent?.[keyPath[i]];
+  if (!parent) return { changed: false, prev: undefined };
+  const lastKey = keyPath[keyPath.length - 1];
+  const prev = parent[lastKey];
+  if (prev === newVal) return { changed: false, prev };
+  parent[lastKey] = newVal;
+  writeFileSync(filePath, JSON.stringify(json, null, 2) + '\n');
+  return { changed: true, prev };
+}
+
 // Doctor's final summary line. Pure function so the 4-way contract
 // (clean / warnings-only / issues / mixed) is unit-testable without spinning
 // up the full doctor pipeline. `issues` are ✗-level (action required);
@@ -1593,34 +1612,19 @@ function syncVersions() {
   const version = pkg.version;
   log(`package.json version: ${version}`);
 
-  // Sync plugin.json
   const pluginJsonPath = join(PROJECT_DIR, '.claude-plugin', 'plugin.json');
   if (existsSync(pluginJsonPath)) {
-    const pluginJson = JSON.parse(readFileSync(pluginJsonPath, 'utf8'));
-    if (pluginJson.version !== version) {
-      pluginJson.version = version;
-      writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2) + '\n');
-      ok(`plugin.json: ${pluginJson.version} → ${version}`);
-    } else {
-      ok(`plugin.json: already ${version}`);
-    }
+    const r = bumpJsonField(pluginJsonPath, ['version'], version);
+    ok(r.changed ? `plugin.json: ${r.prev} → ${version}` : `plugin.json: already ${version}`);
   } else {
     warn('plugin.json not found');
   }
 
-  // Sync marketplace.json
   const marketJsonPath = join(PROJECT_DIR, '.claude-plugin', 'marketplace.json');
   if (existsSync(marketJsonPath)) {
-    const marketJson = JSON.parse(readFileSync(marketJsonPath, 'utf8'));
-    const plugin = marketJson.plugins?.[0];
-    if (plugin && plugin.version !== version) {
-      const prev = plugin.version;
-      plugin.version = version;
-      writeFileSync(marketJsonPath, JSON.stringify(marketJson, null, 2) + '\n');
-      ok(`marketplace.json: ${prev} → ${version}`);
-    } else if (plugin) {
-      ok(`marketplace.json: already ${version}`);
-    }
+    const r = bumpJsonField(marketJsonPath, ['plugins', 0, 'version'], version);
+    if (r.prev === undefined) warn('marketplace.json: plugins[0] not found');
+    else ok(r.changed ? `marketplace.json: ${r.prev} → ${version}` : `marketplace.json: already ${version}`);
   } else {
     warn('marketplace.json not found');
   }
@@ -1649,6 +1653,29 @@ function syncVersions() {
   console.log('');
 }
 
+// Regenerate package-lock.json via npm@10.9.2 to guarantee CI parity. The
+// drift this prevents: `npm install --package-lock-only` on npm@11+ silently
+// strips top-level `@emnapi/core` + `@emnapi/runtime` entries when those are
+// transitive deps of platform-optional bindings (e.g. `@oxc-parser/binding-*`
+// from knip), and CI's bundled npm@10 (Node 22 default in GitHub Actions)
+// then refuses `npm ci` with EUSAGE. Same recipe bit twice (#8271 / 2.58.2 /
+// 2.62.1) before this guard. The packageManager field in package.json
+// declares the same version for corepack-aware tooling. Network cost: ~5-30s
+// per release; release cadence makes this acceptable.
+function regenerateLockfile() {
+  console.log('\nclaude-mem-lite release — regenerate lockfile (npm@10.9.2)\n');
+  try {
+    execFileSync('npx', ['--yes', 'npm@10.9.2', 'install'], {
+      stdio: 'inherit',
+      cwd: PROJECT_DIR,
+    });
+    ok('lockfile regenerated');
+  } catch (e) {
+    fail('lockfile regen failed: ' + e.message);
+    throw e;
+  }
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 export async function main(argv = process.argv.slice(2)) {
@@ -1680,6 +1707,7 @@ export async function main(argv = process.argv.slice(2)) {
       break;
     case 'release':
       syncVersions();
+      if (!flags.has('--no-lock')) regenerateLockfile();
       break;
     default:
       if (IS_NPX) {
@@ -1699,7 +1727,7 @@ Usage:
   node install.mjs cleanup            Remove stale temp/staging files
   node install.mjs cleanup-hooks      Remove only claude-mem-lite hooks from settings.json
   node install.mjs self-update         Check for and install updates
-  node install.mjs release            Sync version to plugin.json + marketplace.json
+  node install.mjs release            Sync versions (plugin/marketplace/CLAUDE.md) + regen lockfile via npm@10.9.2 (use --no-lock to skip lock regen)
 
   npx claude-mem-lite                 Install via npx (one-liner)
 `);

package/mem-cli.mjs

@@ -447,6 +447,25 @@ function cmdRecall(db, args) {
 
 const OBS_FIELDS = ['id', 'type', 'title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases', 'files_read', 'files_modified', 'project', 'created_at', 'memory_session_id', 'prompt_number', 'importance', 'related_ids', 'access_count', 'branch', 'superseded_at', 'superseded_by', 'last_accessed_at'];
 
+// Integer-typed time-epoch fields on the observations table that the `get`
+// command renders. Callers expect raw ms (audit) AND a relative-time hint
+// (human-scan), so formatObsFieldValue emits both. Other epoch fields like
+// `created_at_epoch` / `optimized_at` / `last_injected_at` aren't in
+// OBS_FIELDS so they don't surface via `get`.
+export const OBS_TIME_FIELDS = ['superseded_at', 'last_accessed_at'];
+
+// Pure formatter — null/undefined/non-time pass through; time fields on
+// integer values render as `<raw> (<relative>)` mirroring the convention
+// already used by `recent` / `timeline` / `recall`. Pre-2.63.0 the get
+// path printed bare ms (e.g. `last_accessed_at: 1778357330957`).
+export function formatObsFieldValue(field, val) {
+  if (val === null || val === undefined) return val;
+  if (OBS_TIME_FIELDS.includes(field) && typeof val === 'number') {
+    return `${val} (${relativeTime(val)})`;
+  }
+  return val;
+}
+
 function renderObsRows(db, ids, requestedFields) {
   const placeholders = ids.map(() => '?').join(',');
   try {
@@ -465,8 +484,9 @@ function renderObsRows(db, ids, requestedFields) {
       const val = r[f];
       if (val === null || val === undefined || val === '') continue;
       if (f === 'text' && r.narrative && typeof val === 'string' && val.startsWith(r.narrative)) continue;
+      const formatted = formatObsFieldValue(f, val);
       const maxLen = f === 'narrative' ? 1000 : f === 'lesson_learned' ? 500 : f === 'text' ? 500 : 200;
-      const display = typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val;
+      const display = typeof formatted === 'string' && formatted.length > maxLen ? formatted.slice(0, maxLen) + '…' : formatted;
       lines.push(`${f}: ${display}`);
     }
     parts.push(lines.join('\n'));
@@ -672,7 +692,12 @@ function cmdTimeline(db, args) {
   if ((!anchorId || isNaN(anchorId)) && queryStr) {
     const ftsQuery = sanitizeFtsQuery(queryStr);
     const found = findFtsAnchor(db, { ftsQuery, project: project ?? null });
-    if (found) anchorId = found;
+    if (found) {
+      anchorId = found.id;
+      if (found.relaxed && !anchorNote) {
+        anchorNote = `(query "${queryStr}" relaxed AND→OR — no row matched all terms)`;
+      }
+    }
   }
 
   // No anchor: show most recent observations (aligned with MCP mem_timeline fallback)

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.62.1",
+  "version": "2.63.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
+  "packageManager": "npm@10.9.2",
   "engines": {
     "node": ">=20"
   },

package/search-engine.mjs

@@ -152,7 +152,7 @@ function expandObsByPRF(db, ctx, now, primaryCount, existingIds, results, includ
  *   1. FTS5 MATCH with the sanitized query (AND-by-default), recency-weighted
  *   2. If AND returns 0 → relaxFtsQueryToOr fallback (mirrors searchObservationsHybrid)
  *
- * Returns the matched observation id, or null. Always skips compressed rows.
+ * Always skips compressed rows.
  *
  * @param {Database} db
  * @param {object} opts
@@ -160,7 +160,8 @@ function expandObsByPRF(db, ctx, now, primaryCount, existingIds, results, includ
  * @param {string|null} [opts.project] restrict to this project (boost-by-membership; null = no filter)
  * @param {number} [opts.nowT]         Date.now() override (for deterministic tests)
  * @param {number} [opts.halfLifeMs]   recency half-life (default DEFAULT_DECAY_HALF_LIFE_MS)
- * @returns {number|null}
+ * @returns {{id:number, relaxed:boolean}|null}  `relaxed:true` when AND returned 0 and OR rescued —
+ *   callers should surface a "(relaxed AND→OR)" hint to mirror search transparency.
  */
 export function findFtsAnchor(db, { ftsQuery, project = null, nowT = null, halfLifeMs = DEFAULT_DECAY_HALF_LIFE_MS } = {}) {
   if (!ftsQuery) return null;
@@ -178,13 +179,13 @@ export function findFtsAnchor(db, { ftsQuery, project = null, nowT = null, halfL
   const stmt = db.prepare(sql);
   try {
     const m = stmt.get(ftsQuery, project, project, now);
-    if (m) return m.id;
+    if (m) return { id: m.id, relaxed: false };
   } catch (e) { debugCatch(e, 'findFtsAnchor-and'); }
   const orQuery = relaxFtsQueryToOr(ftsQuery);
   if (orQuery && orQuery !== ftsQuery) {
     try {
       const m = stmt.get(orQuery, project, project, now);
-      if (m) return m.id;
+      if (m) return { id: m.id, relaxed: true };
     } catch (e) { debugCatch(e, 'findFtsAnchor-or'); }
   }
   return null;

package/server.mjs

@@ -614,11 +614,18 @@ server.registerTool(
 
     // Auto-find anchor via FTS (with recency decay). Routes through shared
     // findFtsAnchor so CLI `timeline --query` and MCP mem_timeline use
-    // identical AND→OR fallback semantics (paired-path per #8217).
+    // identical AND→OR fallback semantics (paired-path per #8217). When the
+    // OR fallback fired, surface a hint so the caller knows the match was
+    // not an exact AND coverage of the query — mirrors search transparency.
     if (!anchorId && args.query) {
       const ftsQuery = sanitizeFtsQuery(args.query);
       const found = findFtsAnchor(db, { ftsQuery, project: args.project ?? null });
-      if (found) anchorId = found;
+      if (found) {
+        anchorId = found.id;
+        if (found.relaxed && !anchorNote) {
+          anchorNote = `(query "${args.query}" relaxed AND→OR — no row matched all terms)`;
+        }
+      }
     }
 
     // No anchor: return most recent