@rlabs-inc/memory 0.4.15 → 0.5.0

package/hooks/gemini/curation.ts

@@ -28,16 +28,21 @@ async function main() {
     const sessionId = input.session_id || process.env.GEMINI_SESSION_ID || 'unknown'
     const cwd = input.cwd || process.env.GEMINI_PROJECT_DIR || process.cwd()
     const projectId = getProjectId(cwd)
-    
+
     // Gemini: PreCompress has 'trigger', SessionEnd has 'reason'
     const eventName = input.hook_event_name || 'unknown'
+    const reason = input.reason || 'unknown'
     let trigger = 'session_end'
-    
+
     if (eventName === 'PreCompress') {
         trigger = 'pre_compact'
     }
 
-    console.error(info(`🧠 Curating memories (${eventName})...`))
+    // Debug: log the full input to see what Gemini is sending
+    console.error(info(`🧠 Curation hook called:`))
+    console.error(info(`   event: ${eventName}`))
+    console.error(info(`   reason: ${reason}`))
+    console.error(info(`   session: ${sessionId}`))
 
     const response = await fetch(`${MEMORY_API_URL}/memory/checkpoint`, {
       method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlabs-inc/memory",
-  "version": "0.4.15",
+  "version": "0.5.0",
   "description": "AI Memory System - Consciousness continuity through intelligent memory curation and retrieval",
   "type": "module",
   "main": "dist/index.js",
@@ -52,6 +52,7 @@
     "memory",
     "ai",
     "claude",
+    "gemini",
     "consciousness",
     "retrieval",
     "embeddings",

package/src/cli/commands/install.ts

@@ -353,7 +353,7 @@ async function installGeminiHooks(options: InstallOptions) {
     ],
     SessionEnd: [
       {
-        matcher: 'exit|logout',
+        matcher: '*',
         hooks: [
           {
             name: 'curate-memories',
@@ -376,13 +376,11 @@ async function installGeminiHooks(options: InstallOptions) {
     ...hooksConfig,
   }
 
-  // Enable the hooks
-  const enabledHooks = new Set(settings.hooks.enabled || [])
-  enabledHooks.add('SessionStart')
-  enabledHooks.add('BeforeAgent')
-  enabledHooks.add('PreCompress')
-  enabledHooks.add('SessionEnd')
-  settings.hooks.enabled = Array.from(enabledHooks)
+  // Enable hooks system - both locations for compatibility
+  // hooks.enabled = true is what actually makes hooks fire
+  // hooksConfig.enabled is per Gemini docs but may not be sufficient alone
+  settings.hooks.enabled = true
+  settings.hooksConfig = { enabled: true }
 
   // Write settings
   try {

package/src/core/curator.ts

@@ -801,6 +801,143 @@ This session has ended. Please curate the memories from this conversation accord
     }
   }
 
+  /**
+   * Curate using Gemini CLI (for Gemini-only users)
+   * Uses --resume + --prompt + --output-format json combo
+   * System prompt injected via GEMINI_SYSTEM_MD environment variable
+   */
+  async curateWithGeminiCLI(
+    sessionId: string,
+    triggerType: CurationTrigger = "session_end",
+  ): Promise<CurationResult> {
+    const systemPrompt = this.buildCurationPrompt(triggerType);
+    const userMessage =
+      "This session has ended. Please curate the memories from our conversation according to the instructions in your system prompt. Return ONLY the JSON structure.";
+
+    // Write system prompt to temp file
+    const tempPromptPath = join(homedir(), ".local", "share", "memory", ".gemini-curator-prompt.md");
+
+    // Ensure directory exists
+    const tempDir = join(homedir(), ".local", "share", "memory");
+    if (!existsSync(tempDir)) {
+      const { mkdirSync } = await import("fs");
+      mkdirSync(tempDir, { recursive: true });
+    }
+
+    await Bun.write(tempPromptPath, systemPrompt);
+
+    // Build CLI command
+    const args = [
+      "--resume", sessionId,
+      "-p", userMessage,
+      "--output-format", "json",
+    ];
+
+    logger.debug(`Curator Gemini: Spawning gemini CLI with session ${sessionId}`, "curator");
+
+    // Execute CLI with system prompt via environment variable
+    const proc = Bun.spawn(["gemini", ...args], {
+      env: {
+        ...process.env,
+        MEMORY_CURATOR_ACTIVE: "1", // Prevent recursive hook triggering
+        GEMINI_SYSTEM_MD: tempPromptPath, // Inject our curation prompt
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Capture output
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+
+    logger.debug(`Curator Gemini: Exit code ${exitCode}`, "curator");
+    if (stderr && stderr.trim()) {
+      logger.debug(`Curator Gemini stderr: ${stderr}`, "curator");
+    }
+
+    if (exitCode !== 0) {
+      logger.debug(`Curator Gemini: Failed with exit code ${exitCode}`, "curator");
+      return { session_summary: "", memories: [] };
+    }
+
+    // Parse Gemini JSON output
+    // Note: Gemini CLI outputs log messages before AND after the JSON
+    // We need to extract just the JSON object
+    try {
+      // Find the JSON object - it starts with { and we need to find the matching }
+      const jsonStart = stdout.indexOf('{');
+      if (jsonStart === -1) {
+        logger.debug("Curator Gemini: No JSON object found in output", "curator");
+        logger.debug(`Curator Gemini: Raw stdout: ${stdout.slice(0, 500)}`, "curator");
+        return { session_summary: "", memories: [] };
+      }
+
+      // Find the matching closing brace by counting braces
+      let braceCount = 0;
+      let jsonEnd = -1;
+      for (let i = jsonStart; i < stdout.length; i++) {
+        if (stdout[i] === '{') braceCount++;
+        if (stdout[i] === '}') braceCount--;
+        if (braceCount === 0) {
+          jsonEnd = i + 1;
+          break;
+        }
+      }
+
+      if (jsonEnd === -1) {
+        logger.debug("Curator Gemini: Could not find matching closing brace", "curator");
+        return { session_summary: "", memories: [] };
+      }
+
+      const jsonStr = stdout.slice(jsonStart, jsonEnd);
+      logger.debug(`Curator Gemini: Extracted JSON (${jsonStr.length} chars) from position ${jsonStart} to ${jsonEnd}`, "curator");
+
+      let geminiOutput;
+      try {
+        geminiOutput = JSON.parse(jsonStr);
+        logger.debug(`Curator Gemini: Parsed outer JSON successfully`, "curator");
+      } catch (outerError: any) {
+        logger.debug(`Curator Gemini: Outer JSON parse failed: ${outerError.message}`, "curator");
+        logger.debug(`Curator Gemini: JSON string (first 500): ${jsonStr.slice(0, 500)}`, "curator");
+        return { session_summary: "", memories: [] };
+      }
+
+      // Gemini returns { response: "...", stats: {...} }
+      // The response field contains the AI's output (our curation JSON)
+      const aiResponse = geminiOutput.response || "";
+
+      if (!aiResponse) {
+        logger.debug("Curator Gemini: No response field in output", "curator");
+        return { session_summary: "", memories: [] };
+      }
+
+      logger.debug(`Curator Gemini: Got response (${aiResponse.length} chars)`, "curator");
+
+      // Remove markdown code blocks if present
+      let cleanResponse = aiResponse;
+      const codeBlockMatch = aiResponse.match(/```(?:json)?\s*([\s\S]*?)```/);
+      if (codeBlockMatch) {
+        cleanResponse = codeBlockMatch[1].trim();
+        logger.debug(`Curator Gemini: Extracted JSON from code block (${cleanResponse.length} chars)`, "curator");
+      } else {
+        logger.debug(`Curator Gemini: No code block found, using raw response`, "curator");
+      }
+
+      logger.debug(`Curator Gemini: Calling parseCurationResponse...`, "curator");
+      // Use existing parser
+      const result = this.parseCurationResponse(cleanResponse);
+      logger.debug(`Curator Gemini: Parsed ${result.memories.length} memories`, "curator");
+      return result;
+    } catch (error: any) {
+      logger.debug(`Curator Gemini: Parse error: ${error.message}`, "curator");
+      logger.debug(`Curator Gemini: Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`, "curator");
+      return { session_summary: "", memories: [] };
+    }
+  }
+
   /**
    * Legacy method: Curate using Anthropic SDK with API key
    * Kept for backwards compatibility

package/src/core/manager.ts

@@ -8,6 +8,7 @@ import { join } from 'path'
 import { homedir } from 'os'
 import { existsSync } from 'fs'
 import type { CurationResult } from '../types/memory.ts'
+import { logger } from '../utils/logger.ts'
 
 /**
  * Get the Claude CLI command path
@@ -670,6 +671,255 @@ Please process these memories according to your management procedure. Use the ex
       fullReport,
     }
   }
+
+  /**
+   * Manage using Gemini CLI (for Gemini-only users)
+   * Uses --prompt + --output-format json combo (no --resume needed for manager)
+   * System prompt injected via GEMINI_SYSTEM_MD environment variable
+   */
+  async manageWithGeminiCLI(
+    projectId: string,
+    sessionNumber: number,
+    result: CurationResult,
+    storagePaths?: StoragePaths
+  ): Promise<ManagementResult> {
+    // Skip if disabled via config or env var
+    if (!this._config.enabled || process.env.MEMORY_MANAGER_DISABLED === '1') {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: 'Management agent disabled',
+        fullReport: 'Management agent disabled via configuration',
+      }
+    }
+
+    // Skip if no memories
+    if (result.memories.length === 0) {
+      return {
+        success: true,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: 'No memories to process',
+        fullReport: 'No memories to process - skipped',
+      }
+    }
+
+    // Load skill file
+    const systemPrompt = await this.buildManagementPrompt()
+    if (!systemPrompt) {
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: '',
+        fullReport: 'Error: Management skill file not found',
+        error: 'Management skill not found',
+      }
+    }
+
+    const userMessage = this.buildUserMessage(projectId, sessionNumber, result, storagePaths)
+
+    // Write system prompt to temp file
+    // Include Gemini's tool variables so the manager has access to file tools
+    const geminiSystemPrompt = `${systemPrompt}
+
+## Available Tools
+
+You have access to the following tools to manage memory files:
+
+\${AvailableTools}
+
+Use these tools to read existing memories, write updates, and manage the memory filesystem.
+`
+    const tempPromptPath = join(homedir(), '.local', 'share', 'memory', '.gemini-manager-prompt.md')
+
+    // Ensure directory exists
+    const tempDir = join(homedir(), '.local', 'share', 'memory')
+    if (!existsSync(tempDir)) {
+      const { mkdirSync } = await import('fs')
+      mkdirSync(tempDir, { recursive: true })
+    }
+
+    await Bun.write(tempPromptPath, geminiSystemPrompt)
+
+    logger.debug(`Manager Gemini: Starting management for project ${projectId}`, 'manager')
+    logger.debug(`Manager Gemini: Processing ${result.memories.length} memories`, 'manager')
+    logger.debug(`Manager Gemini: Including directory: ${join(homedir(), '.local', 'share', 'memory')}`, 'manager')
+
+    // Build CLI command (no --resume needed, manager operates on provided data)
+    // CRITICAL: Add --include-directories to allow Gemini to access memory storage
+    // Without this, Gemini is sandboxed to the project directory and can't read/write memories
+    const memoryStoragePath = join(homedir(), '.local', 'share', 'memory')
+    const args = [
+      '-p', userMessage,
+      '--output-format', 'json',
+      '--yolo',  // Auto-approve file operations
+      '--include-directories', memoryStoragePath,  // Allow access to memory storage
+    ]
+
+    logger.debug(`Manager Gemini: Spawning gemini CLI`, 'manager')
+    logger.debug(`Manager Gemini: Running from directory: ${memoryStoragePath}`, 'manager')
+
+    // Execute CLI with system prompt via environment variable
+    // CRITICAL: Run from memory storage directory so it becomes the primary workspace
+    // This allows both READ and WRITE operations (--include-directories only allows reads)
+    const proc = Bun.spawn(['gemini', ...args], {
+      cwd: memoryStoragePath,  // Run FROM memory directory to allow writes
+      env: {
+        ...process.env,
+        MEMORY_CURATOR_ACTIVE: '1',  // Prevent recursive hook triggering
+        GEMINI_SYSTEM_MD: tempPromptPath,  // Inject our management prompt
+      },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+
+    // Capture output
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+    const exitCode = await proc.exited
+
+    logger.debug(`Manager Gemini: Exit code ${exitCode}`, 'manager')
+    if (stderr && stderr.trim()) {
+      logger.debug(`Manager Gemini stderr: ${stderr}`, 'manager')
+    }
+
+    if (exitCode !== 0) {
+      logger.debug(`Manager Gemini: Failed with exit code ${exitCode}`, 'manager')
+      const errorMsg = stderr || `Exit code ${exitCode}`
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: '',
+        fullReport: `Error: Gemini CLI failed with exit code ${exitCode}\n${stderr}`,
+        error: errorMsg,
+      }
+    }
+
+    // Parse Gemini JSON output
+    // Note: Gemini CLI outputs log messages before AND after the JSON
+    // We need to extract just the JSON object
+    logger.debug(`Manager Gemini: Parsing response (${stdout.length} chars)`, 'manager')
+    try {
+      // Find the JSON object - it starts with { and we need to find the matching }
+      const jsonStart = stdout.indexOf('{')
+      if (jsonStart === -1) {
+        logger.debug('Manager Gemini: No JSON object found in output', 'manager')
+        logger.debug(`Manager Gemini: Raw stdout: ${stdout.slice(0, 500)}`, 'manager')
+        return {
+          success: false,
+          superseded: 0,
+          resolved: 0,
+          linked: 0,
+          filesRead: 0,
+          filesWritten: 0,
+          primerUpdated: false,
+          actions: [],
+          summary: 'No JSON in Gemini response',
+          fullReport: 'Manager failed: No JSON object in Gemini CLI output',
+        }
+      }
+
+      // Find the matching closing brace by counting braces
+      let braceCount = 0
+      let jsonEnd = -1
+      for (let i = jsonStart; i < stdout.length; i++) {
+        if (stdout[i] === '{') braceCount++
+        if (stdout[i] === '}') braceCount--
+        if (braceCount === 0) {
+          jsonEnd = i + 1
+          break
+        }
+      }
+
+      if (jsonEnd === -1) {
+        logger.debug('Manager Gemini: Could not find matching closing brace', 'manager')
+        return {
+          success: false,
+          superseded: 0,
+          resolved: 0,
+          linked: 0,
+          filesRead: 0,
+          filesWritten: 0,
+          primerUpdated: false,
+          actions: [],
+          summary: 'Incomplete JSON in Gemini response',
+          fullReport: 'Manager failed: Could not find complete JSON object',
+        }
+      }
+
+      const jsonStr = stdout.slice(jsonStart, jsonEnd)
+      logger.debug(`Manager Gemini: Extracted JSON (${jsonStr.length} chars)`, 'manager')
+
+      const geminiOutput = JSON.parse(jsonStr)
+
+      // Gemini returns { response: "...", stats: {...} }
+      const aiResponse = geminiOutput.response || ''
+
+      if (!aiResponse) {
+        logger.debug('Manager Gemini: No response field in output', 'manager')
+        return {
+          success: true,
+          superseded: 0,
+          resolved: 0,
+          linked: 0,
+          filesRead: 0,
+          filesWritten: 0,
+          primerUpdated: false,
+          actions: [],
+          summary: 'No response from Gemini',
+          fullReport: 'Management completed but no response returned',
+        }
+      }
+
+      logger.debug(`Manager Gemini: Got response (${aiResponse.length} chars)`, 'manager')
+
+      // Parse using our existing SDK parser (same format expected)
+      const result = this._parseSDKManagementResult(aiResponse)
+      logger.debug(`Manager Gemini: Parsed result - superseded: ${result.superseded}, resolved: ${result.resolved}, linked: ${result.linked}`, 'manager')
+      return result
+    } catch (error: any) {
+      logger.debug(`Manager Gemini: Parse error: ${error.message}`, 'manager')
+      logger.debug(`Manager Gemini: Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`, 'manager')
+      return {
+        success: false,
+        superseded: 0,
+        resolved: 0,
+        linked: 0,
+        filesRead: 0,
+        filesWritten: 0,
+        primerUpdated: false,
+        actions: [],
+        summary: '',
+        fullReport: `Error: Failed to parse Gemini response: ${error.message}`,
+        error: error.message,
+      }
+    }
+  }
 }
 
 /**

package/src/server/index.ts

@@ -7,7 +7,7 @@ import { MemoryEngine, createEngine, type EngineConfig } from '../core/engine.ts
 import { Curator, createCurator, type CuratorConfig } from '../core/curator.ts'
 import { EmbeddingGenerator, createEmbeddings } from '../core/embeddings.ts'
 import { Manager, createManager, type ManagerConfig } from '../core/manager.ts'
-import type { CurationTrigger } from '../types/memory.ts'
+import type { CurationTrigger, CurationResult } from '../types/memory.ts'
 import { logger } from '../utils/logger.ts'
 
 /**
@@ -215,29 +215,42 @@ export async function createServer(config: ServerConfig = {}) {
           // Fire and forget - don't block the response
           setImmediate(async () => {
             try {
-              // Try session resume first (v2) - gets full context including tool uses
-              // Falls back to segmented transcript parsing if resume fails
-              let result = await curator.curateWithSessionResume(
-                body.claude_session_id,
-                body.trigger
-              )
+              let result: CurationResult
 
-              // Fallback to transcript-based curation WITH SEGMENTATION if resume returned nothing
-              // This matches the ingest command behavior - breaks large sessions into segments
-              if (result.memories.length === 0) {
-                logger.debug('Session resume returned no memories, falling back to segmented transcript parsing', 'server')
-                result = await curator.curateFromSessionFileWithSegments(
+              // Branch on CLI type - Gemini CLI vs Claude Code
+              if (body.cli_type === 'gemini-cli') {
+                // Use Gemini CLI for curation (no Claude dependency)
+                logger.debug('Using Gemini CLI for curation', 'server')
+                result = await curator.curateWithGeminiCLI(
                   body.claude_session_id,
-                  body.trigger,
-                  body.cwd,
-                  150000, // 150k tokens per segment
-                  (progress) => {
-                    logger.debug(
-                      `Curation segment ${progress.segmentIndex + 1}/${progress.totalSegments}: ${progress.memoriesExtracted} memories (~${Math.round(progress.tokensInSegment / 1000)}k tokens)`,
-                      'server'
-                    )
-                  }
+                  body.trigger
                 )
+              } else {
+                // Default: Use Claude Code (session resume or transcript parsing)
+                // Try session resume first (v2) - gets full context including tool uses
+                // Falls back to segmented transcript parsing if resume fails
+                result = await curator.curateWithSessionResume(
+                  body.claude_session_id,
+                  body.trigger
+                )
+
+                // Fallback to transcript-based curation WITH SEGMENTATION if resume returned nothing
+                // This matches the ingest command behavior - breaks large sessions into segments
+                if (result.memories.length === 0) {
+                  logger.debug('Session resume returned no memories, falling back to segmented transcript parsing', 'server')
+                  result = await curator.curateFromSessionFileWithSegments(
+                    body.claude_session_id,
+                    body.trigger,
+                    body.cwd,
+                    150000, // 150k tokens per segment
+                    (progress) => {
+                      logger.debug(
+                        `Curation segment ${progress.segmentIndex + 1}/${progress.totalSegments}: ${progress.memoriesExtracted} memories (~${Math.round(progress.tokensInSegment / 1000)}k tokens)`,
+                        'server'
+                      )
+                    }
+                  )
+                }
               }
 
               if (result.memories.length > 0) {
@@ -255,19 +268,34 @@ export async function createServer(config: ServerConfig = {}) {
                 const sessionNumber = await engine.getSessionNumber(body.project_id, body.project_path)
                 // Get resolved storage paths from engine config (runtime values, not hardcoded)
                 const storagePaths = engine.getStoragePaths(body.project_id, body.project_path)
+                // Remember cli_type for manager
+                const cliType = body.cli_type
 
                 setImmediate(async () => {
                   try {
                     logger.logManagementStart(result.memories.length)
                     const startTime = Date.now()
 
-                    // Use SDK mode - more reliable than CLI which can go off-rails
-                    const managementResult = await manager.manageWithSDK(
-                      body.project_id,
-                      sessionNumber,
-                      result,
-                      storagePaths
-                    )
+                    // Use appropriate mode based on CLI type
+                    let managementResult
+                    if (cliType === 'gemini-cli') {
+                      // Use Gemini CLI for management (no Claude dependency)
+                      logger.debug('Using Gemini CLI for management', 'server')
+                      managementResult = await manager.manageWithGeminiCLI(
+                        body.project_id,
+                        sessionNumber,
+                        result,
+                        storagePaths
+                      )
+                    } else {
+                      // Use Claude Agent SDK mode - more reliable than CLI
+                      managementResult = await manager.manageWithSDK(
+                        body.project_id,
+                        sessionNumber,
+                        result,
+                        storagePaths
+                      )
+                    }
 
                     logger.logManagementComplete({
                       success: managementResult.success,