context-mode 0.9.21 → 1.0.0

package/hooks/gemini-cli/precompress.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI PreCompress hook — snapshot generation.
+ *
+ * Triggered when Gemini CLI is about to compress the conversation.
+ * Reads all captured session events, builds a priority-sorted resume
+ * snapshot (<2KB XML), and stores it for injection after compress.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath, GEMINI_OPTS } from "../session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = GEMINI_OPTS;
+const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "precompress-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  const { buildResumeSnapshot } = await import(join(PKG_SESSION, "snapshot.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PreCompress is advisory — no stdout output needed

package/hooks/gemini-cli/sessionstart.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI SessionStart hook for context-mode
+ *
+ * Session lifecycle management:
+ * - "startup"  → Cleanup old sessions, capture GEMINI.md rules
+ * - "compact"  → Write events file, inject session knowledge directive
+ * - "resume"   → Load previous session events, inject directive
+ * - "clear"    → No action needed
+ */
+
+import { ROUTING_BLOCK } from "../routing-block.mjs";
+import { writeSessionEventsFile, buildSessionDirective, getAllProjectEvents } from "../session-directive.mjs";
+import {
+  readStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  getProjectDir, GEMINI_OPTS,
+} from "../session-helpers.mjs";
+import { join, dirname } from "node:path";
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = GEMINI_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+  const source = input.source ?? "startup";
+
+  if (source === "compact") {
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("compact", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    try { unlinkSync(getCleanupFlagPath(OPTS)); } catch { /* no flag */ }
+
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+
+    const events = getAllProjectEvents(db);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS));
+      additionalContext += buildSessionDirective("resume", eventMeta);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+    const dbPath = getSessionDBPath(OPTS);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS)); } catch { /* no stale file */ }
+
+    const cleanupFlag = getCleanupFlagPath(OPTS);
+    let previousWasFresh = false;
+    try { readFileSync(cleanupFlag); previousWasFresh = true; } catch { /* no flag */ }
+
+    if (previousWasFresh) {
+      db.cleanupOldSessions(0);
+    } else {
+      db.cleanupOldSessions(7);
+    }
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+    writeFileSync(cleanupFlag, new Date().toISOString(), "utf-8");
+
+    const sessionId = getSessionId(input, OPTS);
+    const projectDir = getProjectDir(OPTS);
+    db.ensureSession(sessionId, projectDir);
+    const ruleFilePaths = [
+      join(homedir(), ".gemini", "GEMINI.md"),
+      join(projectDir, "GEMINI.md"),
+    ];
+    for (const p of ruleFilePaths) {
+      try {
+        const content = readFileSync(p, "utf-8");
+        if (content.trim()) {
+          db.insertEvent(sessionId, { type: "rule", category: "rule", data: p, priority: 1 });
+          db.insertEvent(sessionId, { type: "rule_content", category: "rule", data: content, priority: 1 });
+        }
+      } catch { /* file doesn't exist — skip */ }
+    }
+
+    db.close();
+  }
+  // "clear" — no action needed
+} catch (err) {
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { join: pjoin } = await import("node:path");
+    const { homedir: hd } = await import("node:os");
+    appendFileSync(
+      pjoin(hd(), ".gemini", "context-mode", "sessionstart-debug.log"),
+      `[${new Date().toISOString()}] ${err?.message || err}\n${err?.stack || ""}\n`,
+    );
+  } catch { /* ignore logging failure */ }
+}
+
+const output = `SessionStart:compact hook success: Success\nSessionStart hook additional context: \n${additionalContext}`;
+process.stdout.write(output);

package/hooks/hooks.json

@@ -1,6 +1,28 @@
 {
-  "description": "Context-mode PreToolUse — intercepts data-fetching tools, nudges toward sandbox execution",
+  "description": "Context-mode hooks — PreToolUse routing, PostToolUse session capture, PreCompact snapshot, SessionStart context injection",
   "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse.mjs"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs"
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Bash",
@@ -38,6 +60,15 @@
           }
         ]
       },
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse.mjs"
+          }
+        ]
+      },
       {
         "matcher": "Task",
         "hooks": [
@@ -48,7 +79,7 @@
         ]
       },
       {
-        "matcher": "mcp__plugin_context-mode_context-mode__execute",
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_execute",
         "hooks": [
           {
             "type": "command",
@@ -57,7 +88,7 @@
         ]
       },
       {
-        "matcher": "mcp__plugin_context-mode_context-mode__execute_file",
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_execute_file",
         "hooks": [
           {
             "type": "command",
@@ -66,7 +97,7 @@
         ]
       },
       {
-        "matcher": "mcp__plugin_context-mode_context-mode__batch_execute",
+        "matcher": "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
         "hooks": [
           {
             "type": "command",
@@ -75,6 +106,17 @@
         ]
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/userpromptsubmit.mjs"
+          }
+        ]
+      }
+    ],
     "SessionStart": [
       {
         "matcher": "",

package/hooks/posttooluse.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook for context-mode session continuity.
+ *
+ * Captures session events from tool calls (13 categories) and stores
+ * them in the per-project SessionDB for later resume snapshot building.
+ *
+ * Must be fast (<20ms). No network, no LLM, just SQLite writes.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Resolve absolute path for imports — relative dynamic imports can fail
+// when Claude Code invokes hooks from a different working directory.
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "build", "session");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  const { extractEvents } = await import(join(PKG_SESSION, "extract.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath();
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input);
+
+  // Ensure session meta exists
+  db.ensureSession(sessionId, process.env.CLAUDE_PROJECT_DIR || process.cwd());
+
+  // Extract and store events
+  const events = extractEvents({
+    tool_name: input.tool_name,
+    tool_input: input.tool_input ?? {},
+    tool_response: typeof input.tool_response === "string"
+      ? input.tool_response
+      : JSON.stringify(input.tool_response ?? ""),
+    tool_output: input.tool_output,
+  });
+
+  for (const event of events) {
+    db.insertEvent(sessionId, event, "PostToolUse");
+  }
+
+  db.close();
+} catch {
+  // PostToolUse must never block the session — silent fallback
+}
+
+// PostToolUse hooks don't need hookSpecificOutput

package/hooks/precompact.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * PreCompact hook for context-mode session continuity.
+ *
+ * Triggered when Claude Code is about to compact the conversation.
+ * Reads all captured session events, builds a priority-sorted resume
+ * snapshot (<2KB XML), and stores it for injection after compact.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
+import { appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+// Resolve absolute path for imports
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG_SESSION = join(HOOK_DIR, "..", "build", "session");
+const DEBUG_LOG = join(homedir(), ".claude", "context-mode", "precompact-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  const { buildResumeSnapshot } = await import(join(PKG_SESSION, "snapshot.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath();
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input);
+
+  // Get all events for this session
+  const events = db.getEvents(sessionId);
+
+  if (events.length > 0) {
+    const stats = db.getSessionStats(sessionId);
+    const snapshot = buildResumeSnapshot(events, {
+      compactCount: (stats?.compact_count ?? 0) + 1,
+    });
+
+    db.upsertResume(sessionId, snapshot, events.length);
+    db.incrementCompactCount(sessionId);
+  }
+
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err.message}\n`);
+  } catch {
+    // Silent fallback
+  }
+}
+
+// PreCompact doesn't need hookSpecificOutput
+console.log(JSON.stringify({}));