@empirical-gauzza/cli 1.0.36 → 1.0.38

package/lib/memoryResolve.js

@@ -0,0 +1,112 @@
+'use strict';
+
+// Resolving "which memory did the user mean" from a --match query, shared by every memory
+// subcommand that accepts --match. It lives in its own module so attachmentCommands.js can use
+// it without a require cycle back through memoryCommands.js; memoryCommands.js re-exports the
+// three names so existing importers and tests are unaffected.
+
+const { warn } = require('./ui');
+const { httpJson } = require('./http');
+const { parseOption } = require('./env');
+const { buildApiAuthHeaders } = require('./auth');
+
+async function resolveMemoryByQuery(match, minScore, accessToken, baseUrl, filters) {
+  const queryUrl = new URL('/api/v1/memories/query', baseUrl).toString();
+  const body = { query: match, topK: 5 };
+  if (filters && Object.keys(filters).length) body.filters = filters;
+  let response;
+  try {
+    response = await httpJson(queryUrl, 'POST', body, buildApiAuthHeaders(accessToken));
+  } catch (error) {
+    return { found: false, reason: 'error', message: error.message };
+  }
+
+  const results = (response && response.data && Array.isArray(response.data.results))
+    ? response.data.results
+    : (Array.isArray(response) ? response : []);
+
+  if (!results.length) {
+    return { found: false, reason: 'no_results' };
+  }
+
+  const scored = results.map((r) => ({
+    id: r.id,
+    summary: r.summary,
+    score: r.rankScore != null ? r.rankScore : (r.similarityScore != null ? r.similarityScore : 0)
+  }));
+
+  scored.sort((a, b) => b.score - a.score);
+
+  // A caller-supplied filter (e.g. --tags) that narrows the server-side result set to exactly
+  // one memory is already a stronger disambiguation signal than the semantic score - trust it
+  // outright rather than falling through to the score check below. This matters because Atlas
+  // vector search has a real async indexing lag: a memory created moments ago can come back
+  // with score 0 (unindexed, not "not this one") even when a tag filter already proves it is
+  // the only candidate. Fixes a real bug found 2026-08-25 where delete --match failed on a
+  // memory `query` found instantly, because delete had no way to trust a filtered, unambiguous
+  // result over a stale/zero semantic score.
+  if (filters && Object.keys(filters).length && results.length === 1) {
+    const only = scored[0];
+    return { found: true, memory: { id: only.id, summary: only.summary, score: only.score } };
+  }
+
+  const top = scored[0];
+  const second = scored[1];
+
+  if (top.score < minScore) {
+    return { found: false, reason: 'low_score', candidates: scored.slice(0, 3) };
+  }
+
+  if (second && (top.score - second.score) <= 0.05) {
+    return { found: false, reason: 'ambiguous', candidates: scored.slice(0, 3) };
+  }
+
+  return { found: true, memory: { id: top.id, summary: top.summary, score: top.score } };
+}
+
+// --match resolution depends on Atlas vector search, which has a real async indexing lag:
+// a memory created moments ago can be invisible to $vectorSearch even though it is already
+// findable by tag. Letting --match commands pass --tags narrows the candidate pool directly
+// instead of hoping semantic ranking surfaces the right one - the fix for a real bug found
+// 2026-08-25 where delete --match returned unrelated score-0 candidates for a memory that
+// `query` found instantly. Deliberately --tags (plural) only, not --category: `delete` already
+// uses singular --tag/--category to mean "bulk delete everything in this category", so adding
+// --category here would silently reroute a --match delete into a bulk delete instead of
+// narrowing it - --tags never collides with that bulk-mode gate.
+function parseMatchFilters(args) {
+  const tagsRaw = parseOption(args, '--tags', '');
+  const tags = tagsRaw ? tagsRaw.split(',').map((t) => t.trim()).filter(Boolean) : [];
+  const filters = {};
+  if (tags.length) filters.tags = tags;
+  return filters;
+}
+
+function printMemoryResolveError(result) {
+  if (result.reason === 'no_results') {
+    warn(JSON.stringify({ error: true, code: 'no_results', message: 'No memories matched the query.' }));
+  } else if (result.reason === 'low_score') {
+    warn(JSON.stringify({
+      error: true,
+      code: 'low_score',
+      message: 'Top result score was below --min-score threshold.',
+      candidates: result.candidates
+    }));
+  } else if (result.reason === 'ambiguous') {
+    warn(JSON.stringify({
+      error: true,
+      code: 'ambiguous',
+      message: 'Multiple memories matched with similar scores. Use --memory-id to target one directly.',
+      candidates: result.candidates
+    }));
+  } else if (result.reason === 'error') {
+    warn(JSON.stringify({ error: true, code: 'query_error', message: result.message }));
+  } else {
+    warn(JSON.stringify({ error: true, code: 'resolve_failed', message: 'Could not resolve memory.' }));
+  }
+}
+
+module.exports = {
+  resolveMemoryByQuery,
+  parseMatchFilters,
+  printMemoryResolveError
+};

package/lib/pluginCommands.js

@@ -4,7 +4,7 @@ const { log, warn, uiHeader, uiSuccess } = require('./ui');
 const { detectInstallTargets } = require('./installers/detect');
 const {
   installNativePlugin,
-  OPTIONAL_PLUGIN_NAMES = ['empirical-work-history', 'empirical-scar-tissue', 'empirical-todo']
+  OPTIONAL_PLUGIN_NAMES = ['empirical-work-history', 'empirical-scar-tissue', 'empirical-todo', 'empirical-voice']
 } = require('./installers/nativePlugin');
 const { checkNativePluginUpdates } = require('./pluginUpdateCheck');
 const { addInstalledHosts } = require('./deviceConfig');
@@ -35,6 +35,7 @@ function resolvePluginNames(args = []) {
   if (args.includes('--all-optional') || args.includes('--work-history')) names.push('empirical-work-history');
   if (args.includes('--all-optional') || args.includes('--scar-tissue')) names.push('empirical-scar-tissue');
   if (args.includes('--all-optional') || args.includes('--todo')) names.push('empirical-todo');
+  if (args.includes('--all-optional') || args.includes('--voice')) names.push('empirical-voice');
   return names.filter((name) => name === 'empirical-memory' || OPTIONAL_PLUGIN_NAMES.includes(name));
 }
 
@@ -82,7 +83,7 @@ async function runPluginCommand(args = []) {
   }
   log('');
   log('Native plugin installation does not configure MCP or credentials.');
-  log('Optional packages: --work-history, --scar-tissue, --todo, or --all-optional.');
+  log('Optional packages: --work-history, --scar-tissue, --todo, --voice, or --all-optional.');
   log('Use `empirical auth login` for normal CLI OAuth, or the full `empirical install` flow for MCP setup.');
 }