claude-session-continuity-mcp 1.16.1 → 1.17.0

package/README.md

@@ -1,12 +1,14 @@
 # claude-session-continuity-mcp
 
-> **Never re-explain your project to Claude again.** 100% local session memory for Claude Code — auto context injection, semantic search, and error→solution recall. Zero config, zero API cost.
+> **Never re-explain your project to your AI coding agent again.** 100% local session memory for **Claude Code & OpenAI Codex CLI** — auto context injection, semantic search, and error→solution recall. Zero config, zero API cost.
 
 [![npm version](https://img.shields.io/npm/v/claude-session-continuity-mcp.svg)](https://www.npmjs.com/package/claude-session-continuity-mcp)
 [![npm downloads](https://img.shields.io/npm/dm/claude-session-continuity-mcp.svg)](https://www.npmjs.com/package/claude-session-continuity-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![claude-session-continuity-mcp MCP server](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp/badges/card.svg)](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp)
 
+**⚡ One install → context auto-loads every session · 🧩 survives compaction (0 re-explaining) · 🔒 100% local, $0 API**
+
 ![Session continuity demo — Claude auto-restores your project context on session start](assets/demo.gif)
 
 ## The Problem
@@ -24,7 +26,7 @@ Every new Claude Code session:
 
 ## The Solution
 
-**Fully automatic.** Claude Hooks handle everything without manual calls:
+**Fully automatic.** Lifecycle hooks handle everything without manual calls — on **Claude Code** and **OpenAI Codex CLI**, sharing one local memory so context carries across both:
 
 ```bash
 # Session start → Auto-loads relevant context + recent session history
@@ -79,6 +81,19 @@ Most Claude memory tools rely on **explicit tool calls** ("remember this"), a **
 
 If you want zero-config, offline, no-cost memory that just *happens* while you work — this is it.
 
+### Auto-injection vs. explicit search
+
+There's also a great class of **local search** tools (e.g. [ctx](https://github.com/ctxrs/ctx)) that index your agent history so you can *query* it (`search "failed migration"`). That's complementary, not the same job:
+
+| | claude-session-continuity-mcp | Local-search tools (ctx, etc.) |
+|---|---|---|
+| **How you use it** | **Automatic** — context appears on session start, no command | You (or the agent) run a search query |
+| **Compaction** | **PreCompact hook re-injects a handover** → 0 context re-explained after a compact | Not its job (it's a search index) |
+| **Best at** | *Never losing your thread* across sessions & compacts, hands-off | *Finding* a specific past decision/command on demand |
+| **Coverage** | Claude Code + Codex CLI (where auto-injection is possible) | Often 30+ agents indexed for search |
+
+Use search when you want to *look something up*. Use this when you want your context to *follow you* without asking.
+
 ---
 
 ## Works with Codex CLI too (v1.16.0+)
@@ -99,6 +114,26 @@ interface (it can be null at startup), so host detection uses an installer-injec
 
 ---
 
+## Works with Gemini CLI too (v1.17.0+)
+
+Also supports **Google Gemini CLI**. If `~/.gemini` exists, the installer registers
+the hooks in `~/.gemini/settings.json` (SessionStart, BeforeAgent, PreCompress,
+SessionEnd — Gemini's event names), preserving your other settings. Same shared
+local `sessions.db`, so context carries across all three agents.
+
+Gemini's transcript format was verified against real `~/.gemini/tmp/.../chats/*.jsonl`
+files — it uses **two shapes** (a flat `{type, content}` line and an older
+`{"$set":{"messages":[…]}}` diff line); the parser handles both. Like Codex,
+`transcript_path` can be null at startup, so host detection uses a `--gemini` marker.
+
+**Honest scope note:** session save (SessionEnd) and context output are verified working.
+Gemini's `SessionStart` context injection is documented as *advisory-only* upstream
+([gemini-cli#15413](https://github.com/google-gemini/gemini-cli/issues/15413)) — if your
+Gemini build doesn't render the injected context on startup, that's an upstream limit,
+not this tool. Session continuity still works via the saved history.
+
+---
+
 ## Quick Start
 
 ### Recommended: Global Installation

package/dist/hooks/install.js

@@ -19,6 +19,9 @@ const MCP_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
 // Codex CLI (2026-07-09): hooks register in ~/.codex/hooks.json (same JSON shape as Claude)
 const CODEX_DIR = path.join(os.homedir(), '.codex');
 const CODEX_HOOKS_FILE = path.join(CODEX_DIR, 'hooks.json');
+// Gemini CLI (2026-07-10): hooks register inside ~/.gemini/settings.json under a "hooks" key
+const GEMINI_DIR = path.join(os.homedir(), '.gemini');
+const GEMINI_SETTINGS_FILE = path.join(GEMINI_DIR, 'settings.json');
 // 설치된 패키지 경로 찾기
 function getPackagePath() {
     // 1. 글로벌 설치 확인
@@ -164,6 +167,45 @@ function installCodexHooks() {
     }
     catch { /* non-fatal: Codex hooks are optional */ }
 }
+/**
+ * Register the same hooks in ~/.gemini/settings.json for Gemini CLI (2026-07-10).
+ * Only runs if ~/.gemini exists. Hooks live under a "hooks" key inside settings.json
+ * (not a separate file). Preserves the user's other settings and their own hooks;
+ * replaces only ours (matched by the claude-hook- command prefix).
+ * Gemini event names differ: BeforeAgent (≈UserPromptSubmit), PreCompress (≈PreCompact),
+ * SessionEnd (≈Stop). transcript_path can be null at SessionStart, so we inject "--gemini".
+ */
+function installGeminiHooks() {
+    if (!fs.existsSync(GEMINI_DIR))
+        return; // Gemini not installed -> skip silently
+    const OUR_PREFIX = 'claude-hook-';
+    let settings = {};
+    if (fs.existsSync(GEMINI_SETTINGS_FILE)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(GEMINI_SETTINGS_FILE, 'utf-8'));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const hooks = settings.hooks || {};
+    const merge = (event, ourEntries) => {
+        const existing = (hooks[event] || []);
+        const userEntries = existing.filter(e => !(e.command && e.command.includes(OUR_PREFIX)));
+        hooks[event] = [...userEntries, ...ourEntries];
+    };
+    // Gemini hook entries are flat {type, command} (no nested "hooks" array like Claude/Codex).
+    merge('SessionStart', [{ type: 'command', command: 'npm exec -- claude-hook-session-start --gemini' }]);
+    merge('BeforeAgent', [{ type: 'command', command: 'npm exec -- claude-hook-user-prompt --gemini' }]);
+    merge('PreCompress', [{ type: 'command', command: 'npm exec -- claude-hook-pre-compact --gemini' }]);
+    merge('SessionEnd', [{ type: 'command', command: 'npm exec -- claude-hook-session-end --gemini' }]);
+    settings.hooks = hooks;
+    try {
+        fs.writeFileSync(GEMINI_SETTINGS_FILE, JSON.stringify(settings, null, 2));
+        console.log('✅ Gemini CLI hooks installed (~/.gemini/settings.json)');
+    }
+    catch { /* non-fatal: Gemini hooks are optional */ }
+}
 function install() {
     console.log('');
     console.log('╔════════════════════════════════════════════════════════════╗');
@@ -214,6 +256,8 @@ function install() {
     // Codex CLI hooks (2026-07-09): register the same hooks in ~/.codex/hooks.json
     // if Codex is present. Hooks auto-detect the host and emit the right output format.
     installCodexHooks();
+    // Gemini CLI hooks (2026-07-10): same, in ~/.gemini/settings.json if Gemini is present.
+    installGeminiHooks();
     console.log('✅ Hooks installed (npm exec mode - works with local or global install!)');
     console.log('   SessionStart: context auto-load');
     console.log('   UserPromptSubmit: relevant memory injection');
@@ -286,6 +330,24 @@ function uninstall() {
         }
         catch { /* non-fatal */ }
     }
+    // Also remove our hooks from Gemini (2026-07-10), preserving user's settings + hooks.
+    if (fs.existsSync(GEMINI_SETTINGS_FILE)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(GEMINI_SETTINGS_FILE, 'utf-8'));
+            const gh = cfg.hooks || {};
+            for (const event of ['SessionStart', 'BeforeAgent', 'PreCompress', 'SessionEnd']) {
+                const existing = (gh[event] || []);
+                const remaining = existing.filter(e => !(e.command && e.command.includes(OUR_PREFIX)));
+                if (remaining.length === 0)
+                    delete gh[event];
+                else
+                    gh[event] = remaining;
+            }
+            cfg.hooks = gh;
+            fs.writeFileSync(GEMINI_SETTINGS_FILE, JSON.stringify(cfg, null, 2));
+        }
+        catch { /* non-fatal */ }
+    }
     console.log('✅ Hooks removed successfully!');
 }
 function status() {

package/dist/hooks/session-end.js

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import * as crypto from 'crypto';
 import Database from 'better-sqlite3';
-import { logHookError, isCodexHost } from '../utils/logger.js';
+import { logHookError, isCodexHost, isGeminiHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -209,6 +209,8 @@ function parseUserText(entry) {
     text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
     // Codex support (2026-07-09): Codex injects <environment_context> into the first user message -> strip it
     text = text.replace(/<environment_context>[\s\S]*?<\/environment_context>/g, '').trim();
+    // Gemini support (2026-07-10): Gemini injects <session_context> into the first user message -> strip it
+    text = text.replace(/<session_context>[\s\S]*?<\/session_context>/g, '').trim();
     text = text.replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '').trim();
     text = text.replace(/<command-name>[\s\S]*?<\/command-name>/g, '').trim();
     text = text.replace(/<command-message>[\s\S]*?<\/command-message>/g, '').trim();
@@ -297,6 +299,40 @@ function normalizeCodexLine(codexEntry) {
     }
     return null; // skip reasoning/token_count/session_meta etc.
 }
+/** One Gemini message object -> Claude entry (or null to skip). */
+function geminiMsgToEntry(m) {
+    const t = m.type || m.role; // some builds use role
+    if (t !== 'user' && t !== 'gemini' && t !== 'model' && t !== 'assistant')
+        return null;
+    const text = (m.content || []).map(c => c.text || '').filter(Boolean).join('\n');
+    if (!text)
+        return null;
+    return {
+        type: t === 'user' ? 'user' : 'assistant',
+        timestamp: m.timestamp,
+        message: { content: [{ type: 'text', text }] },
+    };
+}
+/**
+ * Normalize a Gemini CLI transcript line into Claude entries (2026-07-10).
+ * REAL Gemini format has two shapes (verified against actual ~/.gemini transcripts —
+ * the docs claimed only the flat shape, but older sessions use the $set diff shape):
+ *  A) flat:  {type:"user"|"gemini", content:[{text}], timestamp}
+ *  B) diff:  {"$set":{"messages":[ {type/role, content:[{text}]}, ... ]}}
+ * Top-level type:"info" lines and message_update patches are skipped.
+ * Returns an array (shape B can carry multiple messages per line).
+ */
+function normalizeGeminiLine(raw) {
+    const entry = raw;
+    // Shape B: $set.messages array
+    const setMsgs = entry?.['$set']?.messages;
+    if (Array.isArray(setMsgs)) {
+        const out = setMsgs.map(geminiMsgToEntry).filter((e) => e !== null);
+        return out.length ? out : null;
+    }
+    // Shape A: flat message line
+    return geminiMsgToEntry(entry);
+}
 /**
  * Single-Pass Transcript Parser
  * JSONL을 1회 스트림으로 읽으며 모든 데이터를 동시 추출
@@ -314,8 +350,10 @@ async function parseTranscriptSinglePass(transcriptPath) {
     };
     if (!transcriptPath || !fs.existsSync(transcriptPath))
         return result;
-    // Host detection: Codex uses ~/.codex/sessions/...rollout-*.jsonl, Claude uses ~/.claude/projects/...
+    // Host detection: Codex uses ~/.codex/sessions/...rollout-*.jsonl,
+    // Gemini uses ~/.gemini/tmp/.../chats/*.jsonl, Claude uses ~/.claude/projects/...
     const isCodex = isCodexHost(transcriptPath); // shared detection (argv marker or path)
+    const isGemini = isGeminiHost(transcriptPath);
     // commit 추출용 패턴
     const commitPatterns = [
         /git commit.*?-m\s*"\$\(cat <<'?EOF'?\n(.+?)(?:\n\n|\nCo-Authored|\nEOF)/s,
@@ -340,73 +378,79 @@ async function parseTranscriptSinglePass(transcriptPath) {
                 continue;
             try {
                 const rawEntry = JSON.parse(line);
-                // For Codex, normalize the rollout line into a Claude entry shape. Skipped lines (reasoning etc.) return null.
-                const entry = isCodex ? normalizeCodexLine(rawEntry) : rawEntry;
-                if (!entry)
+                // Normalize per host into Claude entry shape. Gemini's $set line can yield
+                // multiple entries, so unify everything into an array and process each.
+                const normalized = isCodex ? normalizeCodexLine(rawEntry)
+                    : isGemini ? normalizeGeminiLine(rawEntry)
+                        : rawEntry;
+                if (!normalized)
                     continue;
-                const role = entry.type || entry.role || '';
-                const content = entry.message?.content;
-                // === 0. Timestamp 추출 (세션 duration 계산용) ===
-                if (entry.timestamp) {
-                    if (!result.firstTimestamp)
-                        result.firstTimestamp = entry.timestamp;
-                    result.lastTimestamp = entry.timestamp;
-                }
-                // === 1. Commit 추출 (tool_use 블록에서) ===
-                if (line.includes('git commit') && Array.isArray(content)) {
-                    for (const block of content) {
-                        if (block.type !== 'tool_use')
-                            continue;
-                        const cmd = block.input?.command;
-                        if (!cmd || !cmd.includes('-m'))
-                            continue;
-                        if (!/(?:^|&&\s*)git\s+commit/.test(cmd))
-                            continue;
-                        for (const pattern of commitPatterns) {
-                            const match = cmd.match(pattern);
-                            if (match?.[1]) {
-                                const msg = match[1].trim().split('\n')[0];
-                                if (msg.length > 10 && !msg.startsWith('Co-Authored')) {
-                                    commitSet.add(msg.slice(0, 150));
+                const entries = Array.isArray(normalized) ? normalized : [normalized];
+                for (const entry of entries) {
+                    const role = entry.type || entry.role || '';
+                    const content = entry.message?.content;
+                    // === 0. Timestamp 추출 (세션 duration 계산용) ===
+                    if (entry.timestamp) {
+                        if (!result.firstTimestamp)
+                            result.firstTimestamp = entry.timestamp;
+                        result.lastTimestamp = entry.timestamp;
+                    }
+                    // === 1. Commit 추출 (tool_use 블록에서) ===
+                    if (line.includes('git commit') && Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type !== 'tool_use')
+                                continue;
+                            const cmd = block.input?.command;
+                            if (!cmd || !cmd.includes('-m'))
+                                continue;
+                            if (!/(?:^|&&\s*)git\s+commit/.test(cmd))
+                                continue;
+                            for (const pattern of commitPatterns) {
+                                const match = cmd.match(pattern);
+                                if (match?.[1]) {
+                                    const msg = match[1].trim().split('\n')[0];
+                                    if (msg.length > 10 && !msg.startsWith('Co-Authored')) {
+                                        commitSet.add(msg.slice(0, 150));
+                                    }
+                                    break;
                                 }
-                                break;
                             }
                         }
                     }
-                }
-                // === 2. User Requests 추출 ===
-                if (role === 'human' || role === 'user') {
-                    const text = parseUserText(entry);
-                    if (text) {
-                        const planMatch = text.match(/^Implement the following plan:\s*\n+#\s*(.+)/);
-                        const cleaned = planMatch
-                            ? planMatch[1].trim().slice(0, 100)
-                            : stripMarkdown(text.split('\n')[0].trim()).slice(0, 100);
-                        if (cleaned && cleaned.length >= 3) {
-                            if (!result.userRequests.firstRequest)
-                                result.userRequests.firstRequest = cleaned;
-                            result.userRequests.allRequests.push(cleaned);
+                    // === 2. User Requests 추출 ===
+                    if (role === 'human' || role === 'user') {
+                        const text = parseUserText(entry);
+                        if (text) {
+                            const planMatch = text.match(/^Implement the following plan:\s*\n+#\s*(.+)/);
+                            const cleaned = planMatch
+                                ? planMatch[1].trim().slice(0, 100)
+                                : stripMarkdown(text.split('\n')[0].trim()).slice(0, 100);
+                            if (cleaned && cleaned.length >= 3) {
+                                if (!result.userRequests.firstRequest)
+                                    result.userRequests.firstRequest = cleaned;
+                                result.userRequests.allRequests.push(cleaned);
+                            }
                         }
                     }
-                }
-                // === 3. Assistant 메시지 수집 (decisions + recentMessages) ===
-                if (role === 'assistant') {
-                    const text = extractTextFromContent(content);
-                    if (text.length > 10) {
-                        // 최근 10개만 유지 (decision 추출용)
-                        result.recentAssistantMessages.push(text);
-                        if (result.recentAssistantMessages.length > 10) {
-                            result.recentAssistantMessages.shift();
+                    // === 3. Assistant 메시지 수집 (decisions + recentMessages) ===
+                    if (role === 'assistant') {
+                        const text = extractTextFromContent(content);
+                        if (text.length > 10) {
+                            // 최근 10개만 유지 (decision 추출용)
+                            result.recentAssistantMessages.push(text);
+                            if (result.recentAssistantMessages.length > 10) {
+                                result.recentAssistantMessages.shift();
+                            }
                         }
                     }
-                }
-                // === 4. Error-Fix pair용 entries 수집 (최근 30개) ===
-                const text = extractTextFromContent(content);
-                if (text.length > 5) {
-                    recentEntries.push({ role, text: text.slice(0, 500) });
-                    if (recentEntries.length > 30)
-                        recentEntries.shift();
-                }
+                    // === 4. Error-Fix pair용 entries 수집 (최근 30개) ===
+                    const text = extractTextFromContent(content);
+                    if (text.length > 5) {
+                        recentEntries.push({ role, text: text.slice(0, 500) });
+                        if (recentEntries.length > 30)
+                            recentEntries.shift();
+                    }
+                } // end for (entry of entries)
             }
             catch { /* skip malformed lines */ }
         }

