context-mode 0.9.22 → 1.0.1

package/hooks/userpromptsubmit.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook for context-mode session continuity.
+ *
+ * Captures every user prompt so the LLM can continue from the exact
+ * point where the user left off after compact or session restart.
+ *
+ * Must be fast (<10ms). Just a single SQLite write.
+ */
+
+import { readStdin, getSessionId, getSessionDBPath } from "./session-helpers.mjs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+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 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 import(join(PKG_SESSION, "db.js"));
+    const { extractUserEvents } = await import(join(PKG_SESSION, "extract.js"));
+    const dbPath = getSessionDBPath();
+    const db = new SessionDB({ dbPath });
+    const sessionId = getSessionId(input);
+
+    db.ensureSession(sessionId, process.env.CLAUDE_PROJECT_DIR || process.cwd());
+
+    // 1. Always save the raw prompt
+    db.insertEvent(sessionId, {
+      type: "user_prompt",
+      category: "prompt",
+      data: prompt,
+      priority: 1,
+    }, "UserPromptSubmit");
+
+    // 2. Extract decision/role/intent/data from user message
+    const userEvents = extractUserEvents(trimmed);
+    for (const ev of userEvents) {
+      db.insertEvent(sessionId, ev, "UserPromptSubmit");
+    }
+
+    db.close();
+  }
+} catch {
+  // UserPromptSubmit must never block the session — silent fallback
+}

package/hooks/vscode-copilot/posttooluse.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PostToolUse hook — session event capture.
+ *
+ * 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, getProjectDir, VSCODE_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 = VSCODE_OPTS;
+const DEBUG_LOG = join(homedir(), ".vscode", "context-mode", "posttooluse-debug.log");
+
+try {
+  const raw = await readStdin();
+  const input = JSON.parse(raw);
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] CALL: ${input.tool_name}\n`);
+
+  const { extractEvents } = await import(join(PKG_SESSION, "extract.js"));
+  const { SessionDB } = await import(join(PKG_SESSION, "db.js"));
+
+  const dbPath = getSessionDBPath(OPTS);
+  const db = new SessionDB({ dbPath });
+  const sessionId = getSessionId(input, OPTS);
+
+  db.ensureSession(sessionId, getProjectDir(OPTS));
+
+  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");
+  }
+
+  appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] OK: ${input.tool_name} → ${events.length} events\n`);
+  db.close();
+} catch (err) {
+  try {
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ERR: ${err?.message || err}\n`);
+  } catch { /* silent */ }
+}
+
+// PostToolUse — no stdout output

package/hooks/vscode-copilot/precompact.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PreCompact hook — snapshot generation.
+ *
+ * Triggered when VS Code Copilot 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, VSCODE_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 = VSCODE_OPTS;
+const DEBUG_LOG = join(homedir(), ".vscode", "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(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 */ }
+}
+
+// PreCompact — no stdout output needed

package/hooks/vscode-copilot/pretooluse.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot PreToolUse 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";
+
+const __hookDir = dirname(fileURLToPath(import.meta.url));
+await initSecurity(resolve(__hookDir, "..", "..", "build"));
+
+const raw = await readStdin();
+const input = JSON.parse(raw);
+const tool = input.tool_name ?? "";
+const toolInput = input.tool_input ?? {};
+
+const decision = routePreToolUse(tool, toolInput, process.env.VSCODE_CWD || process.env.CLAUDE_PROJECT_DIR);
+const response = formatDecision("vscode-copilot", decision);
+if (response !== null) {
+  process.stdout.write(JSON.stringify(response) + "\n");
+}

package/hooks/vscode-copilot/sessionstart.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * VS Code Copilot SessionStart hook for context-mode
+ *
+ * Session lifecycle management:
+ * - "startup"  → Cleanup old sessions, capture instruction file 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, VSCODE_OPTS,
+} from "../session-helpers.mjs";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+
+const HOOK_DIR = new URL(".", import.meta.url).pathname;
+const PKG_SESSION = join(HOOK_DIR, "..", "..", "build", "session");
+const OPTS = VSCODE_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(projectDir, ".github", "copilot-instructions.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(), ".vscode", "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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "context-mode",
-  "version": "0.9.22",
+  "version": "1.0.1",
   "type": "module",
-  "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
+  "description": "MCP plugin that saves 98% of your context window. Works with Claude Code, Gemini CLI, VS Code Copilot, OpenCode, and Codex CLI. Sandboxed code execution, FTS5 knowledge base, and intent-driven search.",
   "author": "Mert Koseoğlu",
   "license": "Elastic-2.0",
   "keywords": [
@@ -10,6 +10,10 @@
     "model-context-protocol",
     "claude",
     "claude-code",
+    "gemini-cli",
+    "vscode-copilot",
+    "opencode",
+    "codex-cli",
     "context-window",
     "sandbox",
     "code-execution",
@@ -18,16 +22,22 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/mksglu/claude-context-mode"
+    "url": "https://github.com/mksglu/context-mode"
+  },
+  "homepage": "https://github.com/mksglu/context-mode#readme",
+  "bugs": "https://github.com/mksglu/context-mode/issues",
+  "main": "./build/cli.js",
+  "exports": {
+    ".": "./build/cli.js",
+    "./plugin": "./build/opencode-plugin.js"
   },
-  "homepage": "https://github.com/mksglu/claude-context-mode#readme",
-  "bugs": "https://github.com/mksglu/claude-context-mode/issues",
   "bin": {
     "context-mode": "./build/cli.js"
   },
   "files": [
     "build",
     "hooks",
+    "configs",
     "server.bundle.mjs",
     "skills",
     ".claude-plugin",
@@ -44,20 +54,12 @@
     "setup": "npx tsx src/cli.ts setup",
     "doctor": "npx tsx src/cli.ts doctor",
     "typecheck": "tsc --noEmit",
-    "test": "npx tsx tests/executor.test.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "benchmark": "npx tsx tests/benchmark.ts",
     "test:use-cases": "npx tsx tests/use-cases.ts",
     "test:compare": "npx tsx tests/context-comparison.ts",
-    "test:ecosystem": "npx tsx tests/ecosystem-benchmark.ts",
-    "test:store": "npx tsx tests/store.test.ts",
-    "test:fuzzy": "npx tsx tests/fuzzy-search.test.ts",
-    "test:hooks": "npx tsx tests/hook-integration.test.ts",
-    "test:project-dir": "npx tsx tests/project-dir.test.ts",
-    "test:stream-cap": "npx tsx tests/stream-cap.test.ts",
-    "test:search-wiring": "npx tsx tests/search-wiring.test.ts",
-    "test:search-fallback": "npx tsx tests/search-fallback-integration.test.ts",
-    "test:turndown": "npx tsx tests/turndown.test.ts",
-    "test:all": "for f in tests/*.test.ts; do npx tsx \"$f\" || exit 1; done"
+    "test:ecosystem": "npx tsx tests/ecosystem-benchmark.ts"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.1",
@@ -75,6 +77,7 @@
     "@types/turndown": "^5.0.5",
     "esbuild": "^0.27.3",
     "tsx": "^4.21.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
   }
 }