hippo-memory 1.26.4 → 1.27.0

package/dist/cli.js

@@ -5245,14 +5245,17 @@ function autoDetectContext() {
 // Embed command
 // ---------------------------------------------------------------------------
 async function cmdEmbed(hippoRoot, flags) {
-    requireInit(hippoRoot);
+    // --global mirrors resolveAuthRoot (cli.ts:6900): initGlobal() + the global
+    // root, skipping the local requireInit entirely, so this is the healing
+    // path for pre-1.27.0 global stores from a directory with no local .hippo.
+    const root = resolveAuthRoot(hippoRoot, flags);
     // --status and --reset-physics only read cached state, so they must work even
     // when no provider key is present (e.g. embedded earlier with a key that was
     // later removed). The provider-availability gate is deferred to the embed path.
     if (flags['reset-physics']) {
-        const entries = loadAllEntries(hippoRoot);
-        const embIndex = loadEmbeddingIndex(hippoRoot);
-        const db = openHippoDb(hippoRoot);
+        const entries = loadAllEntries(root);
+        const embIndex = loadEmbeddingIndex(root);
+        const db = openHippoDb(root);
         try {
             const count = resetAllPhysicsState(db, entries, embIndex);
             console.log(`Reset physics state: ${count} particles re-initialized from embeddings.`);
@@ -5263,8 +5266,8 @@ async function cmdEmbed(hippoRoot, flags) {
         return;
     }
     if (flags['status']) {
-        const entries = loadAllEntries(hippoRoot);
-        const embIndex = loadEmbeddingIndex(hippoRoot);
+        const entries = loadAllEntries(root);
+        const embIndex = loadEmbeddingIndex(root);
         const activeIds = new Set(entries.map((e) => e.id));
         const activeEmbedded = Object.keys(embIndex).filter((id) => activeIds.has(id)).length;
         const orphaned = Object.keys(embIndex).length - activeEmbedded;
@@ -5281,7 +5284,7 @@ async function cmdEmbed(hippoRoot, flags) {
     // Embedding (unlike status/reset) needs an available provider.
     const embedProvider = (() => {
         try {
-            return resolveEmbeddingProvider(hippoRoot);
+            return resolveEmbeddingProvider(root);
         }
         catch (err) {
             console.error(err instanceof Error ? err.message : String(err));
@@ -5293,7 +5296,7 @@ async function cmdEmbed(hippoRoot, flags) {
         return;
     }
     if (!embedProvider.isAvailable()) {
-        if (loadConfig(hippoRoot).embeddings.enabled === false) {
+        if (loadConfig(root).embeddings.enabled === false) {
             console.log('Embeddings are disabled in config (embeddings.enabled = false). Set it to true or "auto" to enable.');
             return;
         }
@@ -5311,17 +5314,17 @@ async function cmdEmbed(hippoRoot, flags) {
     console.log('Embedding all memories (this may take a moment on first run to download model)...');
     let count;
     try {
-        count = await embedAll(hippoRoot, resolveEmbeddingModel(hippoRoot));
+        count = await embedAll(root, resolveEmbeddingModel(root));
     }
     catch (err) {
         console.error(`Embedding failed: ${err instanceof Error ? err.message : String(err)}`);
-        const partial = loadEmbeddingIndex(hippoRoot);
+        const partial = loadEmbeddingIndex(root);
         console.error(`Partial progress saved: ${Object.keys(partial).length} embeddings on disk. Re-run \`hippo embed\` to resume.`);
         process.exitCode = 1;
         return;
     }
-    const entriesAfter = loadAllEntries(hippoRoot);
-    const embIndexAfter = loadEmbeddingIndex(hippoRoot);
+    const entriesAfter = loadAllEntries(root);
+    const embIndexAfter = loadEmbeddingIndex(root);
     console.log(`Done. ${count} new embeddings created. ${Object.keys(embIndexAfter).length}/${entriesAfter.length} total.`);
 }
 // ---------------------------------------------------------------------------
@@ -5519,6 +5522,12 @@ function cmdImport(hippoRoot, args, flags) {
         console.log(`  Skipped (unchanged):   ${vaultResult.skipped}`);
         console.log(`  ${dryRun ? 'Would archive:        ' : 'Archived (removed):   '}${vaultResult.archived ?? 0}`);
         console.log(`  Store:                 ${hippoRoot}`);
+        // Batch producer, same contract as the single-file import below: vault rows
+        // write through api.remember (which never embeds), so backfill them here.
+        // Floating promise is deliberate; see the comment at the single-file site.
+        if (!dryRun && vaultResult.imported >= 1) {
+            void embedAll(hippoRoot).catch(() => { });
+        }
         return;
     }
     // Determine which importer to use based on flag
@@ -5565,6 +5574,15 @@ function cmdImport(hippoRoot, args, flags) {
         process.exit(1);
     }
     const result = importer(filePath, importOptions);
+    // Batch producer: embed newly-imported rows on targetRoot in one pass
+    // rather than per-row (importers.ts writeEntry sites don't embed). The
+    // floating promise is deliberate: libuv keeps the process alive until it
+    // settles, so it is not dropped on process exit; `hippo embed --global` (or
+    // a local `hippo embed`) is the backstop if it does get interrupted. Do not
+    // "fix" this by awaiting it, that would block the CLI on model load/backfill.
+    if (!dryRun && result.imported >= 1) {
+        void embedAll(targetRoot).catch(() => { });
+    }
     const storeLabel = useGlobal ? `global (${getGlobalRoot()})` : targetRoot;
     console.log(`\nImport ${importerName}: ${filePath}`);
     console.log(`  Source entries found:  ${result.total}`);