package/dist/hooks/session-start.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
-import { logHookError, emitContext, isCodexHost } from '../utils/logger.js';
+import { logHookError, emitContext, isCodexHost, isGeminiHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -262,8 +262,9 @@ async function main() {
             emitContext(`\n<session-context project="${project}">\n${context}\n</session-context>\n`, 'SessionStart', input.transcript_path);
         }
         else {
-            // Only Claude gets the "no context" placeholder; Codex would just get empty context.
-            if (!isCodexHost(input.transcript_path)) {
+            // Only Claude gets the plain "no context" placeholder; Codex and Gemini
+            // expect JSON-only stdout, so a stray console.log would corrupt their parsing.
+            if (!isCodexHost(input.transcript_path) && !isGeminiHost(input.transcript_path)) {
                 console.log(`\n[Session] Project: ${project} (no context yet)\n`);
             }
         }

package/dist/utils/logger.d.ts

@@ -37,9 +37,17 @@ export declare function logHookError(hook: string, err: unknown): void;
  */
 export declare function isCodexHost(transcriptPath?: string): boolean;
 /**
- * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * Detect whether the hook is running under Gemini CLI (Google), 2026-07-10.
+ * Same two-signal approach as Codex — Gemini's transcript_path can be null/stubbed
+ * at SessionStart (google-gemini/gemini-cli#14715), so the installer-injected
+ * "--gemini" argv marker is the reliable signal; the ~/.gemini/tmp/.../chats path
+ * is the fallback for later events.
+ */
+export declare function isGeminiHost(transcriptPath?: string): boolean;
+/**
+ * Emit context to stdout in the host's expected format.
  * - Claude Code injects raw stdout text directly.
- * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ * - Codex CLI and Gemini CLI both expect {hookSpecificOutput:{hookEventName, additionalContext}}.
  */
 export declare function emitContext(context: string, hookEventName: string, transcriptPath?: string): void;
 export {};

package/dist/utils/logger.js

@@ -156,12 +156,29 @@ export function isCodexHost(transcriptPath) {
     return transcriptPath.includes('/.codex/sessions/') || /rollout-.*\.jsonl$/.test(transcriptPath);
 }
 /**
- * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * Detect whether the hook is running under Gemini CLI (Google), 2026-07-10.
+ * Same two-signal approach as Codex — Gemini's transcript_path can be null/stubbed
+ * at SessionStart (google-gemini/gemini-cli#14715), so the installer-injected
+ * "--gemini" argv marker is the reliable signal; the ~/.gemini/tmp/.../chats path
+ * is the fallback for later events.
+ */
+export function isGeminiHost(transcriptPath) {
+    if (process.argv.includes('--gemini'))
+        return true;
+    if (!transcriptPath)
+        return false;
+    // Gemini stores chats at ~/.gemini/tmp/<hash>/chats/*.jsonl. Match that specific
+    // path, NOT a bare "/.gemini/" — a Claude session run from a dir containing
+    // ".gemini" would otherwise be misclassified (audit-3 2026-07-10 finding).
+    return transcriptPath.includes('/.gemini/tmp/');
+}
+/**
+ * Emit context to stdout in the host's expected format.
  * - Claude Code injects raw stdout text directly.
- * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ * - Codex CLI and Gemini CLI both expect {hookSpecificOutput:{hookEventName, additionalContext}}.
  */
 export function emitContext(context, hookEventName, transcriptPath) {
-    if (isCodexHost(transcriptPath)) {
+    if (isCodexHost(transcriptPath) || isGeminiHost(transcriptPath)) {
         process.stdout.write(JSON.stringify({
             hookSpecificOutput: { hookEventName, additionalContext: context },
         }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.16.1",
-  "description": "Session Continuity for Claude Code - Never re-explain your project again",
+  "version": "1.17.0",
+  "description": "Session continuity for Claude Code, OpenAI Codex CLI & Google Gemini CLI - never re-explain your project again. 100% local, zero config, auto context injection.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -31,12 +31,19 @@
     "model-context-protocol",
     "claude",
     "claude-code",
+    "codex",
+    "codex-cli",
+    "openai",
+    "gemini",
+    "gemini-cli",
+    "google",
     "ai",
     "context",
     "memory",
     "session",
     "continuity",
-    "anthropic"
+    "anthropic",
+    "agent-memory"
   ],
   "author": "Byeongchang Lee <leesgit@github.com>",
   "license": "MIT",