claude-mem-lite 3.28.2 → 3.29.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.28.2",
+      "version": "3.29.0",
       "source": "./",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.28.2",
+  "version": "3.29.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/format-utils.mjs

@@ -29,16 +29,20 @@ export function truncate(str, max = 80) {
 //      memory-context / session-handoff). User-derived text containing one LITERALLY
 //      would prematurely open/close the block it lands in, spilling the rest as
 //      undelimited context.
-//   2. Harness-authority tags the runtime injects (system-reminder / task-notification).
-//      Memory replays arbitrary captured text \u2014 file contents, tool output, web pages \u2014
-//      so a poisoned observation carrying a literal <system-reminder>\u2026</system-reminder>
-//      would smuggle a forged privileged-channel instruction into the model's context.
-//      It can't escape its wrapper (class 1 closers are defanged), but a nested forged
-//      authority tag is still an indirect-prompt-injection vector; strip the brackets so
-//      it reads as inert text. Other tags (<other-tag>) are deliberately left intact.
+//   2. Harness-authority + tool-call tags the runtime injects (system-reminder /
+//      task-notification / function_calls / function_results, the latter two also in
+//      their antml:-namespaced form). Memory replays arbitrary captured text \u2014 file
+//      contents, tool output, web pages \u2014 so a poisoned observation carrying a literal
+//      <system-reminder>\u2026</system-reminder> or a forged <function_calls>\u2026</function_calls>
+//      block would smuggle a privileged-channel instruction / fake tool-call narrative
+//      into the model's context. It can't escape its wrapper (class 1 closers are
+//      defanged), but a nested forged authority/tool tag is still an indirect-prompt-
+//      injection vector; strip the brackets so it reads as inert text. Other tags
+//      (<other-tag>) \u2014 and the attribute-bearing <invoke \u2026>/<parameter \u2026> forms \u2014 are
+//      deliberately left intact.
 // Reachable by editing files that contain these tokens \u2014 e.g. developing claude-mem-lite
 // itself, where source/observations carry the delimiter names.
-const CONTEXT_DELIMITER_RE = /<\/?(?:claude-mem-context|memory-context|session-handoff|system-reminder|task-notification)>/gi;
+const CONTEXT_DELIMITER_RE = /<\/?(?:claude-mem-context|memory-context|session-handoff|system-reminder|task-notification|(?:antml:)?function_calls|(?:antml:)?function_results)>/gi;
 
 /**
  * Defang the literal context-block delimiter tags in user-derived text. Strips just the

package/lib/import-jsonl.mjs

@@ -134,8 +134,19 @@ function importToolPair(db, toolUse, toolResult, project) {
  * @param {{project: string}} opts
  * @returns {Promise<{prompts:number, observations:number, skipped:number, orphans:number}>}
  */
+// Cold-start backfill reads the whole transcript into one JS string (the dedup
+// state + the better-sqlite3 transaction below are synchronous, so a drop-in async
+// stream isn't available). V8 caps a single string near 512MB, so a larger file
+// throws a cryptic "Cannot create a string longer than…" mid-read. Fail early with
+// an actionable message instead — well under that hard limit.
+export const MAX_IMPORT_BYTES = 450 * 1024 * 1024;
+
 export async function importJsonl(db, path, { project }) {
-  statSync(path);
+  const st = statSync(path);
+  if (st.size > MAX_IMPORT_BYTES) {
+    const mb = (n) => Math.round(n / (1024 * 1024));
+    throw new Error(`transcript too large (${mb(st.size)}MB > ${mb(MAX_IMPORT_BYTES)}MB cap); split it (e.g. split -l 50000 into parts) and import the parts`);
+  }
   const lines = readFileSync(path, 'utf8').split('\n');
   const seenPrompts = new Set();
   const seenObs = new Set();

package/lib/search-core.mjs

@@ -36,20 +36,45 @@ export function buildSearchFtsQuery(query, { or = false } = {}) {
   return ftsQuery;
 }
 
+// Relative-duration units for `--since`. Months/years intentionally omitted —
+// they're calendar-ambiguous; absolute --from/--to cover longer windows.
+const DURATION_UNIT_MS = { s: 1000, m: 60000, h: 3600000, d: 86400000, w: 604800000 };
+
+/**
+ * Parse a relative duration like "7d", "24h", "90m", "2w", "30s" into ms.
+ * Integer magnitude + single unit only (s/m/h/d/w, case-insensitive).
+ * @returns {{ ok: true, ms: number } | { ok: false }}
+ */
+export function parseDuration(raw) {
+  if (typeof raw !== 'string') return { ok: false };
+  const m = raw.trim().match(/^(\d+)\s*([smhdw])$/i);
+  if (!m) return { ok: false };
+  const n = parseInt(m[1], 10);
+  if (!Number.isInteger(n) || n <= 0) return { ok: false };
+  return { ok: true, ms: n * DURATION_UNIT_MS[m[2].toLowerCase()] };
+}
+
 /**
  * Parse from/to date bounds to epoch ms. Date-only `to` (YYYY-MM-DD) extends
- * to end-of-day so "to 2026-06-12" includes that day's rows.
+ * to end-of-day so "to 2026-06-12" includes that day's rows. An optional
+ * relative `sinceRaw` ("7d") sets the lower bound when no absolute `--from`
+ * is given; an explicit `--from` always wins (it's the more specific signal).
  * @returns {{ ok: true, epochFrom: number|null, epochTo: number|null }
- *         | { ok: false, bad: 'from'|'to', value: string }}
+ *         | { ok: false, bad: 'from'|'to'|'since', value: string }}
  */
-export function parseDateBounds(fromRaw, toRaw) {
-  const epochFrom = fromRaw ? new Date(fromRaw).getTime() : null;
+export function parseDateBounds(fromRaw, toRaw, sinceRaw = null, now = Date.now()) {
+  let epochFrom = fromRaw ? new Date(fromRaw).getTime() : null;
   let epochTo = toRaw ? new Date(toRaw).getTime() : null;
   if (epochTo !== null && toRaw && /^\d{4}-\d{2}-\d{2}$/.test(toRaw)) {
     epochTo += 86400000 - 1; // extend to 23:59:59.999
   }
   if (epochFrom !== null && isNaN(epochFrom)) return { ok: false, bad: 'from', value: fromRaw };
   if (epochTo !== null && isNaN(epochTo)) return { ok: false, bad: 'to', value: toRaw };
+  if (sinceRaw) {
+    const d = parseDuration(sinceRaw);
+    if (!d.ok) return { ok: false, bad: 'since', value: sinceRaw };
+    if (epochFrom === null) epochFrom = now - d.ms; // explicit --from takes precedence
+  }
   return { ok: true, epochFrom, epochTo };
 }
 

package/mem-cli.mjs

@@ -42,7 +42,7 @@ import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } from './lib/observation-write.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
 import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
-import { buildSearchFtsQuery, parseDateBounds, coreRunSearchPipeline } from './lib/search-core.mjs';
+import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
 import { computeCitationFunnelTrend } from './lib/citation-tracker.mjs';
@@ -58,7 +58,7 @@ async function cmdSearch(db, args, { llm } = {}) {
   const { positional, flags } = parseArgs(args);
   const query = positional.join(' ');
   if (!query) {
-    fail('[mem] Usage: claude-mem-lite search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance] [--include-noise] [--deep] [--no-deep] [--rerank]');
+    fail('[mem] Usage: claude-mem-lite search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--since DUR] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance] [--include-noise] [--deep] [--no-deep] [--rerank]');
     return;
   }
 
@@ -76,8 +76,12 @@ async function cmdSearch(db, args, { llm } = {}) {
   }
   const source = flags.source || null; // observations|sessions|prompts (null = all)
   const project = flags.project ? resolveProject(db, flags.project) : null;
-  const bounds = parseDateBounds(flags.from, flags.to);
-  if (!bounds.ok) { fail(`[mem] Invalid --${bounds.bad} date: "${bounds.value}". Use YYYY-MM-DD or ISO 8601.`); return; }
+  const bounds = parseDateBounds(flags.from, flags.to, flags.since);
+  if (!bounds.ok) {
+    if (bounds.bad === 'since') fail(`[mem] Invalid --since "${bounds.value}". Use <N><unit>, e.g. 7d, 24h, 90m, 2w.`);
+    else fail(`[mem] Invalid --${bounds.bad} date: "${bounds.value}". Use YYYY-MM-DD or ISO 8601.`);
+    return;
+  }
   const { epochFrom: dateFrom, epochTo: dateTo } = bounds;
   // Inverted range silently returns 0 rows; warn so users see the cause, don't error
   // (a deliberate "search for nothing in this window" is not malformed input).
@@ -352,6 +356,12 @@ function cmdRecent(db, args) {
   const wheres = ['COALESCE(compressed_into, 0) = 0', 'superseded_at IS NULL'];
   if (project) { wheres.push('project = ?'); params.push(project); }
   if (type) { wheres.push('type = ?'); params.push(type); }
+  // --since: relative lower bound on created_at (e.g. "recent 1000 --since 24h").
+  if (flags.since !== undefined) {
+    const d = parseDuration(flags.since);
+    if (!d.ok) { fail(`[mem] Invalid --since "${flags.since}". Use <N><unit>, e.g. 7d, 24h, 90m, 2w.`); return; }
+    wheres.push('created_at_epoch >= ?'); params.push(Date.now() - d.ms);
+  }
   params.push(limit);
 
   const rows = db.prepare(`
@@ -2485,6 +2495,7 @@ Commands:
     --project P         Filter by project
     --from DATE         Start date (YYYY-MM-DD or ISO 8601)
     --to DATE           End date (YYYY-MM-DD or ISO 8601)
+    --since DUR         Relative lower bound: 7d|24h|90m|2w|30s (ignored if --from set)
     --importance N      Minimum importance (1=routine, 2=notable, 3=critical)
     --branch B          Filter by git branch
     --offset N          Skip first N results (pagination)
@@ -2496,6 +2507,7 @@ Commands:
 
   recent [N]            Show N most recent observations (default 10)
     --limit N           Sibling-parity alias for [N] (max 1000)
+    --since DUR         Only items newer than a relative window: 7d|24h|90m|2w|30s
     --project P         Filter by project
     --type T            Filter obs type (bugfix|decision|discovery|feature|refactor|change)
     --json              Output as JSON: {project,limit,type,total,results:[…]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.28.2",
+  "version": "3.29.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/tier.mjs

@@ -73,7 +73,14 @@ export const TIER_CASE_SQL = `(CASE
   WHEN type = 'bugfix'    AND created_at_epoch >= ? THEN 'active'
   WHEN type = 'refactor'  AND created_at_epoch >= ? THEN 'active'
   WHEN type = 'change'    AND created_at_epoch >= ? THEN 'active'
-  WHEN created_at_epoch >= ? THEN 'active'
+  -- Default-window fallthrough is for UNKNOWN/null types ONLY, mirroring
+  -- computeTier's ACTIVE_WINDOWS[type] with a DEFAULT fallback (a KNOWN type
+  -- never takes the fallback). Without the type guard, a known type whose window
+  -- was configured SHORTER than the default would wrongly re-qualify as 'active'
+  -- here after its own window expired — diverging from the JS classifier.
+  -- The "type IS NULL" arm keeps null-type rows on the default window (JS parity).
+  WHEN (type IS NULL OR type NOT IN ('decision','discovery','feature','bugfix','refactor','change'))
+       AND created_at_epoch >= ? THEN 'active'
   ELSE 'archive'
 END)`;