@mxalbert/context-mode 2.0.0

package/hooks/gemini-cli/beforeagent.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * Gemini CLI BeforeAgent hook — UserPromptSubmit equivalent.
+ *
+ * Captures every user prompt so the LLM can resume from the exact point
+ * the user left off after compact / resume. Mirrors hooks/userpromptsubmit.mjs
+ * but reads `input.prompt` (Gemini wire shape, types.ts:547-549) and emits
+ * `hookSpecificOutput.hookEventName: "BeforeAgent"` (types.ts:554-559) so
+ * Gemini's hookRunner appends additionalContext to the prompt
+ * (hookRunner.ts:183-197).
+ *
+ * Must be fast (<10ms). Single SQLite write.
+ */
+
+import {
+  readStdin,
+  parseStdin,
+  getSessionId,
+  getSessionDBPath,
+  getInputProjectDir,
+  GEMINI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const prompt = input.prompt ?? input.message ?? "";
+  const trimmed = (prompt || "").trim();
+
+  // Skip system-generated messages — only capture genuine user prompts.
+  const isSystemMessage = trimmed.startsWith("<task-notification>")
+    || trimmed.startsWith("<system-reminder>")
+    || trimmed.startsWith("<context_guidance>")
+    || trimmed.startsWith("<tool-result>");
+
+  if (trimmed.length > 0 && !isSystemMessage) {
+    const { SessionDB } = await loadSessionDB();
+    const { extractUserEvents } = await loadExtract();
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+
+    db.ensureSession(sessionId, projectDir);
+
+    // 1. Always save the raw prompt.
+    const promptEvent = {
+      type: "user_prompt",
+      category: "user-prompt",
+      data: prompt,
+      priority: 1,
+    };
+    const promptAttributions = attributeAndInsertEvents(
+      db, sessionId, [promptEvent], input, projectDir, "BeforeAgent", resolveProjectAttributions,
+    );
+
+    // 2. Extract decision/role/intent/data from user message.
+    const userEvents = extractUserEvents(trimmed);
+    const savedLastKnown = promptAttributions[0]?.projectDir || null;
+    const sessionStats = db.getSessionStats(sessionId);
+    const lastKnownProjectDir = typeof db.getLatestAttributedProjectDir === "function"
+      ? db.getLatestAttributedProjectDir(sessionId)
+      : null;
+    const userAttributions = resolveProjectAttributions(userEvents, {
+      sessionOriginDir: sessionStats?.project_dir || projectDir,
+      inputProjectDir: projectDir,
+      workspaceRoots: Array.isArray(input.workspace_roots) ? input.workspace_roots : [],
+      lastKnownProjectDir: savedLastKnown || lastKnownProjectDir,
+    });
+    for (let i = 0; i < userEvents.length; i++) {
+      db.insertEvent(sessionId, userEvents[i], "BeforeAgent", userAttributions[i]);
+    }
+
+    db.close();
+  }
+} catch {
+  // BeforeAgent must never block the session — silent fallback.
+}
+
+// Emit empty additionalContext so Gemini's hookRunner treats the response as
+// metadata (no prompt mutation). Matches the SessionStart hook's structured-
+// output convention (sessionstart.mjs:130-135).
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "BeforeAgent",
+    additionalContext: "",
+  },
+}));

package/hooks/gemini-cli/beforetool.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+/**
+ * Gemini CLI BeforeTool hook for context-mode
+ * Thin wrapper — uses shared routing core, no self-heal, no Claude Code-specific logic.
+ */
+
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStdin } from "../core/stdin.mjs";
+import { routePreToolUse, initSecurity } from "../core/routing.mjs";
+import { formatDecision } from "../core/formatters.mjs";
+import { parseStdin, getSessionId, GEMINI_OPTS } from "../session-helpers.mjs";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = parseStdin(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+
+const decision = routePreToolUse(tool, toolInput, process.env.GEMINI_PROJECT_DIR || process.env.CLAUDE_PROJECT_DIR, "gemini-cli", getSessionId(input, GEMINI_OPTS));
+const response = formatDecision("gemini-cli", decision);
+if (response !== null) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}

