@empirical-gauzza/cli 1.0.28 → 1.0.30

package/lib/memoryCommands.js

@@ -50,18 +50,22 @@ const RECALL_PATHS = ['semantic', 'list', 'graph', 'hebbian'];
 const RECALL_HOPS = [1, 2];
 // Hops only mean something on a pathway that walks relationships.
 const RECALL_HOP_PATHS = ['graph', 'hebbian'];
+// Reminder states `memory query --remind-state` may keep. Same enum the server's shared
+// normalizer and Memory.remindState declare.
+const REMIND_STATES = ['pending', 'notified', 'acknowledged', 'cancelled'];
 
 // ─── Scoped `--help` (C-005 item 5) ───────────────────────────────────────────
 // `empirical memory --help` / `empirical memory <sub> --help` print scoped usage instead of
 // the 90-line global help wall bin/empirical.js otherwise short-circuits every --help to.
 
 const MEMORY_SUBCOMMAND_USAGE = {
-  query: 'Usage: empirical memory query --match <query> [--top-k 3] [--category <cat>] [--tags <t1,t2>] [--tags-all <t1,t2>] [--status <s1,s2>] [--path semantic|list|graph|hebbian] [--hops 1|2] [--pretty] [--format table]',
+  query: 'Usage: empirical memory query --match <query> [--top-k 3] [--category <cat>] [--tags <t1,t2>] [--tags-all <t1,t2>] [--status <s1,s2>] [--due-before <ISO date>] [--due-after <ISO date>] [--remind-state pending,notified] [--path semantic|list|graph|hebbian] [--hops 1|2] [--pretty] [--format table]',
   get: 'Usage: empirical memory get --memory-id <id> [--pretty]',
   list: 'Usage: empirical memory list [--category <cat>] [--tags <t1,t2>] [--start-date <ISO>] [--end-date <ISO>] [--limit 20] [--cursor <cursor>] [--oldest] [--pretty] [--format table]',
   record: 'Usage: empirical memory record --category <cat> (--summary <text> | --summary - | --summary-file <path>) [--tags t1,t2] [--node-type observation] [--json-file <path>] [--no-dedupe] [--no-auto-link] [--author-type user|agent]',
   note: 'Usage: empirical memory note --text <note> (--match <query> | --memory-id <id>) [--min-score 0.35]',
   update: 'Usage: empirical memory update (--match <query> | --memory-id <id>) (--patch-json <json> | --json-file <path>) [--min-score 0.35]',
+  acknowledge: 'Usage: empirical memory acknowledge --memory-id <id> [--cancel]   (marks a due reminder done, or dropped with --cancel; frees its slot and clears the alert)',
   delete: 'Usage: empirical memory delete (--match <query> | --memory-id <id>) [--confirm] [--min-score 0.35]\nUsage: empirical memory delete (--tag <t> | --category <c> | --all) --confirm',
   duplicates: 'Usage: empirical memory duplicates --memory-id <id>',
   merge: 'Usage: empirical memory merge --canonical-id <id> --duplicate-id <id> [--no-merge-tags] [--no-merge-relationships]',
@@ -209,6 +213,29 @@ async function runMemoryQuery(args) {
   const pretty = parseFlag(args, '--pretty');
   const format = parseOption(args, '--format', 'json');
 
+  // Reminder filters. Dates are parsed HERE as well as server-side, for the same reason --due
+  // is on record: a typo fails at the terminal, not as a 400 after the round trip. Anything
+  // Date can parse is accepted and sent as the caller typed it.
+  const dueFilters = {};
+  for (const [flag, key] of [['--due-before', 'dueBefore'], ['--due-after', 'dueAfter']]) {
+    const raw = parseOption(args, flag, '');
+    if (!raw) continue;
+    if (Number.isNaN(new Date(raw).getTime())) {
+      warn(`Invalid ${flag} "${raw}". Use an ISO 8601 date, for example 2026-10-14 or 2026-10-14T09:00:00Z.`);
+      process.exit(1);
+    }
+    dueFilters[key] = String(raw).trim();
+  }
+  const remindStateRaw = parseOption(args, '--remind-state', '');
+  const remindState = remindStateRaw
+    ? remindStateRaw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
+    : [];
+  const unknownStates = remindState.filter((s) => !REMIND_STATES.includes(s));
+  if (unknownStates.length) {
+    warn(`--remind-state must be one of: ${REMIND_STATES.join(', ')} (received ${JSON.stringify(unknownStates)})`);
+    process.exit(1);
+  }
+
   // --path / --hops are validated HERE, where the value is decided, so a typo costs no round
   // trip and the message names the four pathways. The server validates the same way (the shared
   // normalizer in packages/server/src/services/recallParams.service.ts); this is a fast local
@@ -252,6 +279,9 @@ async function runMemoryQuery(args) {
   if (tags.length) body.tags = tags;
   if (tagsAll.length) body.tagsAll = tagsAll;
   if (status.length) body.status = status;
+  if (dueFilters.dueBefore) body.dueBefore = dueFilters.dueBefore;
+  if (dueFilters.dueAfter) body.dueAfter = dueFilters.dueAfter;
+  if (remindState.length) body.remindState = remindState;
   if (path) body.path = path;
   if (hops !== null) body.hops = hops;
 
@@ -490,6 +520,23 @@ async function runMemoryRecord(args) {
     payload.authorType = authorType;
   }
 
+  // --due turns the memory into a reminder. Parsed and rejected HERE as well as server-side, so
+  // a typo fails immediately at the terminal instead of coming back as a 400 after the write was
+  // composed. Accepts anything Date can parse, so '2026-10-14' and a full ISO timestamp both work.
+  const dueRaw = parseOption(args, '--due', '');
+  if (dueRaw) {
+    const parsedDue = new Date(dueRaw);
+    if (Number.isNaN(parsedDue.getTime())) {
+      warn(JSON.stringify({
+        error: true,
+        code: 'invalid_due',
+        message: `Invalid --due "${dueRaw}". Use an ISO 8601 date, for example 2026-10-14 or 2026-10-14T09:00:00Z.`
+      }));
+      process.exit(1);
+    }
+    payload.dueAt = parsedDue.toISOString();
+  }
+
   const accessToken = requireAccessToken();
   const baseUrl = resolveApiBaseUrl();
   const recordUrl = new URL('/api/v1/memories', baseUrl).toString();
@@ -549,6 +596,29 @@ async function runMemoryNote(args) {
   log(JSON.stringify(created));
 }
 
+// Closing a reminder from the terminal or from an agent reading a CLI banner. One PUT, the same
+// transition the portal's Mark done / Cancel make; the server retires the alert on every surface.
+async function runMemoryAcknowledge(args) {
+  const memoryId = parseOption(args, '--memory-id', '');
+  const cancel = parseFlag(args, '--cancel');
+  if (!memoryId) {
+    warn(MEMORY_SUBCOMMAND_USAGE.acknowledge);
+    process.exit(1);
+  }
+  const accessToken = requireAccessToken();
+  const baseUrl = resolveApiBaseUrl();
+  const url = new URL(`/api/v1/memories/${encodeURIComponent(memoryId)}`, baseUrl).toString();
+  let response;
+  try {
+    response = await httpJson(url, 'PUT', { remindState: cancel ? 'cancelled' : 'acknowledged' }, buildApiAuthHeaders(accessToken));
+  } catch (error) {
+    printApiError(error);
+    process.exit(1);
+  }
+  const data = response && response.data ? response.data : response;
+  log(JSON.stringify({ id: data.id, remindState: data.remindState, dueAt: data.dueAt || null, message: cancel ? 'Reminder cancelled. Its slot is free.' : 'Reminder marked done. Its slot is free.' }, null, 2));
+}
+
 async function runMemoryUpdate(args) {
   const match = parseOption(args, '--match', '');
   const patchJson = parseOption(args, '--patch-json', '');
@@ -941,9 +1011,21 @@ async function runMemoryBulkImport(args) {
   const bulkUrl = new URL('/api/v1/memories/bulk', baseUrl).toString();
 
   try {
-    const response = await httpJson(bulkUrl, 'POST', { memories, relationships }, buildApiAuthHeaders(accessToken));
-    const data = (response && response.data) ? response.data : response;
-    log(JSON.stringify(data));
+    const enqueueResponse = await httpJson(bulkUrl, 'POST', { memories, relationships }, buildApiAuthHeaders(accessToken));
+    const { jobId } = (enqueueResponse && enqueueResponse.data) ? enqueueResponse.data : enqueueResponse;
+    const statusUrl = new URL(`/api/v1/memories/bulk/${jobId}`, baseUrl).toString();
+
+    const pollIntervalMs = 3000;
+    const maxPolls = 200;
+    for (let i = 0; i < maxPolls; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      const statusResponse = await httpJson(statusUrl, 'GET', undefined, buildApiAuthHeaders(accessToken));
+      const job = (statusResponse && statusResponse.data) ? statusResponse.data : statusResponse;
+      if (job.status === 'succeeded') { log(JSON.stringify(job)); return; }
+      if (job.status === 'failed') { warn(JSON.stringify(job)); process.exit(1); }
+    }
+    warn(JSON.stringify({ error: true, code: 'timeout', message: `Job ${jobId} did not complete within ${(maxPolls * pollIntervalMs) / 1000}s` }));
+    process.exit(1);
   } catch (error) {
     printApiError(error);
     process.exit(1);
@@ -1025,6 +1107,7 @@ async function runMemoryCommand(subArgs) {
       if (sub === 'record') return runMemoryRecord(rest);
       if (sub === 'note') return runMemoryNote(rest);
       if (sub === 'update') return runMemoryUpdate(rest);
+      if (sub === 'acknowledge' || sub === 'ack' || sub === 'done') return runMemoryAcknowledge(rest);
       if (sub === 'delete') return runMemoryDelete(rest);
       if (sub === 'duplicates') return runMemoryDuplicates(rest);
       if (sub === 'merge') return runMemoryMerge(rest);
@@ -1053,6 +1136,7 @@ module.exports = {
   runMemoryRecord,
   runMemoryNote,
   runMemoryUpdate,
+  runMemoryAcknowledge,
   runMemoryDelete,
   runMemoryDuplicates,
   runMemoryMerge,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empirical-gauzza/cli",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Persistent cross-tool memory for AI agents. Give Claude Code, Codex, Copilot, Cursor, and ChatGPT one shared memory: save project context once, recall it everywhere via CLI or MCP.",
   "keywords": [
     "memory",