@contextstream/mcp-server 0.4.49 → 0.4.51

package/dist/hooks/runner.js

@@ -0,0 +1,2889 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/hooks/pre-tool-use.ts
+var pre_tool_use_exports = {};
+__export(pre_tool_use_exports, {
+  runPreToolUseHook: () => runPreToolUseHook
+});
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+function isDiscoveryGlob(pattern) {
+  const patternLower = pattern.toLowerCase();
+  for (const p of DISCOVERY_PATTERNS) {
+    if (patternLower.includes(p)) {
+      return true;
+    }
+  }
+  if (patternLower.startsWith("**/*.") || patternLower.startsWith("**/")) {
+    return true;
+  }
+  if (patternLower.includes("**") || patternLower.includes("*/")) {
+    return true;
+  }
+  return false;
+}
+function isDiscoveryGrep(filePath) {
+  if (!filePath || filePath === "." || filePath === "./" || filePath === "*" || filePath === "**") {
+    return true;
+  }
+  if (filePath.includes("*") || filePath.includes("**")) {
+    return true;
+  }
+  return false;
+}
+function isProjectIndexed(cwd) {
+  if (!fs.existsSync(INDEX_STATUS_FILE)) {
+    return { isIndexed: false, isStale: false };
+  }
+  let data;
+  try {
+    const content = fs.readFileSync(INDEX_STATUS_FILE, "utf-8");
+    data = JSON.parse(content);
+  } catch {
+    return { isIndexed: false, isStale: false };
+  }
+  const projects = data.projects || {};
+  const cwdPath = path.resolve(cwd);
+  for (const [projectPath, info] of Object.entries(projects)) {
+    try {
+      const indexedPath = path.resolve(projectPath);
+      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path.sep)) {
+        const indexedAt = info.indexed_at;
+        if (indexedAt) {
+          try {
+            const indexedTime = new Date(indexedAt);
+            const now = /* @__PURE__ */ new Date();
+            const diffDays = (now.getTime() - indexedTime.getTime()) / (1e3 * 60 * 60 * 24);
+            if (diffDays > STALE_THRESHOLD_DAYS) {
+              return { isIndexed: true, isStale: true };
+            }
+          } catch {
+          }
+        }
+        return { isIndexed: true, isStale: false };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { isIndexed: false, isStale: false };
+}
+function extractCwd(input) {
+  if (input.cwd) return input.cwd;
+  if (input.workspace_roots?.length) return input.workspace_roots[0];
+  if (input.workspaceRoots?.length) return input.workspaceRoots[0];
+  return process.cwd();
+}
+function extractToolName(input) {
+  return input.tool_name || input.toolName || "";
+}
+function extractToolInput(input) {
+  return input.tool_input || input.parameters || input.toolParameters || {};
+}
+function blockClaudeCode(message) {
+  console.error(message);
+  process.exit(2);
+}
+function outputClineBlock(errorMessage, contextMod) {
+  const result = {
+    cancel: true,
+    errorMessage
+  };
+  if (contextMod) {
+    result.contextModification = contextMod;
+  }
+  console.log(JSON.stringify(result));
+  process.exit(0);
+}
+function outputClineAllow() {
+  console.log(JSON.stringify({ cancel: false }));
+  process.exit(0);
+}
+function outputCursorBlock(reason) {
+  console.log(JSON.stringify({ decision: "deny", reason }));
+  process.exit(0);
+}
+function outputCursorAllow() {
+  console.log(JSON.stringify({ decision: "allow" }));
+  process.exit(0);
+}
+function detectEditorFormat(input) {
+  if (input.hookName !== void 0 || input.toolName !== void 0) {
+    return "cline";
+  }
+  if (input.hook_event_name !== void 0) {
+    return "cursor";
+  }
+  return "claude";
+}
+async function runPreToolUseHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const editorFormat = detectEditorFormat(input);
+  const cwd = extractCwd(input);
+  const tool = extractToolName(input);
+  const toolInput = extractToolInput(input);
+  const { isIndexed } = isProjectIndexed(cwd);
+  if (!isIndexed) {
+    if (editorFormat === "cline") {
+      outputClineAllow();
+    } else if (editorFormat === "cursor") {
+      outputCursorAllow();
+    }
+    process.exit(0);
+  }
+  if (tool === "Glob") {
+    const pattern = toolInput?.pattern || "";
+    if (isDiscoveryGlob(pattern)) {
+      const msg = `STOP: Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of Glob.`;
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+  } else if (tool === "Grep" || tool === "Search") {
+    const pattern = toolInput?.pattern || "";
+    const filePath = toolInput?.path || "";
+    if (pattern) {
+      if (filePath && !isDiscoveryGrep(filePath)) {
+        const msg = `STOP: Use Read("${filePath}") to view file content, or mcp__contextstream__search(mode="keyword", query="${pattern}") for codebase search.`;
+        if (editorFormat === "cline") {
+          outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+        } else if (editorFormat === "cursor") {
+          outputCursorBlock(msg);
+        }
+        blockClaudeCode(msg);
+      } else {
+        const msg = `STOP: Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of ${tool}.`;
+        if (editorFormat === "cline") {
+          outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+        } else if (editorFormat === "cursor") {
+          outputCursorBlock(msg);
+        }
+        blockClaudeCode(msg);
+      }
+    }
+  } else if (tool === "Task") {
+    const subagentType = toolInput?.subagent_type?.toLowerCase() || "";
+    if (subagentType === "explore") {
+      const msg = 'STOP: Use mcp__contextstream__search(mode="hybrid") instead of Task(Explore).';
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+    if (subagentType === "plan") {
+      const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan") for planning. ContextStream plans persist across sessions.';
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+  } else if (tool === "EnterPlanMode") {
+    const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan", title="...", steps=[...]) instead of EnterPlanMode. ContextStream plans persist across sessions and are searchable.';
+    if (editorFormat === "cline") {
+      outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
+    } else if (editorFormat === "cursor") {
+      outputCursorBlock(msg);
+    }
+    blockClaudeCode(msg);
+  }
+  if (tool === "list_files" || tool === "search_files") {
+    const pattern = toolInput?.path || toolInput?.regex || "";
+    if (isDiscoveryGlob(pattern) || isDiscoveryGrep(pattern)) {
+      const msg = `Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of ${tool}. ContextStream search is indexed and faster.`;
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+    }
+  }
+  if (editorFormat === "cline") {
+    outputClineAllow();
+  } else if (editorFormat === "cursor") {
+    outputCursorAllow();
+  }
+  process.exit(0);
+}
+var ENABLED, INDEX_STATUS_FILE, STALE_THRESHOLD_DAYS, DISCOVERY_PATTERNS, isDirectRun;
+var init_pre_tool_use = __esm({
+  "src/hooks/pre-tool-use.ts"() {
+    "use strict";
+    ENABLED = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
+    INDEX_STATUS_FILE = path.join(homedir(), ".contextstream", "indexed-projects.json");
+    STALE_THRESHOLD_DAYS = 7;
+    DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
+    isDirectRun = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
+    if (isDirectRun) {
+      runPreToolUseHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/user-prompt-submit.ts
+var user_prompt_submit_exports = {};
+__export(user_prompt_submit_exports, {
+  runUserPromptSubmitHook: () => runUserPromptSubmitHook
+});
+function detectEditorFormat2(input) {
+  if (input.hookName !== void 0) {
+    return "cline";
+  }
+  if (input.hook_event_name === "beforeSubmitPrompt") {
+    return "cursor";
+  }
+  return "claude";
+}
+async function runUserPromptSubmitHook() {
+  if (!ENABLED2) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const editorFormat = detectEditorFormat2(input);
+  if (editorFormat === "claude") {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: REMINDER
+        }
+      })
+    );
+  } else if (editorFormat === "cline") {
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: REMINDER
+      })
+    );
+  } else if (editorFormat === "cursor") {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        user_message: "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+      })
+    );
+  }
+  process.exit(0);
+}
+var ENABLED2, REMINDER, isDirectRun2;
+var init_user_prompt_submit = __esm({
+  "src/hooks/user-prompt-submit.ts"() {
+    "use strict";
+    ENABLED2 = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
+    REMINDER = `[CONTEXTSTREAM - DO THIS FIRST]
+mcp__contextstream__context(user_message="<user's message>") - CALL THIS BEFORE ANY OTHER TOOL
+
+Why: Delivers task-specific rules, lessons from past mistakes, and relevant context.
+Skip it = repeat past mistakes, miss relevant decisions, fly blind.
+
+BEFORE Glob/Grep/Read/Search/Explore:
+mcp__contextstream__search(mode="hybrid", query="...") FIRST
+Local tools ONLY if search returns 0 results.
+[END]`;
+    isDirectRun2 = process.argv[1]?.includes("user-prompt-submit") || process.argv[2] === "user-prompt-submit";
+    if (isDirectRun2) {
+      runUserPromptSubmitHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/media-aware.ts
+var media_aware_exports = {};
+__export(media_aware_exports, {
+  runMediaAwareHook: () => runMediaAwareHook
+});
+function matchesMediaPattern(text) {
+  return PATTERNS.some((pattern) => pattern.test(text));
+}
+function extractPrompt(input) {
+  if (input.prompt) {
+    return input.prompt;
+  }
+  if (input.session?.messages) {
+    for (let i = input.session.messages.length - 1; i >= 0; i--) {
+      const msg = input.session.messages[i];
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        }
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+              return block.text;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  return "";
+}
+function detectEditorFormat3(input) {
+  if (input.hookName !== void 0) {
+    return "cline";
+  }
+  return "claude";
+}
+async function runMediaAwareHook() {
+  if (!ENABLED3) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const prompt = extractPrompt(input);
+  if (!prompt || !matchesMediaPattern(prompt)) {
+    process.exit(0);
+  }
+  const editorFormat = detectEditorFormat3(input);
+  if (editorFormat === "claude") {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: MEDIA_CONTEXT
+        }
+      })
+    );
+  } else {
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: MEDIA_CONTEXT
+      })
+    );
+  }
+  process.exit(0);
+}
+var ENABLED3, PATTERNS, MEDIA_CONTEXT, isDirectRun3;
+var init_media_aware = __esm({
+  "src/hooks/media-aware.ts"() {
+    "use strict";
+    ENABLED3 = process.env.CONTEXTSTREAM_MEDIA_HOOK_ENABLED !== "false";
+    PATTERNS = [
+      /\b(video|videos|clip|clips|footage|keyframe)s?\b/i,
+      /\b(remotion|timeline|video\s*edit)\b/i,
+      /\b(image|images|photo|photos|picture|thumbnail)s?\b/i,
+      /\b(audio|podcast|transcript|transcription|voice)\b/i,
+      /\b(media|asset|assets|creative|b-roll)\b/i,
+      /\b(find|search|show).*(clip|video|image|audio|footage|media)\b/i
+    ];
+    MEDIA_CONTEXT = `[MEDIA TOOLS AVAILABLE]
+Your workspace may have indexed media. Use ContextStream media tools:
+
+- **Search**: \`mcp__contextstream__media(action="search", query="description")\`
+- **Get clip**: \`mcp__contextstream__media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion|ffmpeg|raw")\`
+- **List assets**: \`mcp__contextstream__media(action="list")\`
+- **Index**: \`mcp__contextstream__media(action="index", file_path="...", content_type="video|audio|image|document")\`
+
+For Remotion: use \`output_format="remotion"\` to get frame-based props.
+[END MEDIA TOOLS]`;
+    isDirectRun3 = process.argv[1]?.includes("media-aware") || process.argv[2] === "media-aware";
+    if (isDirectRun3) {
+      runMediaAwareHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/pre-compact.ts
+var pre_compact_exports = {};
+__export(pre_compact_exports, {
+  runPreCompactHook: () => runPreCompactHook
+});
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path2.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path2.join(searchDir, ".mcp.json");
+      if (fs2.existsSync(mcpPath)) {
+        try {
+          const content = fs2.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path2.join(searchDir, ".contextstream", "config.json");
+      if (fs2.existsSync(csConfigPath)) {
+        try {
+          const content = fs2.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path2.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path2.join(homedir2(), ".mcp.json");
+    if (fs2.existsSync(homeMcpPath)) {
+      try {
+        const content = fs2.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+function parseTranscript(transcriptPath) {
+  const activeFiles = /* @__PURE__ */ new Set();
+  const recentMessages = [];
+  const toolCalls = [];
+  const messages = [];
+  let startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let firstTimestamp = true;
+  try {
+    const content = fs2.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const msgType = entry.type || "";
+        const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        if (firstTimestamp && entry.timestamp) {
+          startedAt = entry.timestamp;
+          firstTimestamp = false;
+        }
+        if (msgType === "tool_use") {
+          const toolName = entry.name || "";
+          const toolInput = entry.input || {};
+          toolCalls.push({ name: toolName, input: toolInput });
+          if (["Read", "Write", "Edit", "NotebookEdit"].includes(toolName)) {
+            const filePath = toolInput.file_path || toolInput.notebook_path;
+            if (filePath) {
+              activeFiles.add(filePath);
+            }
+          } else if (toolName === "Glob") {
+            const pattern = toolInput.pattern;
+            if (pattern) {
+              activeFiles.add(`[glob:${pattern}]`);
+            }
+          }
+          messages.push({
+            role: "assistant",
+            content: `[Tool: ${toolName}]`,
+            timestamp,
+            tool_calls: { name: toolName, input: toolInput }
+          });
+        } else if (msgType === "tool_result") {
+          const resultContent = typeof entry.content === "string" ? entry.content.slice(0, 2e3) : JSON.stringify(entry.content || {}).slice(0, 2e3);
+          messages.push({
+            role: "tool",
+            content: resultContent,
+            timestamp,
+            tool_results: { name: entry.name }
+          });
+        } else if (msgType === "user" || entry.role === "user") {
+          const userContent = typeof entry.content === "string" ? entry.content : "";
+          if (userContent) {
+            messages.push({
+              role: "user",
+              content: userContent,
+              timestamp
+            });
+          }
+        } else if (msgType === "assistant" || entry.role === "assistant") {
+          const assistantContent = typeof entry.content === "string" ? entry.content : "";
+          if (assistantContent) {
+            messages.push({
+              role: "assistant",
+              content: assistantContent,
+              timestamp
+            });
+            if (assistantContent.length > 50) {
+              recentMessages.push(assistantContent.slice(0, 500));
+            }
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return {
+    activeFiles: Array.from(activeFiles).slice(-20),
+    // Last 20 files
+    toolCallCount: toolCalls.length,
+    messageCount: messages.length,
+    lastTools: toolCalls.slice(-10).map((t) => t.name),
+    // Last 10 tool names
+    messages,
+    startedAt
+  };
+}
+async function saveFullTranscript(sessionId, transcriptData, trigger) {
+  if (!API_KEY) {
+    return { success: false, message: "No API key configured" };
+  }
+  if (transcriptData.messages.length === 0) {
+    return { success: false, message: "No messages to save" };
+  }
+  const payload = {
+    session_id: sessionId,
+    messages: transcriptData.messages,
+    started_at: transcriptData.startedAt,
+    source_type: "pre_compact",
+    title: `Pre-compaction save (${trigger})`,
+    metadata: {
+      trigger,
+      active_files: transcriptData.activeFiles,
+      tool_call_count: transcriptData.toolCallCount
+    },
+    tags: ["pre_compaction", trigger]
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(`${API_URL}/api/v1/transcripts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: `Transcript saved (${transcriptData.messages.length} messages)` };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
+async function saveSnapshot(sessionId, transcriptData, trigger) {
+  if (!API_KEY) {
+    return { success: false, message: "No API key configured" };
+  }
+  const snapshotContent = {
+    session_id: sessionId,
+    trigger,
+    captured_at: null,
+    // API will set timestamp
+    active_files: transcriptData.activeFiles,
+    tool_call_count: transcriptData.toolCallCount,
+    last_tools: transcriptData.lastTools,
+    auto_captured: true
+  };
+  const payload = {
+    event_type: "session_snapshot",
+    title: `Auto Pre-compaction Snapshot (${trigger})`,
+    content: JSON.stringify(snapshotContent),
+    importance: "high",
+    tags: ["session_snapshot", "pre_compaction", "auto_captured"],
+    source_type: "hook"
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return { success: true, message: "Snapshot saved" };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
+async function runPreCompactHook() {
+  if (!ENABLED4) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "unknown";
+  const transcriptPath = input.transcript_path || "";
+  const trigger = input.trigger || "unknown";
+  const customInstructions = input.custom_instructions || "";
+  let transcriptData = {
+    activeFiles: [],
+    toolCallCount: 0,
+    messageCount: 0,
+    lastTools: []
+  };
+  if (transcriptPath && fs2.existsSync(transcriptPath)) {
+    transcriptData = parseTranscript(transcriptPath);
+  }
+  let autoSaveStatus = "";
+  if (AUTO_SAVE && API_KEY) {
+    const transcriptResult = await saveFullTranscript(sessionId, transcriptData, trigger);
+    if (transcriptResult.success) {
+      autoSaveStatus = `
+[ContextStream: ${transcriptResult.message}]`;
+    } else {
+      const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
+      if (success) {
+        autoSaveStatus = `
+[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files (transcript save failed: ${transcriptResult.message})]`;
+      } else {
+        autoSaveStatus = `
+[ContextStream: Auto-save failed - ${message}]`;
+      }
+    }
+  }
+  const filesList = transcriptData.activeFiles.slice(0, 5).join(", ") || "none detected";
+  const context = `[CONTEXT COMPACTION - ${trigger.toUpperCase()}]${autoSaveStatus}
+
+Active files detected: ${filesList}
+Tool calls in session: ${transcriptData.toolCallCount}
+
+After compaction, call session_init(is_post_compact=true) to restore context.${customInstructions ? `
+User instructions: ${customInstructions}` : ""}`;
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreCompact",
+        additionalContext: context
+      }
+    })
+  );
+  process.exit(0);
+}
+var ENABLED4, AUTO_SAVE, API_URL, API_KEY, WORKSPACE_ID, isDirectRun4;
+var init_pre_compact = __esm({
+  "src/hooks/pre-compact.ts"() {
+    "use strict";
+    ENABLED4 = process.env.CONTEXTSTREAM_PRECOMPACT_ENABLED !== "false";
+    AUTO_SAVE = process.env.CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE !== "false";
+    API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+    WORKSPACE_ID = null;
+    isDirectRun4 = process.argv[1]?.includes("pre-compact") || process.argv[2] === "pre-compact";
+    if (isDirectRun4) {
+      runPreCompactHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/post-write.ts
+var post_write_exports = {};
+__export(post_write_exports, {
+  runPostWriteHook: () => runPostWriteHook
+});
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { homedir as homedir3 } from "node:os";
+function extractFilePath(input) {
+  if (input.tool_input) {
+    const filePath = input.tool_input.file_path || input.tool_input.notebook_path || input.tool_input.path;
+    if (filePath) return filePath;
+  }
+  if (input.parameters) {
+    const filePath = input.parameters.path || input.parameters.file_path;
+    if (filePath) return filePath;
+  }
+  if (input.toolParameters?.path) {
+    return input.toolParameters.path;
+  }
+  if (input.file_path) {
+    return input.file_path;
+  }
+  return null;
+}
+function extractCwd2(input) {
+  if (input.cwd) return input.cwd;
+  if (input.workspace_roots?.length) return input.workspace_roots[0];
+  if (input.workspaceRoots?.length) return input.workspaceRoots[0];
+  return process.cwd();
+}
+function findLocalConfig(startDir) {
+  let currentDir = path3.resolve(startDir);
+  for (let i = 0; i < 10; i++) {
+    const configPath = path3.join(currentDir, ".contextstream", "config.json");
+    if (fs3.existsSync(configPath)) {
+      try {
+        const content = fs3.readFileSync(configPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+      }
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+function loadApiConfig(startDir) {
+  let apiUrl = API_URL2;
+  let apiKey = API_KEY2;
+  if (apiKey) {
+    return { apiUrl, apiKey };
+  }
+  let currentDir = path3.resolve(startDir);
+  for (let i = 0; i < 10; i++) {
+    const mcpPath = path3.join(currentDir, ".mcp.json");
+    if (fs3.existsSync(mcpPath)) {
+      try {
+        const content = fs3.readFileSync(mcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          apiKey = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          apiUrl = csEnv.CONTEXTSTREAM_API_URL;
+        }
+        if (apiKey) break;
+      } catch {
+      }
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  if (!apiKey) {
+    const homeMcpPath = path3.join(homedir3(), ".mcp.json");
+    if (fs3.existsSync(homeMcpPath)) {
+      try {
+        const content = fs3.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          apiKey = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          apiUrl = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+  return { apiUrl, apiKey };
+}
+function shouldIndexFile(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  if (!INDEXABLE_EXTENSIONS.has(ext)) {
+    const basename2 = path3.basename(filePath).toLowerCase();
+    if (!["dockerfile", "makefile", "rakefile", "gemfile", "procfile"].includes(basename2)) {
+      return false;
+    }
+  }
+  try {
+    const stats = fs3.statSync(filePath);
+    if (stats.size > MAX_FILE_SIZE) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  return true;
+}
+function detectLanguage(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".pyw": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".fs": "fsharp",
+    ".vb": "vb",
+    ".rb": "ruby",
+    ".php": "php",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".swift": "swift",
+    ".m": "objective-c",
+    ".mm": "objective-cpp",
+    ".lua": "lua",
+    ".r": "r",
+    ".jl": "julia",
+    ".sh": "shell",
+    ".bash": "shell",
+    ".zsh": "shell",
+    ".fish": "shell",
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".xml": "xml",
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".md": "markdown",
+    ".mdx": "mdx",
+    ".txt": "text",
+    ".rst": "rst",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".astro": "astro",
+    ".tf": "terraform",
+    ".hcl": "hcl",
+    ".prisma": "prisma",
+    ".proto": "protobuf"
+  };
+  return langMap[ext] || "text";
+}
+async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const relativePath = path3.relative(projectRoot, filePath);
+  const payload = {
+    files: [
+      {
+        path: relativePath,
+        content,
+        language: detectLanguage(filePath)
+      }
+    ]
+  };
+  const response = await fetch(`${apiUrl}/api/v1/projects/${projectId}/files/ingest`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(1e4)
+    // 10 second timeout
+  });
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status} ${response.statusText}`);
+  }
+}
+function findProjectRoot(filePath) {
+  let currentDir = path3.dirname(path3.resolve(filePath));
+  for (let i = 0; i < 10; i++) {
+    const configPath = path3.join(currentDir, ".contextstream", "config.json");
+    if (fs3.existsSync(configPath)) {
+      return currentDir;
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function runPostWriteHook() {
+  if (!ENABLED5) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const filePath = extractFilePath(input);
+  if (!filePath) {
+    process.exit(0);
+  }
+  const cwd = extractCwd2(input);
+  const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(cwd, filePath);
+  if (!fs3.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
+    process.exit(0);
+  }
+  const projectRoot = findProjectRoot(absolutePath);
+  if (!projectRoot) {
+    process.exit(0);
+  }
+  const localConfig = findLocalConfig(projectRoot);
+  if (!localConfig?.project_id) {
+    process.exit(0);
+  }
+  const { apiUrl, apiKey } = loadApiConfig(projectRoot);
+  if (!apiKey) {
+    process.exit(0);
+  }
+  try {
+    await indexFile(absolutePath, localConfig.project_id, apiUrl, apiKey, projectRoot);
+  } catch {
+  }
+  process.exit(0);
+}
+var API_URL2, API_KEY2, ENABLED5, INDEXABLE_EXTENSIONS, MAX_FILE_SIZE, isDirectRun5;
+var init_post_write = __esm({
+  "src/hooks/post-write.ts"() {
+    "use strict";
+    API_URL2 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY2 = process.env.CONTEXTSTREAM_API_KEY || "";
+    ENABLED5 = process.env.CONTEXTSTREAM_POSTWRITE_ENABLED !== "false";
+    INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".pyw",
+      ".rs",
+      ".go",
+      ".java",
+      ".kt",
+      ".scala",
+      ".c",
+      ".cpp",
+      ".cc",
+      ".cxx",
+      ".h",
+      ".hpp",
+      ".cs",
+      ".fs",
+      ".vb",
+      ".rb",
+      ".php",
+      ".pl",
+      ".pm",
+      ".swift",
+      ".m",
+      ".mm",
+      ".lua",
+      ".r",
+      ".jl",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".fish",
+      ".sql",
+      ".graphql",
+      ".gql",
+      ".html",
+      ".htm",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".xml",
+      ".ini",
+      ".cfg",
+      ".md",
+      ".mdx",
+      ".txt",
+      ".rst",
+      ".vue",
+      ".svelte",
+      ".astro",
+      ".tf",
+      ".hcl",
+      ".dockerfile",
+      ".containerfile",
+      ".prisma",
+      ".proto"
+    ]);
+    MAX_FILE_SIZE = 1024 * 1024;
+    isDirectRun5 = process.argv[1]?.includes("post-write") || process.argv[2] === "post-write";
+    if (isDirectRun5) {
+      runPostWriteHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks-config.ts
+var hooks_config_exports = {};
+__export(hooks_config_exports, {
+  CLINE_POSTTOOLUSE_HOOK_SCRIPT: () => CLINE_POSTTOOLUSE_HOOK_SCRIPT,
+  CLINE_PRETOOLUSE_HOOK_SCRIPT: () => CLINE_PRETOOLUSE_HOOK_SCRIPT,
+  CLINE_USER_PROMPT_HOOK_SCRIPT: () => CLINE_USER_PROMPT_HOOK_SCRIPT,
+  CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT: () => CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT,
+  CURSOR_PRETOOLUSE_HOOK_SCRIPT: () => CURSOR_PRETOOLUSE_HOOK_SCRIPT,
+  MEDIA_AWARE_HOOK_SCRIPT: () => MEDIA_AWARE_HOOK_SCRIPT,
+  PRECOMPACT_HOOK_SCRIPT: () => PRECOMPACT_HOOK_SCRIPT,
+  PRETOOLUSE_HOOK_SCRIPT: () => PRETOOLUSE_HOOK_SCRIPT,
+  USER_PROMPT_HOOK_SCRIPT: () => USER_PROMPT_HOOK_SCRIPT,
+  buildHooksConfig: () => buildHooksConfig,
+  generateAllHooksDocumentation: () => generateAllHooksDocumentation,
+  generateHooksDocumentation: () => generateHooksDocumentation,
+  getClaudeSettingsPath: () => getClaudeSettingsPath,
+  getClineHooksDir: () => getClineHooksDir,
+  getCursorHooksConfigPath: () => getCursorHooksConfigPath,
+  getCursorHooksDir: () => getCursorHooksDir,
+  getHookCommand: () => getHookCommand,
+  getHooksDir: () => getHooksDir,
+  getIndexStatusPath: () => getIndexStatusPath,
+  getKiloCodeHooksDir: () => getKiloCodeHooksDir,
+  getRooCodeHooksDir: () => getRooCodeHooksDir,
+  installAllEditorHooks: () => installAllEditorHooks,
+  installClaudeCodeHooks: () => installClaudeCodeHooks,
+  installClineHookScripts: () => installClineHookScripts,
+  installCursorHookScripts: () => installCursorHookScripts,
+  installEditorHooks: () => installEditorHooks,
+  installHookScripts: () => installHookScripts,
+  installKiloCodeHookScripts: () => installKiloCodeHookScripts,
+  installRooCodeHookScripts: () => installRooCodeHookScripts,
+  markProjectIndexed: () => markProjectIndexed,
+  mergeHooksIntoSettings: () => mergeHooksIntoSettings,
+  readClaudeSettings: () => readClaudeSettings,
+  readCursorHooksConfig: () => readCursorHooksConfig,
+  readIndexStatus: () => readIndexStatus,
+  unmarkProjectIndexed: () => unmarkProjectIndexed,
+  writeClaudeSettings: () => writeClaudeSettings,
+  writeCursorHooksConfig: () => writeCursorHooksConfig,
+  writeIndexStatus: () => writeIndexStatus
+});
+import * as fs4 from "node:fs/promises";
+import * as path4 from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { fileURLToPath } from "node:url";
+function getHookCommand(hookName2) {
+  try {
+    const __dirname = path4.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path4.join(__dirname, "index.js");
+    const fs6 = __require("node:fs");
+    if (fs6.existsSync(indexPath)) {
+      return `node ${indexPath} hook ${hookName2}`;
+    }
+  } catch {
+  }
+  return `npx @contextstream/mcp-server hook ${hookName2}`;
+}
+function getClaudeSettingsPath(scope, projectPath) {
+  if (scope === "user") {
+    return path4.join(homedir4(), ".claude", "settings.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".claude", "settings.json");
+}
+function getHooksDir() {
+  return path4.join(homedir4(), ".claude", "hooks");
+}
+function buildHooksConfig(options) {
+  const userPromptHooks = [
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("user-prompt-submit"),
+          timeout: 5
+        }
+      ]
+    }
+  ];
+  if (options?.includeOnSaveIntent !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-save-intent"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeMediaAware !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("media-aware"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  const config = {
+    PreToolUse: [
+      {
+        matcher: "Glob|Grep|Search|Task|EnterPlanMode",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("pre-tool-use"),
+            timeout: 5
+          }
+        ]
+      }
+    ],
+    UserPromptSubmit: userPromptHooks
+  };
+  if (options?.includePreCompact !== false) {
+    config.PreCompact = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("pre-compact"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionInit !== false) {
+    config.SessionStart = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-init"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionEnd !== false) {
+    config.Stop = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-end"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  const postToolUseHooks = [];
+  if (options?.includePostWrite !== false) {
+    postToolUseHooks.push({
+      matcher: "Edit|Write|NotebookEdit",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("post-write"),
+          timeout: 10
+        }
+      ]
+    });
+  }
+  if (options?.includeAutoRules !== false) {
+    postToolUseHooks.push({
+      matcher: "mcp__contextstream__init|mcp__contextstream__context",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("auto-rules"),
+          timeout: 15
+        }
+      ]
+    });
+  }
+  if (options?.includeOnBash !== false) {
+    postToolUseHooks.push({
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-bash"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnTask !== false) {
+    postToolUseHooks.push({
+      matcher: "Task",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-task"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnRead !== false) {
+    postToolUseHooks.push({
+      matcher: "Read|Glob|Grep",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-read"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnWeb !== false) {
+    postToolUseHooks.push({
+      matcher: "WebFetch|WebSearch",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-web"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (postToolUseHooks.length > 0) {
+    config.PostToolUse = postToolUseHooks;
+  }
+  return config;
+}
+async function installHookScripts(options) {
+  const hooksDir = getHooksDir();
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const result = {
+    preToolUse: getHookCommand("pre-tool-use"),
+    userPrompt: getHookCommand("user-prompt-submit")
+  };
+  if (options?.includePreCompact !== false) {
+    result.preCompact = getHookCommand("pre-compact");
+  }
+  if (options?.includeMediaAware !== false) {
+    result.mediaAware = getHookCommand("media-aware");
+  }
+  if (options?.includeAutoRules !== false) {
+    result.autoRules = getHookCommand("auto-rules");
+  }
+  return result;
+}
+async function readClaudeSettings(scope, projectPath) {
+  const settingsPath = getClaudeSettingsPath(scope, projectPath);
+  try {
+    const content = await fs4.readFile(settingsPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeClaudeSettings(settings, scope, projectPath) {
+  const settingsPath = getClaudeSettingsPath(scope, projectPath);
+  const dir = path4.dirname(settingsPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}
+function mergeHooksIntoSettings(existingSettings, newHooks) {
+  const settings = { ...existingSettings };
+  const existingHooks = settings.hooks || {};
+  for (const [hookType, matchers] of Object.entries(newHooks || {})) {
+    if (!matchers) continue;
+    const existing = existingHooks?.[hookType] || [];
+    const filtered = existing.filter((m) => {
+      return !m.hooks?.some((h) => h.command?.includes("contextstream"));
+    });
+    existingHooks[hookType] = [...filtered, ...matchers];
+  }
+  settings.hooks = existingHooks;
+  return settings;
+}
+async function installClaudeCodeHooks(options) {
+  const result = { scripts: [], settings: [] };
+  result.scripts.push(
+    getHookCommand("pre-tool-use"),
+    getHookCommand("user-prompt-submit")
+  );
+  if (options.includePreCompact !== false) {
+    result.scripts.push(getHookCommand("pre-compact"));
+  }
+  if (options.includeMediaAware !== false) {
+    result.scripts.push(getHookCommand("media-aware"));
+  }
+  if (options.includePostWrite !== false) {
+    result.scripts.push(getHookCommand("post-write"));
+  }
+  if (options.includeAutoRules !== false) {
+    result.scripts.push(getHookCommand("auto-rules"));
+  }
+  const hooksConfig = buildHooksConfig({
+    includePreCompact: options.includePreCompact,
+    includeMediaAware: options.includeMediaAware,
+    includePostWrite: options.includePostWrite,
+    includeAutoRules: options.includeAutoRules
+  });
+  if (options.scope === "user" || options.scope === "both") {
+    const settingsPath = getClaudeSettingsPath("user");
+    if (!options.dryRun) {
+      const existing = await readClaudeSettings("user");
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, "user");
+    }
+    result.settings.push(settingsPath);
+  }
+  if ((options.scope === "project" || options.scope === "both") && options.projectPath) {
+    const settingsPath = getClaudeSettingsPath("project", options.projectPath);
+    if (!options.dryRun) {
+      const existing = await readClaudeSettings("project", options.projectPath);
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, "project", options.projectPath);
+    }
+    result.settings.push(settingsPath);
+  }
+  return result;
+}
+function generateHooksDocumentation() {
+  return `
+## Claude Code Hooks (ContextStream)
+
+ContextStream installs hooks to enforce ContextStream-first behavior.
+All hooks run via Node.js - no Python dependency required.
+
+### PreToolUse Hook
+- **Command:** \`npx @contextstream/mcp-server hook pre-tool-use\`
+- **Purpose:** Blocks Glob/Grep/Search/EnterPlanMode and redirects to ContextStream
+- **Blocked tools:** Glob, Grep, Search, Task(Explore), Task(Plan), EnterPlanMode
+- **Disable:** Set \`CONTEXTSTREAM_HOOK_ENABLED=false\` environment variable
+
+### UserPromptSubmit Hook
+- **Command:** \`npx @contextstream/mcp-server hook user-prompt-submit\`
+- **Purpose:** Injects a reminder about ContextStream rules on every message
+- **Disable:** Set \`CONTEXTSTREAM_REMINDER_ENABLED=false\` environment variable
+
+### Media-Aware Hook
+- **Command:** \`npx @contextstream/mcp-server hook media-aware\`
+- **Purpose:** Detects media-related prompts and injects media tool guidance
+- **Triggers:** Patterns like video, clips, Remotion, image, audio, creative assets
+- **Disable:** Set \`CONTEXTSTREAM_MEDIA_HOOK_ENABLED=false\` environment variable
+
+When Media-Aware hook detects media patterns, it injects context about:
+- How to search indexed media assets
+- How to get clips for Remotion (with frame-based props)
+- How to index new media files
+
+### PreCompact Hook
+- **Command:** \`npx @contextstream/mcp-server hook pre-compact\`
+- **Purpose:** Saves conversation state before context compaction
+- **Triggers:** Both manual (/compact) and automatic compaction
+- **Installed:** By default (disable with \`CONTEXTSTREAM_HOOK_ENABLED=false\`)
+
+When PreCompact runs, it:
+1. Parses the transcript for active files and tool calls
+2. Saves a session_snapshot to ContextStream API
+3. Injects context about using \`session_init(is_post_compact=true)\` after compaction
+
+### PostToolUse Hook (Real-time Indexing)
+- **Command:** \`npx @contextstream/mcp-server hook post-write\`
+- **Purpose:** Indexes files immediately after Edit/Write/NotebookEdit operations
+- **Matcher:** Edit|Write|NotebookEdit
+- **Disable:** Set \`CONTEXTSTREAM_POSTWRITE_ENABLED=false\` environment variable
+
+### Why Hooks?
+Claude Code has strong built-in behaviors to use its default tools (Grep, Glob, Read)
+and its built-in plan mode. CLAUDE.md instructions decay over long conversations.
+Hooks provide:
+1. **Physical enforcement** - Blocked tools can't be used
+2. **Continuous reminders** - Rules stay in recent context
+3. **Better UX** - Faster searches via indexed ContextStream
+4. **Persistent plans** - ContextStream plans survive across sessions
+5. **Compaction awareness** - Save state before context is compacted
+6. **Real-time indexing** - Files indexed immediately after writes
+
+### Manual Configuration
+If you prefer to configure manually, add to \`~/.claude/settings.json\`:
+\`\`\`json
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Glob|Grep|Search|Task|EnterPlanMode",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook pre-tool-use"}]
+    }],
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook user-prompt-submit"}]
+      },
+      {
+        "matcher": "*",
+        "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook media-aware"}]
+      }
+    ],
+    "PreCompact": [{
+      "matcher": "*",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook pre-compact", "timeout": 10}]
+    }],
+    "PostToolUse": [{
+      "matcher": "Edit|Write|NotebookEdit",
+      "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook post-write", "timeout": 10}]
+    }]
+  }
+}
+\`\`\`
+`.trim();
+}
+function getIndexStatusPath() {
+  return path4.join(homedir4(), ".contextstream", "indexed-projects.json");
+}
+async function readIndexStatus() {
+  const statusPath = getIndexStatusPath();
+  try {
+    const content = await fs4.readFile(statusPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+async function writeIndexStatus(status) {
+  const statusPath = getIndexStatusPath();
+  const dir = path4.dirname(statusPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(statusPath, JSON.stringify(status, null, 2));
+}
+async function markProjectIndexed(projectPath, options) {
+  const status = await readIndexStatus();
+  const resolvedPath = path4.resolve(projectPath);
+  status.projects[resolvedPath] = {
+    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_id: options?.project_id,
+    project_name: options?.project_name
+  };
+  await writeIndexStatus(status);
+}
+async function unmarkProjectIndexed(projectPath) {
+  const status = await readIndexStatus();
+  const resolvedPath = path4.resolve(projectPath);
+  delete status.projects[resolvedPath];
+  await writeIndexStatus(status);
+}
+function getClineHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir4(), "Documents", "Cline", "Rules", "Hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".clinerules", "hooks");
+}
+async function installClineHookScripts(options) {
+  const hooksDir = getClineHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
+  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
+  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getRooCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir4(), ".roo", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".roo", "hooks");
+}
+async function installRooCodeHookScripts(options) {
+  const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
+  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
+  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getKiloCodeHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir4(), ".kilocode", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".kilocode", "hooks");
+}
+async function installKiloCodeHookScripts(options) {
+  const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path4.join(hooksDir, "PreToolUse");
+  const userPromptPath = path4.join(hooksDir, "UserPromptSubmit");
+  const postToolUsePath = path4.join(hooksDir, "PostToolUse");
+  await fs4.writeFile(preToolUsePath, CLINE_HOOK_WRAPPER("pre-tool-use"), { mode: 493 });
+  await fs4.writeFile(userPromptPath, CLINE_HOOK_WRAPPER("user-prompt-submit"), { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPromptSubmit: userPromptPath
+  };
+  if (options.includePostWrite !== false) {
+    await fs4.writeFile(postToolUsePath, CLINE_HOOK_WRAPPER("post-write"), { mode: 493 });
+    result.postToolUse = postToolUsePath;
+  }
+  return result;
+}
+function getCursorHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir4(), ".cursor", "hooks.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".cursor", "hooks.json");
+}
+function getCursorHooksDir(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir4(), ".cursor", "hooks");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".cursor", "hooks");
+}
+async function readCursorHooksConfig(scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, hooks: {} };
+  }
+}
+async function writeCursorHooksConfig(config, scope, projectPath) {
+  const configPath = getCursorHooksConfigPath(scope, projectPath);
+  const dir = path4.dirname(configPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installCursorHookScripts(options) {
+  const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
+  const filterContextStreamHooks = (hooks2) => {
+    if (!hooks2) return [];
+    return hooks2.filter((h) => {
+      const hook = h;
+      return !hook.command?.includes("contextstream");
+    });
+  };
+  const filteredPreToolUse = filterContextStreamHooks(existingConfig.hooks.preToolUse);
+  const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
+  const preToolUseCommand = getHookCommand("pre-tool-use");
+  const userPromptCommand = getHookCommand("user-prompt-submit");
+  const config = {
+    version: 1,
+    hooks: {
+      ...existingConfig.hooks,
+      preToolUse: [
+        ...filteredPreToolUse,
+        {
+          command: preToolUseCommand,
+          type: "command",
+          timeout: 5,
+          matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
+        }
+      ],
+      beforeSubmitPrompt: [
+        ...filteredBeforeSubmit,
+        {
+          command: userPromptCommand,
+          type: "command",
+          timeout: 5
+        }
+      ]
+    }
+  };
+  await writeCursorHooksConfig(config, options.scope, options.projectPath);
+  const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
+  return {
+    preToolUse: preToolUseCommand,
+    beforeSubmitPrompt: userPromptCommand,
+    config: configPath
+  };
+}
+async function installEditorHooks(options) {
+  const { editor, scope, projectPath, includePreCompact, includePostWrite } = options;
+  switch (editor) {
+    case "claude": {
+      if (scope === "project" && !projectPath) {
+        throw new Error("projectPath required for project scope");
+      }
+      const scripts = await installHookScripts({ includePreCompact });
+      const hooksConfig = buildHooksConfig({ includePreCompact, includePostWrite });
+      const settingsScope = scope === "global" ? "user" : "project";
+      const existing = await readClaudeSettings(settingsScope, projectPath);
+      const merged = mergeHooksIntoSettings(existing, hooksConfig);
+      await writeClaudeSettings(merged, settingsScope, projectPath);
+      const installed = [scripts.preToolUse, scripts.userPrompt];
+      if (scripts.preCompact) installed.push(scripts.preCompact);
+      return {
+        editor: "claude",
+        installed,
+        hooksDir: getHooksDir()
+      };
+    }
+    case "cline": {
+      const scripts = await installClineHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "cline",
+        installed,
+        hooksDir: getClineHooksDir(scope, projectPath)
+      };
+    }
+    case "roo": {
+      const scripts = await installRooCodeHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "roo",
+        installed,
+        hooksDir: getRooCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "kilo": {
+      const scripts = await installKiloCodeHookScripts({ scope, projectPath, includePostWrite });
+      const installed = [scripts.preToolUse, scripts.userPromptSubmit];
+      if (scripts.postToolUse) installed.push(scripts.postToolUse);
+      return {
+        editor: "kilo",
+        installed,
+        hooksDir: getKiloCodeHooksDir(scope, projectPath)
+      };
+    }
+    case "cursor": {
+      const scripts = await installCursorHookScripts({ scope, projectPath });
+      return {
+        editor: "cursor",
+        installed: [scripts.preToolUse, scripts.beforeSubmitPrompt],
+        hooksDir: getCursorHooksDir(scope, projectPath)
+      };
+    }
+    default:
+      throw new Error(`Unsupported editor: ${editor}`);
+  }
+}
+async function installAllEditorHooks(options) {
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor"];
+  const results = [];
+  for (const editor of editors) {
+    try {
+      const result = await installEditorHooks({
+        editor,
+        scope: options.scope,
+        projectPath: options.projectPath,
+        includePreCompact: options.includePreCompact,
+        includePostWrite: options.includePostWrite
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`Failed to install hooks for ${editor}:`, error);
+    }
+  }
+  return results;
+}
+function generateAllHooksDocumentation() {
+  return `
+## Editor Hooks Support (ContextStream)
+
+ContextStream can install hooks for multiple AI code editors to enforce ContextStream-first behavior.
+
+### Supported Editors
+
+| Editor | Hooks Location | Hook Types |
+|--------|---------------|------------|
+| **Claude Code** | \`~/.claude/hooks/\` | PreToolUse, UserPromptSubmit, PreCompact |
+| **Cursor** | \`~/.cursor/hooks/\` | preToolUse, beforeSubmit |
+| **Cline** | \`~/Documents/Cline/Rules/Hooks/\` | PreToolUse, UserPromptSubmit |
+| **Roo Code** | \`~/.roo/hooks/\` | PreToolUse, UserPromptSubmit |
+| **Kilo Code** | \`~/.kilocode/hooks/\` | PreToolUse, UserPromptSubmit |
+
+### Claude Code Hooks
+
+${generateHooksDocumentation()}
+
+### Cursor Hooks
+
+Cursor uses a \`hooks.json\` configuration file:
+- **preToolUse**: Blocks discovery tools before execution
+- **beforeSubmitPrompt**: Injects ContextStream rules reminder
+
+#### Output Format
+\`\`\`json
+{ "decision": "allow" }
+\`\`\`
+or
+\`\`\`json
+{ "decision": "deny", "reason": "Use ContextStream search instead" }
+\`\`\`
+
+### Cline/Roo/Kilo Code Hooks
+
+These editors use the same hook format (JSON output):
+- **PreToolUse**: Blocks discovery tools, redirects to ContextStream search
+- **UserPromptSubmit**: Injects ContextStream rules reminder
+
+Hooks are executable scripts named after the hook type (no extension).
+
+#### Output Format
+\`\`\`json
+{
+  "cancel": true,
+  "errorMessage": "Use ContextStream search instead",
+  "contextModification": "[CONTEXTSTREAM] Use search tool first"
+}
+\`\`\`
+
+### Installation
+
+Use \`generate_rules(install_hooks=true, editors=["claude", "cursor", "cline", "roo", "kilo"])\` to install hooks for specific editors, or omit \`editors\` to install for all.
+
+### Disabling Hooks
+
+Set environment variables:
+- \`CONTEXTSTREAM_HOOK_ENABLED=false\` - Disable PreToolUse blocking
+- \`CONTEXTSTREAM_REMINDER_ENABLED=false\` - Disable UserPromptSubmit reminders
+`.trim();
+}
+var PRETOOLUSE_HOOK_SCRIPT, USER_PROMPT_HOOK_SCRIPT, MEDIA_AWARE_HOOK_SCRIPT, PRECOMPACT_HOOK_SCRIPT, CLINE_PRETOOLUSE_HOOK_SCRIPT, CLINE_USER_PROMPT_HOOK_SCRIPT, CLINE_POSTTOOLUSE_HOOK_SCRIPT, CLINE_HOOK_WRAPPER, CURSOR_PRETOOLUSE_HOOK_SCRIPT, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT;
+var init_hooks_config = __esm({
+  "src/hooks-config.ts"() {
+    "use strict";
+    PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Claude Code
+Blocks Grep/Glob/Search/Task(Explore)/EnterPlanMode and redirects to ContextStream.
+
+Only blocks if the current project is indexed in ContextStream.
+If not indexed, allows local tools through with a suggestion to index.
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+# Consider index stale after 7 days
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(cwd: str) -> tuple[bool, bool]:
+    """
+    Check if the current directory is in an indexed project.
+    Returns (is_indexed, is_stale).
+    """
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+    cwd_path = Path(cwd).resolve()
+
+    # Check if cwd is within any indexed project
+    for project_path, info in projects.items():
+        try:
+            indexed_path = Path(project_path).resolve()
+            # Check if cwd is the project or a subdirectory
+            if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                # Check if stale
+                indexed_at = info.get("indexed_at")
+                if indexed_at:
+                    try:
+                        indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                        if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                            return True, True  # Indexed but stale
+                    except:
+                        pass
+                return True, False  # Indexed and fresh
+        except:
+            continue
+
+    return False, False
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool = data.get("tool_name", "")
+    inp = data.get("tool_input", {})
+    cwd = data.get("cwd", os.getcwd())
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(cwd)
+
+    if not is_indexed:
+        # Project not indexed - allow local tools but suggest indexing
+        # Don't block, just exit successfully
+        sys.exit(0)
+
+    if is_stale:
+        # Index is stale - allow with warning (printed but not blocking)
+        # Still allow the tool but remind about re-indexing
+        pass  # Continue to blocking logic but could add warning
+
+    if tool == "Glob":
+        pattern = inp.get("pattern", "")
+        if is_discovery_glob(pattern):
+            print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of Glob.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "Grep" or tool == "Search":
+        # Block ALL Grep/Search operations - use ContextStream search or Read for specific files
+        pattern = inp.get("pattern", "")
+        path = inp.get("path", "")
+        if pattern:
+            if path and not is_discovery_grep(path):
+                # Specific file - suggest Read instead
+                print(f"STOP: Use Read(\\"{path}\\") to view file content, or mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") for codebase search.", file=sys.stderr)
+            else:
+                print(f"STOP: Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "Task":
+        if inp.get("subagent_type", "").lower() == "explore":
+            print("STOP: Use mcp__contextstream__search(mode=\\"hybrid\\") instead of Task(Explore).", file=sys.stderr)
+            sys.exit(2)
+        if inp.get("subagent_type", "").lower() == "plan":
+            print("STOP: Use mcp__contextstream__session(action=\\"capture_plan\\") for planning. ContextStream plans persist across sessions.", file=sys.stderr)
+            sys.exit(2)
+
+    elif tool == "EnterPlanMode":
+        print("STOP: Use mcp__contextstream__session(action=\\"capture_plan\\", title=\\"...\\", steps=[...]) instead of EnterPlanMode. ContextStream plans persist across sessions and are searchable.", file=sys.stderr)
+        sys.exit(2)
+
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    USER_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream UserPromptSubmit Hook - Injects reminder on every message.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+REMINDER = """[CONTEXTSTREAM RULES]
+1. BEFORE Glob/Grep/Read/Search: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]"""
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": REMINDER}}))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    MEDIA_AWARE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream Media-Aware Hook for Claude Code
+
+Detects media-related prompts and injects context about the media tool.
+"""
+
+import json
+import sys
+import os
+import re
+
+ENABLED = os.environ.get("CONTEXTSTREAM_MEDIA_HOOK_ENABLED", "true").lower() == "true"
+
+# Media patterns (case-insensitive)
+PATTERNS = [
+    r"\\b(video|videos|clip|clips|footage|keyframe)s?\\b",
+    r"\\b(remotion|timeline|video\\s*edit)\\b",
+    r"\\b(image|images|photo|photos|picture|thumbnail)s?\\b",
+    r"\\b(audio|podcast|transcript|transcription|voice)\\b",
+    r"\\b(media|asset|assets|creative|b-roll)\\b",
+    r"\\b(find|search|show).*(clip|video|image|audio|footage|media)\\b",
+]
+
+COMPILED = [re.compile(p, re.IGNORECASE) for p in PATTERNS]
+
+MEDIA_CONTEXT = """[MEDIA TOOLS AVAILABLE]
+Your workspace may have indexed media. Use ContextStream media tools:
+
+- **Search**: \`mcp__contextstream__media(action="search", query="description")\`
+- **Get clip**: \`mcp__contextstream__media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion|ffmpeg|raw")\`
+- **List assets**: \`mcp__contextstream__media(action="list")\`
+- **Index**: \`mcp__contextstream__media(action="index", file_path="...", content_type="video|audio|image|document")\`
+
+For Remotion: use \`output_format="remotion"\` to get frame-based props.
+[END MEDIA TOOLS]"""
+
+def matches(text):
+    return any(p.search(text) for p in COMPILED)
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    prompt = data.get("prompt", "")
+    if not prompt:
+        session = data.get("session", {})
+        for msg in reversed(session.get("messages", [])):
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                prompt = content if isinstance(content, str) else ""
+                if isinstance(content, list):
+                    for b in content:
+                        if isinstance(b, dict) and b.get("type") == "text":
+                            prompt = b.get("text", "")
+                            break
+                break
+
+    if not prompt or not matches(prompt):
+        sys.exit(0)
+
+    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": MEDIA_CONTEXT}}))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreCompact Hook for Claude Code
+
+Runs BEFORE conversation context is compacted (manual via /compact or automatic).
+Automatically saves conversation state to ContextStream by parsing the transcript.
+
+Input (via stdin):
+{
+  "session_id": "...",
+  "transcript_path": "/path/to/transcript.jsonl",
+  "permission_mode": "default",
+  "hook_event_name": "PreCompact",
+  "trigger": "manual" | "auto",
+  "custom_instructions": "..."
+}
+
+Output (to stdout):
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "... status message ..."
+  }
+}
+"""
+
+import json
+import sys
+import os
+import re
+import urllib.request
+import urllib.error
+
+ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+AUTO_SAVE = os.environ.get("CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE", "true").lower() == "true"
+API_URL = os.environ.get("CONTEXTSTREAM_API_URL", "https://api.contextstream.io")
+API_KEY = os.environ.get("CONTEXTSTREAM_API_KEY", "")
+
+WORKSPACE_ID = None
+
+def load_config_from_mcp_json(cwd):
+    """Load API config from .mcp.json if env vars not set."""
+    global API_URL, API_KEY, WORKSPACE_ID
+
+    # Try to find .mcp.json and .contextstream/config.json in cwd or parent directories
+    search_dir = cwd
+    for _ in range(5):  # Search up to 5 levels
+        # Load API config from .mcp.json
+        if not API_KEY:
+            mcp_path = os.path.join(search_dir, ".mcp.json")
+            if os.path.exists(mcp_path):
+                try:
+                    with open(mcp_path, 'r') as f:
+                        config = json.load(f)
+                    servers = config.get("mcpServers", {})
+                    cs_config = servers.get("contextstream", {})
+                    env = cs_config.get("env", {})
+                    if env.get("CONTEXTSTREAM_API_KEY"):
+                        API_KEY = env["CONTEXTSTREAM_API_KEY"]
+                    if env.get("CONTEXTSTREAM_API_URL"):
+                        API_URL = env["CONTEXTSTREAM_API_URL"]
+                except:
+                    pass
+
+        # Load workspace_id from .contextstream/config.json
+        if not WORKSPACE_ID:
+            cs_config_path = os.path.join(search_dir, ".contextstream", "config.json")
+            if os.path.exists(cs_config_path):
+                try:
+                    with open(cs_config_path, 'r') as f:
+                        cs_config = json.load(f)
+                    if cs_config.get("workspace_id"):
+                        WORKSPACE_ID = cs_config["workspace_id"]
+                except:
+                    pass
+
+        parent = os.path.dirname(search_dir)
+        if parent == search_dir:
+            break
+        search_dir = parent
+
+def parse_transcript(transcript_path):
+    """Parse transcript to extract active files, decisions, and context."""
+    active_files = set()
+    recent_messages = []
+    tool_calls = []
+
+    try:
+        with open(transcript_path, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    msg_type = entry.get("type", "")
+
+                    # Extract files from tool calls
+                    if msg_type == "tool_use":
+                        tool_name = entry.get("name", "")
+                        tool_input = entry.get("input", {})
+                        tool_calls.append({"name": tool_name, "input": tool_input})
+
+                        # Extract file paths from common tools
+                        if tool_name in ["Read", "Write", "Edit", "NotebookEdit"]:
+                            file_path = tool_input.get("file_path") or tool_input.get("notebook_path")
+                            if file_path:
+                                active_files.add(file_path)
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            if pattern:
+                                active_files.add(f"[glob:{pattern}]")
+
+                    # Collect recent assistant messages for summary
+                    if msg_type == "assistant" and entry.get("content"):
+                        content = entry.get("content", "")
+                        if isinstance(content, str) and len(content) > 50:
+                            recent_messages.append(content[:500])
+
+                except json.JSONDecodeError:
+                    continue
+    except Exception as e:
+        pass
+
+    return {
+        "active_files": list(active_files)[-20:],  # Last 20 files
+        "tool_call_count": len(tool_calls),
+        "message_count": len(recent_messages),
+        "last_tools": [t["name"] for t in tool_calls[-10:]],  # Last 10 tool names
+    }
+
+def save_snapshot(session_id, transcript_data, trigger):
+    """Save snapshot to ContextStream API."""
+    if not API_KEY:
+        return False, "No API key configured"
+
+    snapshot_content = {
+        "session_id": session_id,
+        "trigger": trigger,
+        "captured_at": None,  # API will set timestamp
+        "active_files": transcript_data.get("active_files", []),
+        "tool_call_count": transcript_data.get("tool_call_count", 0),
+        "last_tools": transcript_data.get("last_tools", []),
+        "auto_captured": True,
+    }
+
+    payload = {
+        "event_type": "session_snapshot",
+        "title": f"Auto Pre-compaction Snapshot ({trigger})",
+        "content": json.dumps(snapshot_content),
+        "importance": "high",
+        "tags": ["session_snapshot", "pre_compaction", "auto_captured"],
+        "source_type": "hook",
+    }
+
+    # Add workspace_id if available
+    if WORKSPACE_ID:
+        payload["workspace_id"] = WORKSPACE_ID
+
+    try:
+        req = urllib.request.Request(
+            f"{API_URL}/api/v1/memory/events",
+            data=json.dumps(payload).encode('utf-8'),
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": API_KEY,
+            },
+            method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return True, "Snapshot saved"
+    except urllib.error.URLError as e:
+        return False, str(e)
+    except Exception as e:
+        return False, str(e)
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    # Load config from .mcp.json if env vars not set
+    cwd = data.get("cwd", os.getcwd())
+    load_config_from_mcp_json(cwd)
+
+    session_id = data.get("session_id", "unknown")
+    transcript_path = data.get("transcript_path", "")
+    trigger = data.get("trigger", "unknown")
+    custom_instructions = data.get("custom_instructions", "")
+
+    # Parse transcript for context
+    transcript_data = {}
+    if transcript_path and os.path.exists(transcript_path):
+        transcript_data = parse_transcript(transcript_path)
+
+    # Auto-save snapshot if enabled
+    auto_save_status = ""
+    if AUTO_SAVE and API_KEY:
+        success, msg = save_snapshot(session_id, transcript_data, trigger)
+        if success:
+            auto_save_status = f"\\n[ContextStream: Auto-saved snapshot with {len(transcript_data.get('active_files', []))} active files]"
+        else:
+            auto_save_status = f"\\n[ContextStream: Auto-save failed - {msg}]"
+
+    # Build context injection for the AI (backup in case auto-save fails)
+    files_list = ", ".join(transcript_data.get("active_files", [])[:5]) or "none detected"
+    context = f"""[CONTEXT COMPACTION - {trigger.upper()}]{auto_save_status}
+
+Active files detected: {files_list}
+Tool calls in session: {transcript_data.get('tool_call_count', 0)}
+
+After compaction, call session_init(is_post_compact=true) to restore context.
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}"""
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreCompact",
+            "additionalContext": context
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Cline
+Blocks discovery tools and redirects to ContextStream search.
+
+Cline hooks use JSON output format:
+{
+  "cancel": true/false,
+  "errorMessage": "optional error description",
+  "contextModification": "optional text to inject"
+}
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow(context_mod=None):
+    result = {"cancel": False}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def output_block(error_msg, context_mod=None):
+    result = {"cancel": True, "errorMessage": error_msg}
+    if context_mod:
+        result["contextModification"] = context_mod
+    print(json.dumps(result))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hookName", "")
+    if hook_name != "PreToolUse":
+        output_allow()
+
+    tool = data.get("toolName", "")
+    params = data.get("toolParameters", {})
+    workspace_roots = data.get("workspaceRoots", [])
+
+    # Check if project is indexed
+    is_indexed, is_stale = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for discovery patterns
+    if tool == "list_files" or tool == "search_files":
+        pattern = params.get("path", "") or params.get("regex", "")
+        if is_discovery_glob(pattern) or is_discovery_grep(pattern):
+            output_block(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster. Only use local tools if ContextStream returns 0 results.",
+                "[CONTEXTSTREAM] Use ContextStream search for code discovery."
+            )
+
+    elif tool == "read_file":
+        # Allow read_file by default - blocking discovery at search level is enough
+        pass
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_USER_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream UserPromptSubmit Hook for Cline
+Injects reminder about ContextStream rules on every message.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+REMINDER = """[CONTEXTSTREAM RULES]
+1. BEFORE list_files/search_files/read_file: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]"""
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"cancel": False}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "cancel": False,
+        "contextModification": REMINDER
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+    CLINE_POSTTOOLUSE_HOOK_SCRIPT = `#!/bin/bash
+# ContextStream PostToolUse Hook for Cline/Roo/Kilo Code
+# Indexes files after Edit/Write/NotebookEdit operations for real-time search updates.
+#
+# The hook receives JSON on stdin with tool_name and toolParameters.
+# Only runs for write operations (write_to_file, edit_file).
+
+TOOL_NAME=$(cat | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('toolName', d.get('tool_name', '')))" 2>/dev/null)
+
+case "$TOOL_NAME" in
+  write_to_file|edit_file|Write|Edit|NotebookEdit)
+    npx @contextstream/mcp-server hook post-write
+    ;;
+esac
+
+exit 0
+`;
+    CLINE_HOOK_WRAPPER = (hookName2) => {
+      const command = getHookCommand(hookName2);
+      return `#!/bin/bash
+# ContextStream ${hookName2} Hook Wrapper for Cline/Roo/Kilo Code
+exec ${command}
+`;
+    };
+    CURSOR_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreToolUse Hook for Cursor
+Blocks discovery tools and redirects to ContextStream search.
+
+Cursor hooks use JSON output format:
+{
+  "decision": "allow" | "deny",
+  "reason": "optional error description"
+}
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime, timedelta
+
+ENABLED = os.environ.get("CONTEXTSTREAM_HOOK_ENABLED", "true").lower() == "true"
+INDEX_STATUS_FILE = Path.home() / ".contextstream" / "indexed-projects.json"
+STALE_THRESHOLD_DAYS = 7
+
+DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"]
+
+def is_discovery_glob(pattern):
+    pattern_lower = pattern.lower()
+    for p in DISCOVERY_PATTERNS:
+        if p in pattern_lower:
+            return True
+    if pattern_lower.startswith("**/*.") or pattern_lower.startswith("**/"):
+        return True
+    if "**" in pattern or "*/" in pattern:
+        return True
+    return False
+
+def is_discovery_grep(file_path):
+    if not file_path or file_path in [".", "./", "*", "**"]:
+        return True
+    if "*" in file_path or "**" in file_path:
+        return True
+    return False
+
+def is_project_indexed(workspace_roots):
+    """Check if any workspace root is in an indexed project."""
+    if not INDEX_STATUS_FILE.exists():
+        return False, False
+
+    try:
+        with open(INDEX_STATUS_FILE, "r") as f:
+            data = json.load(f)
+    except:
+        return False, False
+
+    projects = data.get("projects", {})
+
+    for workspace in workspace_roots:
+        cwd_path = Path(workspace).resolve()
+        for project_path, info in projects.items():
+            try:
+                indexed_path = Path(project_path).resolve()
+                if cwd_path == indexed_path or indexed_path in cwd_path.parents:
+                    indexed_at = info.get("indexed_at")
+                    if indexed_at:
+                        try:
+                            indexed_time = datetime.fromisoformat(indexed_at.replace("Z", "+00:00"))
+                            if datetime.now(indexed_time.tzinfo) - indexed_time > timedelta(days=STALE_THRESHOLD_DAYS):
+                                return True, True
+                        except:
+                            pass
+                    return True, False
+            except:
+                continue
+    return False, False
+
+def output_allow():
+    print(json.dumps({"decision": "allow"}))
+    sys.exit(0)
+
+def output_deny(reason):
+    print(json.dumps({"decision": "deny", "reason": reason}))
+    sys.exit(0)
+
+def main():
+    if not ENABLED:
+        output_allow()
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        output_allow()
+
+    hook_name = data.get("hook_event_name", "")
+    if hook_name != "preToolUse":
+        output_allow()
+
+    tool = data.get("tool_name", "")
+    params = data.get("tool_input", {}) or data.get("parameters", {})
+    workspace_roots = data.get("workspace_roots", [])
+
+    # Check if project is indexed
+    is_indexed, _ = is_project_indexed(workspace_roots)
+    if not is_indexed:
+        output_allow()
+
+    # Check for Cursor tools
+    if tool in ["Glob", "glob", "list_files"]:
+        pattern = params.get("pattern", "") or params.get("path", "")
+        if is_discovery_glob(pattern):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"hybrid\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    elif tool in ["Grep", "grep", "search_files", "ripgrep"]:
+        pattern = params.get("pattern", "") or params.get("regex", "")
+        file_path = params.get("path", "")
+        if is_discovery_grep(file_path):
+            output_deny(
+                f"Use mcp__contextstream__search(mode=\\"keyword\\", query=\\"{pattern}\\") instead of {tool}. "
+                "ContextStream search is indexed and faster."
+            )
+
+    output_allow()
+
+if __name__ == "__main__":
+    main()
+`;
+    CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream BeforeSubmitPrompt Hook for Cursor
+Injects reminder about ContextStream rules.
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_REMINDER_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    try:
+        json.load(sys.stdin)
+    except:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    print(json.dumps({
+        "continue": True,
+        "user_message": "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+    }))
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+`;
+  }
+});
+
+// src/hooks/auto-rules.ts
+var auto_rules_exports = {};
+__export(auto_rules_exports, {
+  runAutoRulesHook: () => runAutoRulesHook
+});
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+import { homedir as homedir5 } from "node:os";
+function hasRunRecently() {
+  try {
+    if (!fs5.existsSync(MARKER_FILE)) return false;
+    const stat = fs5.statSync(MARKER_FILE);
+    const age = Date.now() - stat.mtimeMs;
+    return age < COOLDOWN_MS;
+  } catch {
+    return false;
+  }
+}
+function markAsRan() {
+  try {
+    const dir = path5.dirname(MARKER_FILE);
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
+    }
+    fs5.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function extractRulesNotice(input) {
+  if (input.tool_result) {
+    try {
+      const parsed = JSON.parse(input.tool_result);
+      if (parsed.rules_notice) return parsed.rules_notice;
+    } catch {
+    }
+  }
+  if (input.tool_response?.structuredContent) {
+    const sc = input.tool_response.structuredContent;
+    if (sc.rules_notice) return sc.rules_notice;
+  }
+  if (input.response) {
+    if (input.response.rules_notice) {
+      return input.response.rules_notice;
+    }
+  }
+  return null;
+}
+function extractCwd3(input) {
+  if (input.cwd) return input.cwd;
+  return process.cwd();
+}
+function hasPythonHooks(settingsPath) {
+  try {
+    if (!fs5.existsSync(settingsPath)) return false;
+    const content = fs5.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const hooks2 = settings.hooks;
+    if (!hooks2) return false;
+    for (const hookType of Object.keys(hooks2)) {
+      const matchers = hooks2[hookType];
+      if (!Array.isArray(matchers)) continue;
+      for (const matcher of matchers) {
+        const hookList = matcher.hooks;
+        if (!Array.isArray(hookList)) continue;
+        for (const hook of hookList) {
+          const cmd = hook.command || "";
+          if (cmd.includes("python3") && cmd.includes("contextstream")) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function detectPythonHooks(cwd) {
+  const globalSettingsPath = path5.join(homedir5(), ".claude", "settings.json");
+  const projectSettingsPath = path5.join(cwd, ".claude", "settings.json");
+  return {
+    global: hasPythonHooks(globalSettingsPath),
+    project: hasPythonHooks(projectSettingsPath)
+  };
+}
+async function upgradeHooksForFolder(folderPath) {
+  const { installClaudeCodeHooks: installClaudeCodeHooks2 } = await Promise.resolve().then(() => (init_hooks_config(), hooks_config_exports));
+  await installClaudeCodeHooks2({
+    scope: "both",
+    projectPath: folderPath,
+    includePreCompact: true,
+    includeMediaAware: true,
+    includePostWrite: true,
+    includeAutoRules: true
+  });
+}
+async function runAutoRulesHook() {
+  if (!ENABLED6) {
+    process.exit(0);
+  }
+  if (hasRunRecently()) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || input.toolName || "";
+  const isContextTool = toolName.includes("init") || toolName.includes("context") || toolName.includes("session_init") || toolName.includes("context_smart");
+  if (!isContextTool) {
+    process.exit(0);
+  }
+  const cwd = extractCwd3(input);
+  const pythonHooks = detectPythonHooks(cwd);
+  const hasPythonHooksToUpgrade = pythonHooks.global || pythonHooks.project;
+  const rulesNotice = extractRulesNotice(input);
+  const rulesNeedUpdate = rulesNotice && rulesNotice.status !== "current";
+  if (!hasPythonHooksToUpgrade && !rulesNeedUpdate) {
+    process.exit(0);
+  }
+  const folderPath = rulesNotice?.update_args?.folder_path || cwd;
+  try {
+    await upgradeHooksForFolder(folderPath);
+    markAsRan();
+  } catch {
+  }
+  process.exit(0);
+}
+var API_URL3, API_KEY3, ENABLED6, MARKER_FILE, COOLDOWN_MS, isDirectRun6;
+var init_auto_rules = __esm({
+  "src/hooks/auto-rules.ts"() {
+    "use strict";
+    API_URL3 = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+    API_KEY3 = process.env.CONTEXTSTREAM_API_KEY || "";
+    ENABLED6 = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
+    MARKER_FILE = path5.join(homedir5(), ".contextstream", ".auto-rules-ran");
+    COOLDOWN_MS = 4 * 60 * 60 * 1e3;
+    isDirectRun6 = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
+    if (isDirectRun6) {
+      runAutoRulesHook().catch(() => process.exit(0));
+    }
+  }
+});
+
+// src/hooks/runner.ts
+var hookName = process.argv[2];
+if (!hookName) {
+  console.error("Usage: contextstream-hook <hook-name>");
+  console.error(
+    "Available hooks: pre-tool-use, user-prompt-submit, media-aware, pre-compact, post-write, auto-rules"
+  );
+  process.exit(1);
+}
+var hooks = {
+  "pre-tool-use": () => Promise.resolve().then(() => (init_pre_tool_use(), pre_tool_use_exports)),
+  "user-prompt-submit": () => Promise.resolve().then(() => (init_user_prompt_submit(), user_prompt_submit_exports)),
+  "media-aware": () => Promise.resolve().then(() => (init_media_aware(), media_aware_exports)),
+  "pre-compact": () => Promise.resolve().then(() => (init_pre_compact(), pre_compact_exports)),
+  "post-write": () => Promise.resolve().then(() => (init_post_write(), post_write_exports)),
+  "auto-rules": () => Promise.resolve().then(() => (init_auto_rules(), auto_rules_exports))
+};
+var handler = hooks[hookName];
+if (!handler) {
+  console.error(`Unknown hook: ${hookName}`);
+  console.error(`Available: ${Object.keys(hooks).join(", ")}`);
+  process.exit(1);
+}
+handler().catch((err) => {
+  console.error(`Hook ${hookName} failed:`, err.message);
+  process.exit(1);
+});