@mxalbert/context-mode 2.0.0

package/hooks/posttooluse.mjs

@@ -0,0 +1,225 @@
+#!/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.
+ *
+ * Crash-resilience: wrapped via runHook (#414).
+ */
+
+import { runHook } from "./run-hook.mjs";
+
+await runHook(async () => {
+  const {
+    readStdin,
+    parseStdin,
+    getSessionId,
+    getSessionDBPath,
+    getInputProjectDir,
+  } = await import("./session-helpers.mjs");
+  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
+  const { dirname, resolve, basename } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const { readFileSync, unlinkSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+
+  // 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 { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+
+  try {
+    const raw = await readStdin();
+    const input = parseStdin(raw);
+    const projectDir = getInputProjectDir(input);
+
+    const { extractEvents } = await loadExtract();
+    const { resolveProjectAttributions } = await loadProjectAttribution();
+    const { SessionDB } = await loadSessionDB();
+
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input);
+
+    // Ensure session meta exists
+    db.ensureSession(sessionId, projectDir);
+
+    // 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,
+    });
+
+    attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
+
+    // ─── Category 18: Rejected-approach — read PreToolUse marker ───
+    try {
+      const rejectedPath = resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`);
+      let rejectedData;
+      try {
+        rejectedData = readFileSync(rejectedPath, "utf-8").trim();
+        unlinkSync(rejectedPath);
+      } catch { /* no marker */ }
+      if (rejectedData) {
+        const colonIdx = rejectedData.indexOf(":");
+        const rejTool = colonIdx > 0 ? rejectedData.slice(0, colonIdx) : rejectedData;
+        const rejReason = colonIdx > 0 ? rejectedData.slice(colonIdx + 1) : "denied";
+        // v1.0.160: route through attributeAndInsertEvents so the bridge wire
+        // receives this event too. db.insertEvent only writes locally — the
+        // dashboard's rejection-rate widget needs the platform row.
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          [{
+            type: "rejected",
+            category: "rejected-approach",
+            data: `${rejTool}: ${rejReason}`,
+            priority: 2,
+          }],
+          input,
+          projectDir,
+          "PreToolUse",
+          resolveProjectAttributions,
+        );
+      }
+    } catch { /* best-effort */ }
+
+    // ─── D2 PRD Phase 3/4: redirect marker — emit byte-accounting event ───
+    // PreToolUse wrote `context-mode-redirect-${sessionId}.txt` for tools whose
+    // output we kept out of the model's context window (curl/wget, WebFetch,
+    // large Read). Format: `tool:type:bytesAvoided:commandSummary` (Override C).
+    try {
+      const redirectPath = resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`);
+      let redirectData;
+      try {
+        redirectData = readFileSync(redirectPath, "utf-8").trim();
+        // Slice 3.3: unlink so the next PostToolUse for an unrelated tool call
+        // does NOT re-emit the same event (no double-accounting).
+        unlinkSync(redirectPath);
+      } catch { /* no marker — Slice 3.4: phantom-event guard */ }
+
+      if (redirectData) {
+        // Parse first 3 colons; the rest (commandSummary) may itself contain
+        // colons (URLs do — `https://`). Avoid `split(":", 4)` which would
+        // truncate the summary at any embedded colon.
+        const i1 = redirectData.indexOf(":");
+        const i2 = i1 >= 0 ? redirectData.indexOf(":", i1 + 1) : -1;
+        const i3 = i2 >= 0 ? redirectData.indexOf(":", i2 + 1) : -1;
+        if (i1 > 0 && i2 > i1 && i3 > i2) {
+          const tool = redirectData.slice(0, i1);
+          const type = redirectData.slice(i1 + 1, i2);
+          const bytesRaw = redirectData.slice(i2 + 1, i3);
+          const summary = redirectData.slice(i3 + 1);
+          const bytesAvoided = Number.parseInt(bytesRaw, 10);
+          if (Number.isFinite(bytesAvoided) && bytesAvoided > 0) {
+            // v1.0.160: route through wire — context-saving (byte-accounting)
+            // widget on the platform reads category='redirect' rows. event
+            // carries bytes_avoided so the bytesList branch in
+            // attributeAndInsertEvents stamps the column.
+            attributeAndInsertEvents(
+              db,
+              sessionId,
+              [{
+                type,
+                category: "redirect",
+                data: `${tool}: ${summary}`,
+                priority: 2,
+                bytes_avoided: bytesAvoided,
+              }],
+              input,
+              projectDir,
+              "PreToolUse",
+              resolveProjectAttributions,
+            );
+          }
+        }
+      }
+    } catch { /* best-effort — never block hook */ }
+
+    // ─── Category 27: Latency — read cross-hook marker and emit event if slow ───
+    try {
+      const toolName = input.tool_name ?? "";
+      if (toolName) {
+        const markerPath = resolve(tmpdir(), `context-mode-latency-${sessionId}-${toolName}.txt`);
+        let startTime;
+        try {
+          startTime = parseInt(readFileSync(markerPath, "utf-8").trim(), 10);
+          unlinkSync(markerPath);
+        } catch {
+          // No marker — pretooluse didn't write one or already consumed
+        }
+        if (startTime && !isNaN(startTime)) {
+          const duration = Date.now() - startTime;
+          if (duration > 5000) {
+            // v1.0.160: route through wire — slow-tool insights need this row.
+            attributeAndInsertEvents(
+              db,
+              sessionId,
+              [{
+                type: "tool_latency",
+                category: "latency",
+                data: `${toolName}: ${duration}ms`,
+                priority: 3,
+              }],
+              input,
+              projectDir,
+              "PostToolUse",
+              resolveProjectAttributions,
+            );
+          }
+        }
+      }
+    } catch { /* latency tracking is best-effort */ }
+
+    // ─── Retrieval bridge: emit the "With context-mode" (bytes_retrieved) row ───
+    // The MCP server appended ctx_search / ctx_fetch_and_index response bytes to
+    // a marker keyed by the session DB basename (the hook NEVER fires for the
+    // plugin's own MCP tools, so this is the only place that signal can enter
+    // the forward stream). Consume + emit one forwardable event so the platform
+    // kept_out_pct goes "measured". Mirrors the redirect-marker handshake above.
+    try {
+      const marker = resolve(tmpdir(), `context-mode-retrieval-${basename(dbPath)}.txt`);
+      let retrievedBytes = 0;
+      try {
+        const raw = readFileSync(marker, "utf-8");
+        for (const line of raw.split("\n")) {
+          const n = parseInt(line, 10);
+          if (Number.isFinite(n) && n > 0) retrievedBytes += n;
+        }
+        unlinkSync(marker); // consume-once — next fire cannot re-forward
+      } catch { /* no marker — phantom-event guard */ }
+      if (retrievedBytes > 0) {
+        // session-loaders stamps bytes_retrieved onto the platform payload from
+        // this in-memory field (session_events has no such column — forward-only).
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          [{
+            type: "mcp_tool_call",
+            category: "retrieval",
+            data: `retrieval: ${retrievedBytes} bytes accessed`,
+            priority: 2,
+            bytes_retrieved: retrievedBytes,
+          }],
+          input,
+          projectDir,
+          "PostToolUse",
+          resolveProjectAttributions,
+        );
+      }
+    } catch { /* best-effort — never block the hook */ }
+
+    db.close();
+  } catch {
+    // PostToolUse must never block the session — silent fallback
+  }
+
+  // PostToolUse hooks don't need hookSpecificOutput
+});

