@rlabs-inc/memory 0.5.9 → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlabs-inc/memory",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",

package/src/cli/commands/serve.ts

@@ -135,6 +135,14 @@ export async function serve(options: ServeOptions) {
         console.log(c.muted(`    Use 'memory migrate --dry-run' to preview changes first`))
       }
 
+      // Note for Gemini CLI API key auth users (OAuth users don't need this)
+      if (!process.env.GEMINI_API_KEY) {
+        console.log()
+        console.log(c.muted(`  ${symbols.info} Using Gemini CLI with API key auth?`))
+        console.log(c.muted(`    Run: GEMINI_API_KEY=your-key memory serve`))
+        console.log(c.muted(`    (OAuth users can ignore this)`))
+      }
+
       console.log()
       console.log(c.muted(`  Press Ctrl+C to stop`))
       console.log()

package/src/core/curator.ts

@@ -818,6 +818,62 @@ This session has ended. Please curate the memories from this conversation accord
       "curator",
     );
 
+    // Temporarily disable hooks in project's .gemini/settings.json
+    // This prevents recursive hook triggering (env vars don't propagate to hook subprocesses)
+    const projectGeminiDir = cwd ? join(cwd, ".gemini") : null;
+    const projectSettingsPath = projectGeminiDir
+      ? join(projectGeminiDir, "settings.json")
+      : null;
+    const backupSettingsPath = projectSettingsPath
+      ? `${projectSettingsPath}.memory-backup`
+      : null;
+    let hadExistingSettings = false;
+
+    if (projectSettingsPath && projectGeminiDir) {
+      try {
+        // Backup existing settings if present
+        if (existsSync(projectSettingsPath)) {
+          hadExistingSettings = true;
+          const existingContent = await Bun.file(projectSettingsPath).text();
+          await Bun.write(backupSettingsPath!, existingContent);
+          logger.debug(
+            `Curator Gemini: Backed up existing settings to ${backupSettingsPath}`,
+            "curator",
+          );
+        }
+
+        // Ensure .gemini directory exists
+        if (!existsSync(projectGeminiDir)) {
+          const { mkdirSync } = await import("fs");
+          mkdirSync(projectGeminiDir, { recursive: true });
+        }
+
+        // Create temporary settings with hooks disabled
+        const tempSettings = {
+          hooks: {
+            disabled: [
+              "inject-memories",
+              "load-session-primer",
+              "curate-memories",
+            ],
+          },
+        };
+        await Bun.write(
+          projectSettingsPath,
+          JSON.stringify(tempSettings, null, 2),
+        );
+        logger.debug(
+          `Curator Gemini: Created temporary settings with hooks disabled`,
+          "curator",
+        );
+      } catch (err: any) {
+        logger.debug(
+          `Curator Gemini: Could not manage settings file: ${err.message}`,
+          "curator",
+        );
+      }
+    }
+
     // Execute CLI with system prompt via environment variable
     // Must run from original project directory so --resume latest finds correct session
     const proc = Bun.spawn(["gemini", ...args], {
@@ -839,6 +895,35 @@ This session has ended. Please curate the memories from this conversation accord
     ]);
     const exitCode = await proc.exited;
 
+    // Cleanup: Restore original settings file
+    if (projectSettingsPath && backupSettingsPath) {
+      try {
+        const { unlinkSync } = await import("fs");
+        if (hadExistingSettings && existsSync(backupSettingsPath)) {
+          // Restore backup
+          const backupContent = await Bun.file(backupSettingsPath).text();
+          await Bun.write(projectSettingsPath, backupContent);
+          unlinkSync(backupSettingsPath);
+          logger.debug(
+            `Curator Gemini: Restored original settings from backup`,
+            "curator",
+          );
+        } else if (existsSync(projectSettingsPath)) {
+          // Delete temporary settings (there was no original)
+          unlinkSync(projectSettingsPath);
+          logger.debug(
+            `Curator Gemini: Removed temporary settings file`,
+            "curator",
+          );
+        }
+      } catch (err: any) {
+        logger.debug(
+          `Curator Gemini: Could not cleanup settings: ${err.message}`,
+          "curator",
+        );
+      }
+    }
+
     logger.debug(`Curator Gemini: Exit code ${exitCode}`, "curator");
     if (stderr && stderr.trim()) {
       logger.debug(`Curator Gemini - stderr: ${stderr}`, "curator");

package/src/server/index.ts

@@ -241,12 +241,15 @@ export async function createServer(config: ServerConfig = {}) {
               // Branch on CLI type - Gemini CLI vs Claude Code
               if (body.cli_type === 'gemini-cli') {
                 // Use Gemini CLI for curation (no Claude dependency)
+                // Fallback to server's GEMINI_API_KEY if hook didn't pass one
+                // (hooks spawned by Gemini CLI may not inherit env vars)
+                const geminiApiKey = body.gemini_api_key || process.env.GEMINI_API_KEY
                 logger.debug('Using Gemini CLI for curation', 'server')
                 result = await curator.curateWithGeminiCLI(
                   body.claude_session_id,
                   body.trigger,
                   body.cwd,  // Run from original project directory
-                  body.gemini_api_key
+                  geminiApiKey
                 )
               } else {
                 // Default: Use Claude Code (session resume or transcript parsing)
@@ -303,13 +306,15 @@ export async function createServer(config: ServerConfig = {}) {
                     let managementResult
                     if (cliType === 'gemini-cli') {
                       // Use Gemini CLI for management (no Claude dependency)
+                      // Use same API key fallback as curation (hooks don't inherit env vars)
+                      const geminiApiKey = body.gemini_api_key || process.env.GEMINI_API_KEY
                       logger.debug('Using Gemini CLI for management', 'server')
                       managementResult = await manager.manageWithGeminiCLI(
                         body.project_id,
                         sessionNumber,
                         result,
                         storagePaths,
-                        body.gemini_api_key
+                        geminiApiKey
                       )
                     } else {
                       // Use Claude Agent SDK mode - more reliable than CLI