package/hooks/gemini-cli/precompress.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * 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, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir, GEMINI_OPTS } from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.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 { loadSessionDB, loadSnapshot } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+const DEBUG_LOG = join(homedir(), ".gemini", "context-mode", "precompress-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  const { buildResumeSnapshot } = await loadSnapshot();
+  const { SessionDB } = await loadSessionDB();
+
+  const dbPath = getSessionDBPath(OPTS, projectDir);
+  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,137 @@
+#!/usr/bin/env node
+import "../suppress-stderr.mjs";
+import "../ensure-deps.mjs";
+/**
+ * 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 { createRoutingBlock } from "../routing-block.mjs";
+import { createToolNamer } from "../core/tool-naming.mjs";
+
+const toolNamer = createToolNamer("gemini-cli");
+const ROUTING_BLOCK = createRoutingBlock(toolNamer);
+import { writeSessionEventsFile, buildSessionDirective, getSessionEvents } from "../session-directive.mjs";
+import {
+  readStdin, parseStdin, getSessionId, getSessionDBPath, getSessionEventsPath, getCleanupFlagPath,
+  getInputProjectDir, GEMINI_OPTS,
+} from "../session-helpers.mjs";
+import { createSessionLoaders } from "../session-loaders.mjs";
+import { join, dirname } from "node:path";
+import { readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+const { loadSessionDB } = createSessionLoaders(HOOK_DIR);
+const OPTS = GEMINI_OPTS;
+
+let additionalContext = ROUTING_BLOCK;
+
+try {
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const source = input.source ?? "startup";
+  const projectDir = getInputProjectDir(input, OPTS);
+
+  if (source === "compact") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input, OPTS);
+    const resume = db.getResume(sessionId);
+
+    if (resume && !resume.consumed) {
+      db.markResumeConsumed(sessionId);
+    }
+
+    const events = getSessionEvents(db, sessionId);
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective("compact", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "resume") {
+    try { unlinkSync(getCleanupFlagPath(OPTS, projectDir)); } catch { /* no flag */ }
+
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+
+    // Filter events to the session being resumed. Falling back to
+    // getLatestSessionEvents(db) leaks events from any other session whose
+    // session_meta.started_at is more recent — observed cross-session bleed
+    // when a different session started after this one and before the resume.
+    const sessionId = getSessionId(input, OPTS);
+    const events = sessionId ? getSessionEvents(db, sessionId) : [];
+    if (events.length > 0) {
+      const eventMeta = writeSessionEventsFile(events, getSessionEventsPath(OPTS, projectDir));
+      additionalContext += buildSessionDirective("resume", eventMeta, toolNamer);
+    }
+
+    db.close();
+  } else if (source === "startup") {
+    const { SessionDB } = await loadSessionDB();
+    const dbPath = getSessionDBPath(OPTS, projectDir);
+    const db = new SessionDB({ dbPath });
+    try { unlinkSync(getSessionEventsPath(OPTS, projectDir)); } catch { /* no stale file */ }
+
+    db.cleanupOldSessions(7);
+    db.db.exec(`DELETE FROM session_events WHERE session_id NOT IN (SELECT session_id FROM session_meta)`);
+
+    const sessionId = getSessionId(input, OPTS);
+    db.ensureSession(sessionId, projectDir);
+
+    // NOTE (#558): excised the old GEMINI.md auto-write block. It loaded an
+    // adapter from build/ (gitignored, missing on marketplace installs) and
+    // called a method that was deleted from every adapter in commit 6dae20c.
+    // Both layers were silently no-op'd by the surrounding try/catch on every
+    // install path for many releases. If routing-instruction auto-write is
+    // reintroduced it must come with its own PRD, method spec, and format
+    // tests — out of scope for the security regression fix.
+
+    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 */ }
+}
+
+// Emit structured JSON rather than plain text so Gemini CLI treats the
+// routing block as hook metadata instead of user-visible output (#299).
+// Matches the format already used by Claude Code and VS Code Copilot
+// SessionStart hooks.
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "SessionStart",
+    additionalContext,
+  },
+}));