package/hooks/precompact.mjs

@@ -0,0 +1,100 @@
+#!/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.
+ *
+ * Crash-resilience: wrapped via runHook (#414).
+ */
+
+import { runHook } from "./run-hook.mjs";
+
+await runHook(async () => {
+  const {
+    readStdin,
+    parseStdin,
+    getSessionId,
+    getSessionDBPath,
+    getInputProjectDir,
+    resolveConfigDir,
+  } = await import("./session-helpers.mjs");
+  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
+  const { appendFileSync } = await import("node:fs");
+  const { join, dirname } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+
+  // Resolve absolute path for imports
+  const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
+  const { loadSessionDB, loadSnapshot, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
+  const DEBUG_LOG = join(resolveConfigDir(), "context-mode", "precompact-debug.log");
+
+  try {
+    const raw = await readStdin();
+    const input = parseStdin(raw);
+
+    const { buildResumeSnapshot } = await loadSnapshot();
+    const { SessionDB } = await loadSessionDB();
+
+    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);
+
+      // v1.0.160: route compaction lifecycle events through wire so
+      // dashboard's compact widget gets per-compaction rows (the engine
+      // joins on category='compaction' to compute snapshot insights).
+      try {
+        const fileEvents = events.filter(e => e.category === "file");
+        const projectDirCompact = getInputProjectDir(input);
+        const { resolveProjectAttributions } = await loadProjectAttribution();
+        attributeAndInsertEvents(
+          db,
+          sessionId,
+          [
+            {
+              type: "compaction_summary",
+              category: "compaction",
+              data: `Session compacted. ${events.length} events, ${fileEvents.length} files touched.`,
+              priority: 1,
+            },
+            {
+              type: "snapshot-built",
+              category: "compaction",
+              data: `Snapshot built. ${snapshot.length} bytes for ${events.length} events.`,
+              priority: 1,
+              bytes_avoided: snapshot.length,
+            },
+          ],
+          input,
+          projectDirCompact,
+          "PreCompact",
+          resolveProjectAttributions,
+        );
+      } catch { /* best-effort — never block PreCompact */ }
+    }
+
+    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({}));
+});

package/hooks/pretooluse.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * Unified PreToolUse hook for context-mode (Claude Code)
+ * Redirects data-fetching tools to context-mode MCP tools
+ *
+ * Cross-platform (Windows/macOS/Linux) — no bash/jq dependency.
+ *
+ * Routing is delegated to core/routing.mjs (shared across platforms).
+ * This file retains the Claude Code-specific self-heal block and
+ * uses core/formatters.mjs for Claude Code output format.
+ *
+ * Crash-resilience: wrapped via runHook (#414) — module loads happen
+ * dynamically inside the wrapper.
+ *
+ * #415: the destructive settings.json mutation block (which removed
+ * context-mode hook entries when hooks.json was present) was deleted.
+ * It deleted user-written hook configs without consent and was the
+ * documented cause of the regression.
+ */
+
+import { runHook } from "./run-hook.mjs";
+
+await runHook(async () => {
+  const { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, readdirSync } = await import("node:fs");
+  const { resolve, dirname, basename } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const { tmpdir } = await import("node:os");
+  const { readStdin } = await import("./core/stdin.mjs");
+  const { routePreToolUse, initSecurity } = await import("./core/routing.mjs");
+  const { formatDecision } = await import("./core/formatters.mjs");
+  const { parseStdin, getInputProjectDir, getSessionId, resolveConfigDir } = await import("./session-helpers.mjs");
+
+  // ─── Manual recursive copy (avoids cpSync libuv crash on non-ASCII paths, Windows + Node 24) ───
+  function copyDirSync(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src, { withFileTypes: true })) {
+      const srcPath = resolve(src, entry.name);
+      const destPath = resolve(dest, entry.name);
+      if (entry.isDirectory()) copyDirSync(srcPath, destPath);
+      else copyFileSync(srcPath, destPath);
+    }
+  }
+
+  // ─── Self-heal: rename dir to correct version, fix registry + hooks ───
+  try {
+    const hookDir = dirname(fileURLToPath(import.meta.url));
+    const myRoot = resolve(hookDir, "..");
+    const myPkg = JSON.parse(readFileSync(resolve(myRoot, "package.json"), "utf-8"));
+    const myVersion = myPkg.version ?? "unknown";
+    const myDirName = basename(myRoot);
+    const cacheParent = dirname(myRoot);
+    const marker = resolve(tmpdir(), `context-mode-healed-${myVersion}`);
+
+    // Only self-heal inside plugin cache dirs — skip in dev/CI environments
+    const isInPluginCache = myRoot.includes("/plugins/cache/") || myRoot.includes("\\plugins\\cache\\");
+    if (myVersion !== "unknown" && isInPluginCache && !existsSync(marker)) {
+      // 1. If dir name doesn't match version (e.g. "0.7.0" but code is "0.9.12"),
+      //    create correct dir, copy files, update registry + hooks
+      const correctDir = resolve(cacheParent, myVersion);
+      if (myDirName !== myVersion && !existsSync(correctDir)) {
+        copyDirSync(myRoot, correctDir);
+
+        // Create start.mjs in new dir if missing
+        const startMjs = resolve(correctDir, "start.mjs");
+        if (!existsSync(startMjs)) {
+          writeFileSync(startMjs, [
+            '#!/usr/bin/env node',
+            'import { existsSync } from "node:fs";',
+            'import { dirname, resolve } from "node:path";',
+            'import { fileURLToPath } from "node:url";',
+            'const __dirname = dirname(fileURLToPath(import.meta.url));',
+            'process.chdir(__dirname);',
+            'if (!process.env.CLAUDE_PROJECT_DIR) process.env.CLAUDE_PROJECT_DIR = process.cwd();',
+            'if (existsSync(resolve(__dirname, "server.bundle.mjs"))) {',
+            '  await import("./server.bundle.mjs");',
+            '} else if (existsSync(resolve(__dirname, "build", "server.js"))) {',
+            '  await import("./build/server.js");',
+            '}',
+          ].join("\n"), "utf-8");
+        }
+      }
+
+      const targetDir = existsSync(correctDir) ? correctDir : myRoot;
+
+      // 2. Update installed_plugins.json → point to correct version dir
+      //    Skip if not present (e.g. CI / non-Claude-Code environments)
+      const ipPath = resolve(resolveConfigDir(), "plugins", "installed_plugins.json");
+      if (existsSync(ipPath)) {
+        const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
+        for (const [key, entries] of Object.entries(ip.plugins || {})) {
+          if (!key.toLowerCase().includes("context-mode")) continue;
+          for (const entry of entries) {
+            entry.installPath = targetDir;
+            entry.version = myVersion;
+            entry.lastUpdated = new Date().toISOString();
+          }
+        }
+        writeFileSync(ipPath, JSON.stringify(ip, null, 2) + "\n", "utf-8");
+      }
+
+      // 3. Legacy: hooks.json absent — rewrite stale paths in settings.json to current version dir.
+      //    The previous "if hooks.json present, delete settings.json entries" block was REMOVED (#415):
+      //    it destroyed user-written hook configs without consent. Plugin-system + settings.json
+      //    coexistence is now Claude Code's responsibility, not ours.
+      const settingsPath = resolve(resolveConfigDir(), "settings.json");
+      try {
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const allHooks = settings.hooks || {};
+        let changed = false;
+
+        const hooksJsonPath = resolve(myRoot, "hooks", "hooks.json");
+        if (!existsSync(hooksJsonPath)) {
+          // Legacy: hooks.json absent — rewrite stale paths to current version dir.
+          for (const hookType of Object.keys(allHooks)) {
+            const entries = allHooks[hookType];
+            if (!Array.isArray(entries)) continue;
+
+            for (const entry of entries) {
+              // Fix deprecated Task-only matcher (PreToolUse only)
+              if (hookType === "PreToolUse" && entry.matcher?.includes("Task") && !entry.matcher.includes("Agent")) {
+                entry.matcher = entry.matcher.replace("Task", "Agent|Task");
+                changed = true;
+              }
+              // Rewrite stale context-mode hook paths to point to current version
+              for (const h of (entry.hooks || [])) {
+                if (h.command && h.command.includes(".mjs") && h.command.includes("context-mode") && !h.command.includes(targetDir)) {
+                  // Extract the script filename (e.g., sessionstart.mjs, pretooluse.mjs)
+                  const scriptMatch = h.command.match(/([a-z]+\.mjs)\s*"?\s*$/);
+                  if (scriptMatch) {
+                    // Issue #636: quote the script path so spaces in targetDir
+                    // (e.g. Dropbox/iCloud display names like "Lucas Werneck",
+                    // or CLAUDE_CONFIG_DIR pointed at a synced spaced folder)
+                    // don't break /bin/sh's word-splitting at hook-spawn time.
+                    // JSON.stringify is sufficient on Unix and safe on Windows
+                    // (backslashes get escaped — Claude Code's hook layer
+                    //  normalizes to POSIX on Windows anyway via toHookPath).
+                    const scriptPath = resolve(targetDir, "hooks", scriptMatch[1]);
+                    h.command = `node ${JSON.stringify(scriptPath)}`;
+                    changed = true;
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        if (changed) writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+      } catch { /* skip settings update */ }
+
+      // Old version dirs are cleaned lazily by sessionstart.mjs (age-gated >1h)
+      // to avoid breaking active sessions that still reference them (#181).
+
+      writeFileSync(marker, Date.now().toString(), "utf-8");
+    }
+  } catch { /* best effort — don't block hook */ }
+
+  // ─── Init security from compiled build ───
+  const __hookDir = dirname(fileURLToPath(import.meta.url));
+  await initSecurity(resolve(__hookDir, "..", "build"));
+
+  // ─── Read stdin ───
+  const raw = await readStdin();
+  const input = parseStdin(raw);
+  const tool = input.tool_name ?? "";
+  const toolInput = input.tool_input ?? {};
+  const projectDir = getInputProjectDir(input);
+  const isSubagentContext = input.agent_id != null || input.agent_type != null;
+
+  // ─── Route and format response ───
+  const decision = routePreToolUse(tool, toolInput, projectDir, "claude-code", getSessionId(input), {
+    mcpToolsAvailable: !isSubagentContext,
+  });
+  const response = formatDecision("claude-code", decision);
+
+  // ─── Write latency marker for cross-hook timing (Category 27) ───
+  // Marker writes MUST happen before stdout write — stdout is the last action
+  // so the process can exit immediately after, avoiding CI test timeouts.
+  try {
+    const sessionId = getSessionId(input);
+    if (tool) {
+      const markerPath = resolve(tmpdir(), `context-mode-latency-${sessionId}-${tool}.txt`);
+      writeFileSync(markerPath, String(Date.now()), "utf-8");
+    }
+  } catch { /* latency tracking is best-effort — never block hook */ }
+
+  // ─── Write rejected-approach marker for PostToolUse to pick up ───
+  // PreToolUse cannot safely load SessionDB (native module loading breaks hook stdout).
+  // Write a marker file instead; PostToolUse reads it and writes the event.
+  if (decision && (decision.action === "deny" || decision.action === "modify")) {
+    try {
+      const sessionId = getSessionId(input);
+      const reason = decision.action === "deny"
+        ? (decision.reason || "denied")
+        : "Redirected to context-mode sandbox";
+      const markerPath = resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`);
+      writeFileSync(markerPath, `${tool}:${reason}`, "utf-8");
+    } catch { /* best-effort — never block hook */ }
+  }
+
+  // ─── D2 PRD Phase 3/4: redirect marker for byte-accounting events ───
+  // routing.mjs attaches `redirectMeta` to decisions for tools whose output we
+  // kept out of the model's context window (curl/wget, WebFetch, large Read).
+  // PostToolUse reads this marker to emit a `category=redirect` event with the
+  // estimated `bytes_avoided`. PreToolUse cannot load SessionDB safely (native
+  // module load breaks hook stdout), hence the marker indirection.
+  if (decision && decision.redirectMeta) {
+    try {
+      const sessionId = getSessionId(input);
+      const meta = decision.redirectMeta;
+      const summary = String(meta.commandSummary ?? "").slice(0, 200);
+      const markerPath = resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`);
+      // Format: tool:type:bytesAvoided:commandSummary (matches Override C).
+      // commandSummary may legitimately contain `:` (URLs) — don't quote it,
+      // PostToolUse parses only the first 3 colons and treats the rest as data.
+      writeFileSync(
+        markerPath,
+        `${meta.tool}:${meta.type}:${meta.bytesAvoided}:${summary}`,
+        "utf-8",
+      );
+    } catch { /* best-effort — never block hook */ }
+  }
+
+  // ─── stdout write is the LAST action — process exits immediately after ───
+  if (response !== null) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+});

package/hooks/qwen-code/platform.mjs

@@ -0,0 +1 @@
+process.env.CONTEXT_MODE_PLATFORM = "qwen-code";