@contextstream/mcp-server 0.4.81 → 1.0.0

package/dist/hooks/auto-rules.js

@@ -1,3384 +0,0 @@
-#!/usr/bin/env node
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/ignore/index.js
-var require_ignore = __commonJS({
-  "node_modules/ignore/index.js"(exports, module) {
-    function makeArray(subject) {
-      return Array.isArray(subject) ? subject : [subject];
-    }
-    var UNDEFINED = void 0;
-    var EMPTY = "";
-    var SPACE = " ";
-    var ESCAPE = "\\";
-    var REGEX_TEST_BLANK_LINE = /^\s+$/;
-    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-    var REGEX_SPLITALL_CRLF = /\r?\n/g;
-    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-    var REGEX_TEST_TRAILING_SLASH = /\/$/;
-    var SLASH = "/";
-    var TMP_KEY_IGNORE = "node-ignore";
-    if (typeof Symbol !== "undefined") {
-      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
-    }
-    var KEY_IGNORE = TMP_KEY_IGNORE;
-    var define = (object, key, value) => {
-      Object.defineProperty(object, key, { value });
-      return value;
-    };
-    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-    var RETURN_FALSE = () => false;
-    var sanitizeRange = (range) => range.replace(
-      REGEX_REGEXP_RANGE,
-      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
-    );
-    var cleanRangeBackSlash = (slashes) => {
-      const { length } = slashes;
-      return slashes.slice(0, length - length % 2);
-    };
-    var REPLACERS = [
-      [
-        // Remove BOM
-        // TODO:
-        // Other similar zero-width characters?
-        /^\uFEFF/,
-        () => EMPTY
-      ],
-      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-      [
-        // (a\ ) -> (a )
-        // (a  ) -> (a)
-        // (a ) -> (a)
-        // (a \ ) -> (a  )
-        /((?:\\\\)*?)(\\?\s+)$/,
-        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
-      ],
-      // Replace (\ ) with ' '
-      // (\ ) -> ' '
-      // (\\ ) -> '\\ '
-      // (\\\ ) -> '\\ '
-      [
-        /(\\+?)\s/g,
-        (_, m1) => {
-          const { length } = m1;
-          return m1.slice(0, length - length % 2) + SPACE;
-        }
-      ],
-      // Escape metacharacters
-      // which is written down by users but means special for regular expressions.
-      // > There are 12 characters with special meanings:
-      // > - the backslash \,
-      // > - the caret ^,
-      // > - the dollar sign $,
-      // > - the period or dot .,
-      // > - the vertical bar or pipe symbol |,
-      // > - the question mark ?,
-      // > - the asterisk or star *,
-      // > - the plus sign +,
-      // > - the opening parenthesis (,
-      // > - the closing parenthesis ),
-      // > - and the opening square bracket [,
-      // > - the opening curly brace {,
-      // > These special characters are often called "metacharacters".
-      [
-        /[\\$.|*+(){^]/g,
-        (match) => `\\${match}`
-      ],
-      [
-        // > a question mark (?) matches a single character
-        /(?!\\)\?/g,
-        () => "[^/]"
-      ],
-      // leading slash
-      [
-        // > A leading slash matches the beginning of the pathname.
-        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-        // A leading slash matches the beginning of the pathname
-        /^\//,
-        () => "^"
-      ],
-      // replace special metacharacter slash after the leading slash
-      [
-        /\//g,
-        () => "\\/"
-      ],
-      [
-        // > A leading "**" followed by a slash means match in all directories.
-        // > For example, "**/foo" matches file or directory "foo" anywhere,
-        // > the same as pattern "foo".
-        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-        // >   under directory "foo".
-        // Notice that the '*'s have been replaced as '\\*'
-        /^\^*\\\*\\\*\\\//,
-        // '**/foo' <-> 'foo'
-        () => "^(?:.*\\/)?"
-      ],
-      // starting
-      [
-        // there will be no leading '/'
-        //   (which has been replaced by section "leading slash")
-        // If starts with '**', adding a '^' to the regular expression also works
-        /^(?=[^^])/,
-        function startingReplacer() {
-          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
-        }
-      ],
-      // two globstars
-      [
-        // Use lookahead assertions so that we could match more than one `'/**'`
-        /\\\/\\\*\\\*(?=\\\/|$)/g,
-        // Zero, one or several directories
-        // should not use '*', or it will be replaced by the next replacer
-        // Check if it is not the last `'/**'`
-        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
-      ],
-      // normal intermediate wildcards
-      [
-        // Never replace escaped '*'
-        // ignore rule '\*' will match the path '*'
-        // 'abc.*/' -> go
-        // 'abc.*'  -> skip this rule,
-        //    coz trailing single wildcard will be handed by [trailing wildcard]
-        /(^|[^\\]+)(\\\*)+(?=.+)/g,
-        // '*.js' matches '.js'
-        // '*.js' doesn't match 'abc'
-        (_, p1, p2) => {
-          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
-          return p1 + unescaped;
-        }
-      ],
-      [
-        // unescape, revert step 3 except for back slash
-        // For example, if a user escape a '\\*',
-        // after step 3, the result will be '\\\\\\*'
-        /\\\\\\(?=[$.|*+(){^])/g,
-        () => ESCAPE
-      ],
-      [
-        // '\\\\' -> '\\'
-        /\\\\/g,
-        () => ESCAPE
-      ],
-      [
-        // > The range notation, e.g. [a-zA-Z],
-        // > can be used to match one of the characters in a range.
-        // `\` is escaped by step 3
-        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
-      ],
-      // ending
-      [
-        // 'js' will not match 'js.'
-        // 'ab' will not match 'abc'
-        /(?:[^*])$/,
-        // WTF!
-        // https://git-scm.com/docs/gitignore
-        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-        // which re-fixes #24, #38
-        // > If there is a separator at the end of the pattern then the pattern
-        // > will only match directories, otherwise the pattern can match both
-        // > files and directories.
-        // 'js*' will not match 'a.js'
-        // 'js/' will not match 'a.js'
-        // 'js' will match 'a.js' and 'a.js/'
-        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
-      ]
-    ];
-    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
-    var MODE_IGNORE = "regex";
-    var MODE_CHECK_IGNORE = "checkRegex";
-    var UNDERSCORE = "_";
-    var TRAILING_WILD_CARD_REPLACERS = {
-      [MODE_IGNORE](_, p1) {
-        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
-      },
-      [MODE_CHECK_IGNORE](_, p1) {
-        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
-      }
-    };
-    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
-      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
-      pattern
-    );
-    var isString = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
-    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
-    var IgnoreRule = class {
-      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
-        this.pattern = pattern;
-        this.mark = mark;
-        this.negative = negative;
-        define(this, "body", body);
-        define(this, "ignoreCase", ignoreCase);
-        define(this, "regexPrefix", prefix);
-      }
-      get regex() {
-        const key = UNDERSCORE + MODE_IGNORE;
-        if (this[key]) {
-          return this[key];
-        }
-        return this._make(MODE_IGNORE, key);
-      }
-      get checkRegex() {
-        const key = UNDERSCORE + MODE_CHECK_IGNORE;
-        if (this[key]) {
-          return this[key];
-        }
-        return this._make(MODE_CHECK_IGNORE, key);
-      }
-      _make(mode, key) {
-        const str = this.regexPrefix.replace(
-          REGEX_REPLACE_TRAILING_WILDCARD,
-          // It does not need to bind pattern
-          TRAILING_WILD_CARD_REPLACERS[mode]
-        );
-        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
-        return define(this, key, regex);
-      }
-    };
-    var createRule = ({
-      pattern,
-      mark
-    }, ignoreCase) => {
-      let negative = false;
-      let body = pattern;
-      if (body.indexOf("!") === 0) {
-        negative = true;
-        body = body.substr(1);
-      }
-      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
-      const regexPrefix = makeRegexPrefix(body);
-      return new IgnoreRule(
-        pattern,
-        mark,
-        body,
-        ignoreCase,
-        negative,
-        regexPrefix
-      );
-    };
-    var RuleManager = class {
-      constructor(ignoreCase) {
-        this._ignoreCase = ignoreCase;
-        this._rules = [];
-      }
-      _add(pattern) {
-        if (pattern && pattern[KEY_IGNORE]) {
-          this._rules = this._rules.concat(pattern._rules._rules);
-          this._added = true;
-          return;
-        }
-        if (isString(pattern)) {
-          pattern = {
-            pattern
-          };
-        }
-        if (checkPattern(pattern.pattern)) {
-          const rule = createRule(pattern, this._ignoreCase);
-          this._added = true;
-          this._rules.push(rule);
-        }
-      }
-      // @param {Array<string> | string | Ignore} pattern
-      add(pattern) {
-        this._added = false;
-        makeArray(
-          isString(pattern) ? splitPattern(pattern) : pattern
-        ).forEach(this._add, this);
-        return this._added;
-      }
-      // Test one single path without recursively checking parent directories
-      //
-      // - checkUnignored `boolean` whether should check if the path is unignored,
-      //   setting `checkUnignored` to `false` could reduce additional
-      //   path matching.
-      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
-      // @returns {TestResult} true if a file is ignored
-      test(path5, checkUnignored, mode) {
-        let ignored = false;
-        let unignored = false;
-        let matchedRule;
-        this._rules.forEach((rule) => {
-          const { negative } = rule;
-          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-            return;
-          }
-          const matched = rule[mode].test(path5);
-          if (!matched) {
-            return;
-          }
-          ignored = !negative;
-          unignored = negative;
-          matchedRule = negative ? UNDEFINED : rule;
-        });
-        const ret = {
-          ignored,
-          unignored
-        };
-        if (matchedRule) {
-          ret.rule = matchedRule;
-        }
-        return ret;
-      }
-    };
-    var throwError = (message, Ctor) => {
-      throw new Ctor(message);
-    };
-    var checkPath = (path5, originalPath, doThrow) => {
-      if (!isString(path5)) {
-        return doThrow(
-          `path must be a string, but got \`${originalPath}\``,
-          TypeError
-        );
-      }
-      if (!path5) {
-        return doThrow(`path must not be empty`, TypeError);
-      }
-      if (checkPath.isNotRelative(path5)) {
-        const r = "`path.relative()`d";
-        return doThrow(
-          `path should be a ${r} string, but got "${originalPath}"`,
-          RangeError
-        );
-      }
-      return true;
-    };
-    var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
-    checkPath.isNotRelative = isNotRelative;
-    checkPath.convert = (p) => p;
-    var Ignore2 = class {
-      constructor({
-        ignorecase = true,
-        ignoreCase = ignorecase,
-        allowRelativePaths = false
-      } = {}) {
-        define(this, KEY_IGNORE, true);
-        this._rules = new RuleManager(ignoreCase);
-        this._strictPathCheck = !allowRelativePaths;
-        this._initCache();
-      }
-      _initCache() {
-        this._ignoreCache = /* @__PURE__ */ Object.create(null);
-        this._testCache = /* @__PURE__ */ Object.create(null);
-      }
-      add(pattern) {
-        if (this._rules.add(pattern)) {
-          this._initCache();
-        }
-        return this;
-      }
-      // legacy
-      addPattern(pattern) {
-        return this.add(pattern);
-      }
-      // @returns {TestResult}
-      _test(originalPath, cache, checkUnignored, slices) {
-        const path5 = originalPath && checkPath.convert(originalPath);
-        checkPath(
-          path5,
-          originalPath,
-          this._strictPathCheck ? throwError : RETURN_FALSE
-        );
-        return this._t(path5, cache, checkUnignored, slices);
-      }
-      checkIgnore(path5) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path5)) {
-          return this.test(path5);
-        }
-        const slices = path5.split(SLASH).filter(Boolean);
-        slices.pop();
-        if (slices.length) {
-          const parent = this._t(
-            slices.join(SLASH) + SLASH,
-            this._testCache,
-            true,
-            slices
-          );
-          if (parent.ignored) {
-            return parent;
-          }
-        }
-        return this._rules.test(path5, false, MODE_CHECK_IGNORE);
-      }
-      _t(path5, cache, checkUnignored, slices) {
-        if (path5 in cache) {
-          return cache[path5];
-        }
-        if (!slices) {
-          slices = path5.split(SLASH).filter(Boolean);
-        }
-        slices.pop();
-        if (!slices.length) {
-          return cache[path5] = this._rules.test(path5, checkUnignored, MODE_IGNORE);
-        }
-        const parent = this._t(
-          slices.join(SLASH) + SLASH,
-          cache,
-          checkUnignored,
-          slices
-        );
-        return cache[path5] = parent.ignored ? parent : this._rules.test(path5, checkUnignored, MODE_IGNORE);
-      }
-      ignores(path5) {
-        return this._test(path5, this._ignoreCache, false).ignored;
-      }
-      createFilter() {
-        return (path5) => !this.ignores(path5);
-      }
-      filter(paths) {
-        return makeArray(paths).filter(this.createFilter());
-      }
-      // @returns {TestResult}
-      test(path5) {
-        return this._test(path5, this._testCache, true);
-      }
-    };
-    var factory = (options) => new Ignore2(options);
-    var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, RETURN_FALSE);
-    var setupWindows = () => {
-      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
-      checkPath.convert = makePosix;
-      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path5) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
-    };
-    if (
-      // Detect `process` so that it can run in browsers.
-      typeof process !== "undefined" && process.platform === "win32"
-    ) {
-      setupWindows();
-    }
-    module.exports = factory;
-    factory.default = factory;
-    module.exports.isPathValid = isPathValid;
-    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
-  }
-});
-
-// src/ignore.ts
-import * as fs from "fs";
-import * as path from "path";
-async function loadIgnorePatterns(projectRoot) {
-  const ig = (0, import_ignore.default)();
-  const patterns = [...DEFAULT_IGNORE_PATTERNS];
-  ig.add(DEFAULT_IGNORE_PATTERNS);
-  const ignoreFilePath = path.join(projectRoot, IGNORE_FILENAME);
-  let hasUserPatterns = false;
-  try {
-    const content = await fs.promises.readFile(ignoreFilePath, "utf-8");
-    const userPatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-    if (userPatterns.length > 0) {
-      ig.add(userPatterns);
-      patterns.push(...userPatterns);
-      hasUserPatterns = true;
-    }
-  } catch {
-  }
-  return {
-    ignores: (pathname) => ig.ignores(pathname),
-    patterns,
-    hasUserPatterns
-  };
-}
-var import_ignore, IGNORE_FILENAME, DEFAULT_IGNORE_PATTERNS;
-var init_ignore = __esm({
-  "src/ignore.ts"() {
-    "use strict";
-    import_ignore = __toESM(require_ignore(), 1);
-    IGNORE_FILENAME = ".contextstream/ignore";
-    DEFAULT_IGNORE_PATTERNS = [
-      // Version control
-      ".git/",
-      ".svn/",
-      ".hg/",
-      // Package managers / dependencies
-      "node_modules/",
-      "vendor/",
-      ".pnpm/",
-      // Build outputs
-      "target/",
-      "dist/",
-      "build/",
-      "out/",
-      ".next/",
-      ".nuxt/",
-      ".svelte-kit/",
-      ".parcel-cache/",
-      ".turbo/",
-      ".gradle/",
-      ".cache/",
-      "bin/",
-      "obj/",
-      // Python
-      "__pycache__/",
-      ".pytest_cache/",
-      ".mypy_cache/",
-      "venv/",
-      ".venv/",
-      "env/",
-      ".env/",
-      // IDE
-      ".idea/",
-      ".vscode/",
-      ".vs/",
-      // Coverage
-      "coverage/",
-      ".coverage/",
-      // Lock files
-      "package-lock.json",
-      "yarn.lock",
-      "pnpm-lock.yaml",
-      "Cargo.lock",
-      "poetry.lock",
-      "Gemfile.lock",
-      "composer.lock",
-      "*.min.js",
-      "*.min.css",
-      // OS files
-      ".DS_Store",
-      "Thumbs.db"
-    ];
-  }
-});
-
-// src/files.ts
-var files_exports = {};
-__export(files_exports, {
-  clearGitContextCache: () => clearGitContextCache,
-  countIndexableFiles: () => countIndexableFiles,
-  deleteHashManifest: () => deleteHashManifest,
-  detectLanguage: () => detectLanguage,
-  readAllFilesInBatches: () => readAllFilesInBatches,
-  readChangedFilesInBatches: () => readChangedFilesInBatches,
-  readFilesFromDirectory: () => readFilesFromDirectory,
-  readHashManifest: () => readHashManifest,
-  sha256Hex: () => sha256Hex,
-  writeHashManifest: () => writeHashManifest
-});
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-import * as os from "os";
-import * as crypto from "crypto";
-function getMachineId() {
-  const hostname2 = os.hostname();
-  const hash = crypto.createHash("sha256").update(hostname2).digest("hex");
-  return hash.substring(0, 12);
-}
-async function isGitRepo(rootPath) {
-  try {
-    await execAsync("git rev-parse --is-inside-work-tree", {
-      cwd: rootPath,
-      timeout: 5e3
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getGitBranch(rootPath) {
-  try {
-    const { stdout } = await execAsync("git branch --show-current", {
-      cwd: rootPath,
-      timeout: 5e3
-    });
-    const branch = stdout.trim();
-    return branch || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function getGitDefaultBranch(rootPath) {
-  try {
-    const { stdout } = await execAsync(
-      "git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null",
-      { cwd: rootPath, timeout: 5e3 }
-    );
-    const match = stdout.trim().match(/refs\/remotes\/origin\/(.+)/);
-    if (match) return match[1];
-  } catch {
-  }
-  try {
-    const { stdout } = await execAsync(
-      "git config --get init.defaultBranch 2>/dev/null",
-      { cwd: rootPath, timeout: 5e3 }
-    );
-    const branch = stdout.trim();
-    if (branch) return branch;
-  } catch {
-  }
-  try {
-    const { stdout } = await execAsync("git branch --list main master", {
-      cwd: rootPath,
-      timeout: 5e3
-    });
-    const branches = stdout.trim().split("\n").map((b) => b.replace(/^\*?\s*/, "").trim()).filter(Boolean);
-    if (branches.includes("main")) return "main";
-    if (branches.includes("master")) return "master";
-  } catch {
-  }
-  return void 0;
-}
-async function getFileGitInfo(rootPath, relativePath) {
-  try {
-    const { stdout } = await execAsync(
-      `git log -1 --format="%H %ct" -- "${relativePath}"`,
-      { cwd: rootPath, timeout: 5e3 }
-    );
-    const parts = stdout.trim().split(" ");
-    if (parts.length >= 2) {
-      const sha = parts[0];
-      const unixTimestamp = parseInt(parts[1], 10);
-      if (sha && !isNaN(unixTimestamp)) {
-        const timestamp = new Date(unixTimestamp * 1e3).toISOString();
-        return { sha, timestamp };
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function getGitContext(rootPath) {
-  const cached = gitContextCache.get(rootPath);
-  if (cached) return cached;
-  const machineId = getMachineId();
-  const isRepo = await isGitRepo(rootPath);
-  if (!isRepo) {
-    const context2 = { isGitRepo: false, machineId };
-    gitContextCache.set(rootPath, context2);
-    return context2;
-  }
-  const [branch, defaultBranch] = await Promise.all([
-    getGitBranch(rootPath),
-    getGitDefaultBranch(rootPath)
-  ]);
-  const context = {
-    isGitRepo: true,
-    branch,
-    defaultBranch,
-    isDefaultBranch: branch !== void 0 && branch === defaultBranch,
-    machineId
-  };
-  gitContextCache.set(rootPath, context);
-  return context;
-}
-function clearGitContextCache() {
-  gitContextCache.clear();
-}
-async function readFilesFromDirectory(rootPath, options = {}) {
-  const maxFiles = options.maxFiles ?? MAX_FILES_PER_BATCH;
-  const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
-  const files = [];
-  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
-  const gitCtx = await getGitContext(rootPath);
-  async function walkDir(dir, relativePath = "") {
-    if (files.length >= maxFiles) return;
-    let entries;
-    try {
-      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (files.length >= maxFiles) break;
-      const fullPath = path2.join(dir, entry.name);
-      const relPath = path2.join(relativePath, entry.name);
-      if (entry.isDirectory()) {
-        if (IGNORE_DIRS.has(entry.name)) continue;
-        if (ig.ignores(relPath + "/")) continue;
-        await walkDir(fullPath, relPath);
-      } else if (entry.isFile()) {
-        if (IGNORE_FILES.has(entry.name)) continue;
-        if (ig.ignores(relPath)) continue;
-        const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (!CODE_EXTENSIONS.has(ext)) continue;
-        try {
-          const stat = await fs2.promises.stat(fullPath);
-          if (stat.size > maxFileSize) continue;
-          const content = await fs2.promises.readFile(fullPath, "utf-8");
-          const file = {
-            path: relPath,
-            content,
-            language: detectLanguage(relPath),
-            // Always include machine_id and source_modified_at
-            machine_id: gitCtx.machineId,
-            source_modified_at: stat.mtime.toISOString()
-          };
-          if (gitCtx.isGitRepo) {
-            file.git_branch = gitCtx.branch;
-            file.git_default_branch = gitCtx.defaultBranch;
-            file.is_default_branch = gitCtx.isDefaultBranch;
-            const gitInfo = await getFileGitInfo(rootPath, relPath);
-            if (gitInfo) {
-              file.git_commit_sha = gitInfo.sha;
-              file.git_commit_timestamp = gitInfo.timestamp;
-            }
-          }
-          files.push(file);
-        } catch {
-        }
-      }
-    }
-  }
-  await walkDir(rootPath);
-  return files;
-}
-async function* readAllFilesInBatches(rootPath, options = {}) {
-  const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
-  const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
-  const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
-  const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
-  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
-  const gitCtx = await getGitContext(rootPath);
-  let batch = [];
-  let currentBatchBytes = 0;
-  async function* walkDir(dir, relativePath = "") {
-    let entries;
-    try {
-      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      const relPath = path2.join(relativePath, entry.name);
-      if (entry.isDirectory()) {
-        if (IGNORE_DIRS.has(entry.name)) continue;
-        if (ig.ignores(relPath + "/")) continue;
-        yield* walkDir(fullPath, relPath);
-      } else if (entry.isFile()) {
-        if (IGNORE_FILES.has(entry.name)) continue;
-        if (ig.ignores(relPath)) continue;
-        const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (!CODE_EXTENSIONS.has(ext)) continue;
-        try {
-          const stat = await fs2.promises.stat(fullPath);
-          if (stat.size > maxFileSize) continue;
-          const content = await fs2.promises.readFile(fullPath, "utf-8");
-          const file = {
-            path: relPath,
-            content,
-            language: detectLanguage(relPath),
-            sizeBytes: stat.size,
-            // Always include machine_id and source_modified_at
-            machine_id: gitCtx.machineId,
-            source_modified_at: stat.mtime.toISOString()
-          };
-          if (gitCtx.isGitRepo) {
-            file.git_branch = gitCtx.branch;
-            file.git_default_branch = gitCtx.defaultBranch;
-            file.is_default_branch = gitCtx.isDefaultBranch;
-            const gitInfo = await getFileGitInfo(rootPath, relPath);
-            if (gitInfo) {
-              file.git_commit_sha = gitInfo.sha;
-              file.git_commit_timestamp = gitInfo.timestamp;
-            }
-          }
-          yield file;
-        } catch {
-        }
-      }
-    }
-  }
-  for await (const file of walkDir(rootPath)) {
-    if (file.sizeBytes > largeFileThreshold) {
-      if (batch.length > 0) {
-        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
-        batch = [];
-        currentBatchBytes = 0;
-      }
-      const { sizeBytes, ...fileData } = file;
-      yield [fileData];
-      continue;
-    }
-    const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
-    const wouldExceedFiles = batch.length >= maxFilesPerBatch;
-    if (wouldExceedBytes || wouldExceedFiles) {
-      if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
-        batch = [];
-        currentBatchBytes = 0;
-      }
-    }
-    batch.push(file);
-    currentBatchBytes += file.sizeBytes;
-  }
-  if (batch.length > 0) {
-    yield batch.map(({ sizeBytes, ...rest }) => rest);
-  }
-}
-async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}) {
-  const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
-  const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
-  const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
-  const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
-  const sinceMs = sinceTimestamp.getTime();
-  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
-  const gitCtx = await getGitContext(rootPath);
-  let batch = [];
-  let currentBatchBytes = 0;
-  let filesScanned = 0;
-  let filesChanged = 0;
-  async function* walkDir(dir, relativePath = "") {
-    let entries;
-    try {
-      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      const relPath = path2.join(relativePath, entry.name);
-      if (entry.isDirectory()) {
-        if (IGNORE_DIRS.has(entry.name)) continue;
-        if (ig.ignores(relPath + "/")) continue;
-        yield* walkDir(fullPath, relPath);
-      } else if (entry.isFile()) {
-        if (IGNORE_FILES.has(entry.name)) continue;
-        if (ig.ignores(relPath)) continue;
-        const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (!CODE_EXTENSIONS.has(ext)) continue;
-        try {
-          const stat = await fs2.promises.stat(fullPath);
-          filesScanned++;
-          if (stat.mtimeMs <= sinceMs) continue;
-          if (stat.size > maxFileSize) continue;
-          const content = await fs2.promises.readFile(fullPath, "utf-8");
-          filesChanged++;
-          const file = {
-            path: relPath,
-            content,
-            language: detectLanguage(relPath),
-            sizeBytes: stat.size,
-            // Always include machine_id and source_modified_at
-            machine_id: gitCtx.machineId,
-            source_modified_at: stat.mtime.toISOString()
-          };
-          if (gitCtx.isGitRepo) {
-            file.git_branch = gitCtx.branch;
-            file.git_default_branch = gitCtx.defaultBranch;
-            file.is_default_branch = gitCtx.isDefaultBranch;
-            const gitInfo = await getFileGitInfo(rootPath, relPath);
-            if (gitInfo) {
-              file.git_commit_sha = gitInfo.sha;
-              file.git_commit_timestamp = gitInfo.timestamp;
-            }
-          }
-          yield file;
-        } catch {
-        }
-      }
-    }
-  }
-  for await (const file of walkDir(rootPath)) {
-    if (file.sizeBytes > largeFileThreshold) {
-      if (batch.length > 0) {
-        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
-        batch = [];
-        currentBatchBytes = 0;
-      }
-      const { sizeBytes, ...fileData } = file;
-      yield [fileData];
-      continue;
-    }
-    const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
-    const wouldExceedFiles = batch.length >= maxFilesPerBatch;
-    if (wouldExceedBytes || wouldExceedFiles) {
-      if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
-        batch = [];
-        currentBatchBytes = 0;
-      }
-    }
-    batch.push(file);
-    currentBatchBytes += file.sizeBytes;
-  }
-  if (batch.length > 0) {
-    yield batch.map(({ sizeBytes, ...rest }) => rest);
-  }
-  console.error(
-    `[ContextStream] Incremental scan: ${filesChanged} changed files out of ${filesScanned} scanned (since ${sinceTimestamp.toISOString()})`
-  );
-}
-async function countIndexableFiles(rootPath, options = {}) {
-  const maxFiles = options.maxFiles ?? 1;
-  const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
-  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
-  let count = 0;
-  let stopped = false;
-  async function walkDir(dir, relativePath = "") {
-    if (count >= maxFiles) {
-      stopped = true;
-      return;
-    }
-    let entries;
-    try {
-      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (count >= maxFiles) {
-        stopped = true;
-        return;
-      }
-      const fullPath = path2.join(dir, entry.name);
-      const relPath = path2.join(relativePath, entry.name);
-      if (entry.isDirectory()) {
-        if (IGNORE_DIRS.has(entry.name)) continue;
-        if (ig.ignores(relPath + "/")) continue;
-        await walkDir(fullPath, relPath);
-      } else if (entry.isFile()) {
-        if (IGNORE_FILES.has(entry.name)) continue;
-        if (ig.ignores(relPath)) continue;
-        const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (!CODE_EXTENSIONS.has(ext)) continue;
-        try {
-          const stat = await fs2.promises.stat(fullPath);
-          if (stat.size > maxFileSize) continue;
-          count++;
-          if (count >= maxFiles) {
-            stopped = true;
-            return;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  await walkDir(rootPath);
-  return { count, stopped };
-}
-function detectLanguage(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
-  const langMap = {
-    rs: "rust",
-    ts: "typescript",
-    tsx: "typescript",
-    js: "javascript",
-    jsx: "javascript",
-    py: "python",
-    go: "go",
-    java: "java",
-    kt: "kotlin",
-    c: "c",
-    h: "c",
-    cpp: "cpp",
-    hpp: "cpp",
-    cs: "csharp",
-    rb: "ruby",
-    php: "php",
-    swift: "swift",
-    scala: "scala",
-    sql: "sql",
-    dart: "dart",
-    md: "markdown",
-    json: "json",
-    yaml: "yaml",
-    yml: "yaml",
-    toml: "toml",
-    html: "html",
-    css: "css",
-    sh: "shell"
-  };
-  return langMap[ext] ?? "unknown";
-}
-function sha256Hex(content) {
-  return crypto.createHash("sha256").update(content).digest("hex");
-}
-function hashManifestPath(projectId) {
-  return path2.join(os.homedir(), ".contextstream", "file-hashes", `${projectId}.json`);
-}
-function readHashManifest(projectId) {
-  try {
-    const content = fs2.readFileSync(hashManifestPath(projectId), "utf-8");
-    const parsed = JSON.parse(content);
-    return new Map(Object.entries(parsed));
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-}
-function writeHashManifest(projectId, hashes) {
-  const filePath = hashManifestPath(projectId);
-  try {
-    const dir = path2.dirname(filePath);
-    fs2.mkdirSync(dir, { recursive: true });
-    const obj = Object.fromEntries(hashes);
-    fs2.writeFileSync(filePath, JSON.stringify(obj, null, 2));
-  } catch {
-  }
-}
-function deleteHashManifest(projectId) {
-  try {
-    fs2.unlinkSync(hashManifestPath(projectId));
-  } catch {
-  }
-}
-var execAsync, CODE_EXTENSIONS, IGNORE_DIRS, IGNORE_FILES, MAX_FILE_SIZE, MAX_BATCH_BYTES, LARGE_FILE_THRESHOLD, MAX_FILES_PER_BATCH, gitContextCache;
-var init_files = __esm({
-  "src/files.ts"() {
-    "use strict";
-    init_ignore();
-    execAsync = promisify(exec);
-    CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-      // Rust
-      "rs",
-      // TypeScript/JavaScript
-      "ts",
-      "tsx",
-      "js",
-      "jsx",
-      "mjs",
-      "cjs",
-      // Python
-      "py",
-      "pyi",
-      // Go
-      "go",
-      // Java/Kotlin
-      "java",
-      "kt",
-      "kts",
-      // C/C++
-      "c",
-      "h",
-      "cpp",
-      "hpp",
-      "cc",
-      "cxx",
-      // C#
-      "cs",
-      // Ruby
-      "rb",
-      // PHP
-      "php",
-      // Swift
-      "swift",
-      // Scala
-      "scala",
-      // Shell
-      "sh",
-      "bash",
-      "zsh",
-      // Config/Data
-      "json",
-      "yaml",
-      "yml",
-      "toml",
-      "xml",
-      // SQL
-      "sql",
-      // Markdown/Docs
-      "md",
-      "markdown",
-      "rst",
-      "txt",
-      // HTML/CSS
-      "html",
-      "htm",
-      "css",
-      "scss",
-      "sass",
-      "less",
-      // Other
-      "graphql",
-      "proto",
-      "dockerfile",
-      // Dart/Flutter
-      "dart"
-    ]);
-    IGNORE_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      ".git",
-      ".svn",
-      ".hg",
-      "target",
-      "dist",
-      "build",
-      "out",
-      ".next",
-      ".nuxt",
-      ".svelte-kit",
-      ".parcel-cache",
-      ".turbo",
-      ".gradle",
-      ".cache",
-      "__pycache__",
-      ".pytest_cache",
-      ".mypy_cache",
-      "venv",
-      ".venv",
-      "env",
-      ".env",
-      "vendor",
-      "coverage",
-      ".coverage",
-      "bin",
-      "obj",
-      ".idea",
-      ".vscode",
-      ".vs"
-    ]);
-    IGNORE_FILES = /* @__PURE__ */ new Set([
-      ".DS_Store",
-      "Thumbs.db",
-      ".gitignore",
-      ".gitattributes",
-      "package-lock.json",
-      "yarn.lock",
-      "pnpm-lock.yaml",
-      "Cargo.lock",
-      "poetry.lock",
-      "Gemfile.lock",
-      "composer.lock"
-    ]);
-    MAX_FILE_SIZE = 5 * 1024 * 1024;
-    MAX_BATCH_BYTES = 1024 * 1024;
-    LARGE_FILE_THRESHOLD = 2 * 1024 * 1024;
-    MAX_FILES_PER_BATCH = 20;
-    gitContextCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/hooks-config.ts
-var hooks_config_exports = {};
-__export(hooks_config_exports, {
-  CLAUDE_ENFORCEMENT_CRITICAL_HOOKS: () => CLAUDE_ENFORCEMENT_CRITICAL_HOOKS,
-  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_ENFORCEMENT_CRITICAL_HOOKS: () => CURSOR_ENFORCEMENT_CRITICAL_HOOKS,
-  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,
-  clearProjectIndex: () => clearProjectIndex,
-  generateAllHooksDocumentation: () => generateAllHooksDocumentation,
-  generateHooksDocumentation: () => generateHooksDocumentation,
-  getClaudeSettingsPath: () => getClaudeSettingsPath,
-  getClineHooksDir: () => getClineHooksDir,
-  getCursorHooksConfigPath: () => getCursorHooksConfigPath,
-  getCursorHooksDir: () => getCursorHooksDir,
-  getHookCommand: () => getHookCommand,
-  getHooksDir: () => getHooksDir,
-  getIndexStatusPath: () => getIndexStatusPath,
-  getKiloCodeHooksDir: () => getKiloCodeHooksDir,
-  getRooCodeHooksDir: () => getRooCodeHooksDir,
-  getWindsurfHooksConfigPath: () => getWindsurfHooksConfigPath,
-  installAllEditorHooks: () => installAllEditorHooks,
-  installClaudeCodeHooks: () => installClaudeCodeHooks,
-  installClineHookScripts: () => installClineHookScripts,
-  installCursorHookScripts: () => installCursorHookScripts,
-  installEditorHooks: () => installEditorHooks,
-  installHookScripts: () => installHookScripts,
-  installKiloCodeHookScripts: () => installKiloCodeHookScripts,
-  installRooCodeHookScripts: () => installRooCodeHookScripts,
-  installWindsurfHookScripts: () => installWindsurfHookScripts,
-  markProjectIndexed: () => markProjectIndexed,
-  mergeHooksIntoSettings: () => mergeHooksIntoSettings,
-  readClaudeSettings: () => readClaudeSettings,
-  readCursorHooksConfig: () => readCursorHooksConfig,
-  readIndexStatus: () => readIndexStatus,
-  readWindsurfHooksConfig: () => readWindsurfHooksConfig,
-  unmarkProjectIndexed: () => unmarkProjectIndexed,
-  writeClaudeSettings: () => writeClaudeSettings,
-  writeCursorHooksConfig: () => writeCursorHooksConfig,
-  writeIndexStatus: () => writeIndexStatus,
-  writeWindsurfHooksConfig: () => writeWindsurfHooksConfig
-});
-import * as fs3 from "node:fs/promises";
-import * as fsSync from "node:fs";
-import * as path3 from "node:path";
-import { homedir as homedir2 } from "node:os";
-import { fileURLToPath } from "node:url";
-function getHookCommand(hookName) {
-  const isWindows = process.platform === "win32";
-  if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA;
-    if (localAppData) {
-      const windowsBinaryPath = path3.join(localAppData, "ContextStream", "contextstream-mcp.exe");
-      if (fsSync.existsSync(windowsBinaryPath)) {
-        return `"${windowsBinaryPath}" hook ${hookName}`;
-      }
-    }
-  } else {
-    const unixBinaryPath = "/usr/local/bin/contextstream-mcp";
-    if (fsSync.existsSync(unixBinaryPath)) {
-      return `${unixBinaryPath} hook ${hookName}`;
-    }
-  }
-  try {
-    const __dirname = path3.dirname(fileURLToPath(import.meta.url));
-    const indexPath = path3.join(__dirname, "index.js");
-    if (fsSync.existsSync(indexPath)) {
-      return `node "${indexPath}" hook ${hookName}`;
-    }
-  } catch {
-  }
-  return `npx @contextstream/mcp-server hook ${hookName}`;
-}
-function getClaudeSettingsPath(scope, projectPath) {
-  if (scope === "user") {
-    return path3.join(homedir2(), ".claude", "settings.json");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".claude", "settings.json");
-}
-function getHooksDir() {
-  return path3.join(homedir2(), ".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 === true) {
-    userPromptHooks.push({
-      matcher: "*",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("media-aware"),
-          timeout: 5
-        }
-      ]
-    });
-  }
-  const config = {
-    PreToolUse: [
-      {
-        matcher: "*",
-        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
-          }
-        ]
-      }
-    ];
-    config.PostCompact = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("post-compact"),
-            timeout: 15
-          }
-        ]
-      }
-    ];
-  }
-  if (options?.includeSessionInit !== false) {
-    config.SessionStart = [
-      {
-        matcher: "startup|resume|compact",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("session-start"),
-            timeout: 15
-          }
-        ]
-      }
-    ];
-    config.InstructionsLoaded = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("instructions-loaded"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.ConfigChange = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("config-change"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.CwdChanged = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("cwd-changed"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.FileChanged = [
-      {
-        matcher: ".*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("file-changed"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.WorktreeCreate = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("worktree-create"),
-            timeout: 15
-          }
-        ]
-      }
-    ];
-    config.WorktreeRemove = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("worktree-remove"),
-            timeout: 15
-          }
-        ]
-      }
-    ];
-    config.Elicitation = [
-      {
-        matcher: ".*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("elicitation"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.ElicitationResult = [
-      {
-        matcher: ".*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("elicitation-result"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-  }
-  if (options?.includeSessionEnd !== false) {
-    config.Stop = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("stop"),
-            timeout: 15
-          }
-        ]
-      }
-    ];
-    config.SessionEnd = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("session-end"),
-            timeout: 10
-          }
-        ]
-      }
-    ];
-    config.StopFailure = [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: getHookCommand("stop-failure"),
-            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 === true) {
-    postToolUseHooks.push({
-      matcher: "mcp__contextstream__init|mcp__contextstream__context",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("auto-rules"),
-          timeout: 15
-        }
-      ]
-    });
-  }
-  if (options?.includeOnBash === true) {
-    postToolUseHooks.push({
-      matcher: "Bash",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("on-bash"),
-          timeout: 5
-        }
-      ]
-    });
-  }
-  if (options?.includeOnTask === true) {
-    postToolUseHooks.push({
-      matcher: "Task",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("on-task"),
-          timeout: 5
-        }
-      ]
-    });
-  }
-  if (options?.includeOnRead === true) {
-    postToolUseHooks.push({
-      matcher: "Read|Glob|Grep",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("on-read"),
-          timeout: 5
-        }
-      ]
-    });
-  }
-  if (options?.includeOnWeb === true) {
-    postToolUseHooks.push({
-      matcher: "WebFetch|WebSearch",
-      hooks: [
-        {
-          type: "command",
-          command: getHookCommand("on-web"),
-          timeout: 5
-        }
-      ]
-    });
-  }
-  if (postToolUseHooks.length > 0) {
-    config.PostToolUse = postToolUseHooks;
-  }
-  config.PostToolUseFailure = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("post-tool-use-failure"), timeout: 10 }]
-    }
-  ];
-  config.SubagentStart = [
-    {
-      matcher: "Explore|Plan|general-purpose|custom",
-      hooks: [{ type: "command", command: getHookCommand("subagent-start"), timeout: 10 }]
-    }
-  ];
-  config.SubagentStop = [
-    {
-      matcher: "Plan",
-      hooks: [{ type: "command", command: getHookCommand("subagent-stop"), timeout: 15 }]
-    }
-  ];
-  config.TaskCreated = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("task-created"), timeout: 10 }]
-    }
-  ];
-  config.TaskCompleted = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("task-completed"), timeout: 10 }]
-    }
-  ];
-  config.TeammateIdle = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("teammate-idle"), timeout: 10 }]
-    }
-  ];
-  config.Notification = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("notification"), timeout: 10 }]
-    }
-  ];
-  config.PermissionRequest = [
-    {
-      matcher: "*",
-      hooks: [{ type: "command", command: getHookCommand("permission-request"), timeout: 10 }]
-    }
-  ];
-  return config;
-}
-async function installHookScripts(options) {
-  const hooksDir = getHooksDir();
-  await fs3.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 fs3.readFile(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function writeClaudeSettings(settings, scope, projectPath) {
-  const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path3.dirname(settingsPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.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"),
-    getHookCommand("on-save-intent"),
-    getHookCommand("session-start"),
-    getHookCommand("instructions-loaded"),
-    getHookCommand("config-change"),
-    getHookCommand("cwd-changed"),
-    getHookCommand("file-changed"),
-    getHookCommand("worktree-create"),
-    getHookCommand("worktree-remove"),
-    getHookCommand("elicitation"),
-    getHookCommand("elicitation-result"),
-    getHookCommand("stop"),
-    getHookCommand("stop-failure"),
-    getHookCommand("session-end"),
-    getHookCommand("post-tool-use-failure"),
-    getHookCommand("subagent-start"),
-    getHookCommand("subagent-stop"),
-    getHookCommand("task-created"),
-    getHookCommand("task-completed"),
-    getHookCommand("teammate-idle"),
-    getHookCommand("notification"),
-    getHookCommand("permission-request")
-  );
-  if (options.includePreCompact !== false) {
-    result.scripts.push(getHookCommand("pre-compact"));
-    result.scripts.push(getHookCommand("post-compact"));
-  }
-  if (options.includeMediaAware === true) {
-    result.scripts.push(getHookCommand("media-aware"));
-  }
-  if (options.includePostWrite !== false) {
-    result.scripts.push(getHookCommand("post-write"));
-  }
-  if (options.includeAutoRules === true) {
-    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/Explore/Task/EnterPlanMode and redirects to ContextStream
-- **Blocked tools:** Glob, Grep, Search, Explore, 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|Explore|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 path3.join(homedir2(), ".contextstream", "indexed-projects.json");
-}
-async function readIndexStatus() {
-  const statusPath = getIndexStatusPath();
-  try {
-    const content = await fs3.readFile(statusPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { version: 1, projects: {} };
-  }
-}
-async function writeIndexStatus(status) {
-  const statusPath = getIndexStatusPath();
-  const dir = path3.dirname(statusPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(statusPath, JSON.stringify(status, null, 2));
-}
-async function markProjectIndexed(projectPath, options) {
-  const status = await readIndexStatus();
-  const resolvedPath = path3.resolve(projectPath);
-  const previous = status.projects[resolvedPath];
-  status.projects[resolvedPath] = {
-    indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
-    project_id: options?.project_id ?? previous?.project_id,
-    project_name: options?.project_name ?? previous?.project_name,
-    git_head: options?.git_head ?? previous?.git_head,
-    git_remote: options?.git_remote ?? previous?.git_remote
-  };
-  await writeIndexStatus(status);
-}
-async function unmarkProjectIndexed(projectPath) {
-  const status = await readIndexStatus();
-  const resolvedPath = path3.resolve(projectPath);
-  delete status.projects[resolvedPath];
-  await writeIndexStatus(status);
-}
-async function clearProjectIndex(projectPath, projectId) {
-  await unmarkProjectIndexed(projectPath);
-  if (projectId) {
-    const { deleteHashManifest: deleteHashManifest2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-    deleteHashManifest2(projectId);
-  }
-}
-function getClineHooksDir(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), "Documents", "Cline", "Rules", "Hooks");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".clinerules", "hooks");
-}
-function getHookWrapperScript(hookName) {
-  const isWindows = process.platform === "win32";
-  const command = getHookCommand(hookName);
-  if (isWindows) {
-    return {
-      content: `@echo off\r
-${command}\r
-`,
-      extension: ".cmd"
-    };
-  } else {
-    return {
-      content: `#!/bin/bash
-# ContextStream ${hookName} Hook Wrapper for Cline/Roo/Kilo Code
-exec ${command}
-`,
-      extension: ""
-    };
-  }
-}
-async function installClineHookScripts(options) {
-  const hooksDir = getClineHooksDir(options.scope, options.projectPath);
-  await fs3.mkdir(hooksDir, { recursive: true });
-  const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
-  const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
-  const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path3.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path3.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path3.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs3.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs3.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
-  const result = {
-    preToolUse: preToolUsePath,
-    userPromptSubmit: userPromptPath
-  };
-  if (options.includePostWrite !== false) {
-    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
-    result.postToolUse = postToolUsePath;
-  }
-  return result;
-}
-function getRooCodeHooksDir(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), ".roo", "hooks");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".roo", "hooks");
-}
-async function installRooCodeHookScripts(options) {
-  const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
-  await fs3.mkdir(hooksDir, { recursive: true });
-  const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
-  const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
-  const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path3.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path3.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path3.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs3.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs3.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
-  const result = {
-    preToolUse: preToolUsePath,
-    userPromptSubmit: userPromptPath
-  };
-  if (options.includePostWrite !== false) {
-    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
-    result.postToolUse = postToolUsePath;
-  }
-  return result;
-}
-function getKiloCodeHooksDir(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), ".kilocode", "hooks");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".kilocode", "hooks");
-}
-async function installKiloCodeHookScripts(options) {
-  const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
-  await fs3.mkdir(hooksDir, { recursive: true });
-  const preToolUseWrapper = getHookWrapperScript("pre-tool-use");
-  const userPromptWrapper = getHookWrapperScript("user-prompt-submit");
-  const postWriteWrapper = getHookWrapperScript("post-write");
-  const preToolUsePath = path3.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path3.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path3.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs3.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs3.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
-  const result = {
-    preToolUse: preToolUsePath,
-    userPromptSubmit: userPromptPath
-  };
-  if (options.includePostWrite !== false) {
-    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
-    result.postToolUse = postToolUsePath;
-  }
-  return result;
-}
-function getCursorHooksConfigPath(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), ".cursor", "hooks.json");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".cursor", "hooks.json");
-}
-function getCursorHooksDir(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), ".cursor", "hooks");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".cursor", "hooks");
-}
-function getWindsurfHooksConfigPath(scope, projectPath) {
-  if (scope === "global") {
-    return path3.join(homedir2(), ".codeium", "windsurf", "hooks.json");
-  }
-  if (!projectPath) {
-    throw new Error("projectPath required for project scope");
-  }
-  return path3.join(projectPath, ".windsurf", "hooks.json");
-}
-async function readCursorHooksConfig(scope, projectPath) {
-  const configPath = getCursorHooksConfigPath(scope, projectPath);
-  try {
-    const content = await fs3.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 = path3.dirname(configPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(configPath, JSON.stringify(config, null, 2));
-}
-async function installCursorHookScripts(options) {
-  const hooksDir = getCursorHooksDir(options.scope, options.projectPath);
-  await fs3.mkdir(hooksDir, { recursive: true });
-  const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
-  const filterContextStreamHooks = (hooks) => {
-    if (!hooks) return [];
-    return hooks.filter((h) => {
-      const hook = h;
-      return !hook.command?.includes("contextstream");
-    });
-  };
-  const cleanedHooks = {};
-  for (const [eventName, entries] of Object.entries(existingConfig.hooks || {})) {
-    cleanedHooks[eventName] = filterContextStreamHooks(entries);
-  }
-  const cursorHookCommand = (name) => `${getHookCommand(name)} --editor=cursor`;
-  const preToolUseCommand = cursorHookCommand("pre-tool-use");
-  const userPromptCommand = cursorHookCommand("user-prompt-submit");
-  const saveIntentCommand = cursorHookCommand("on-save-intent");
-  const postToolUseCommand = cursorHookCommand("post-tool-use");
-  const postToolUseFailureCommand = cursorHookCommand("post-tool-use-failure");
-  const preCompactCommand = cursorHookCommand("pre-compact");
-  const sessionStartCommand = cursorHookCommand("session-start");
-  const sessionEndCommand = cursorHookCommand("session-end");
-  const stopCommand = cursorHookCommand("stop");
-  const notificationCommand = cursorHookCommand("notification");
-  const permissionRequestCommand = cursorHookCommand("permission-request");
-  const subagentStartCommand = cursorHookCommand("subagent-start");
-  const subagentStopCommand = cursorHookCommand("subagent-stop");
-  const taskCompletedCommand = cursorHookCommand("task-completed");
-  const teammateIdleCommand = cursorHookCommand("teammate-idle");
-  const config = {
-    version: 1,
-    hooks: {
-      ...cleanedHooks,
-      preToolUse: [
-        ...cleanedHooks.preToolUse || [],
-        {
-          command: preToolUseCommand,
-          type: "command",
-          timeout: 5
-        }
-      ],
-      beforeSubmitPrompt: [
-        ...cleanedHooks.beforeSubmitPrompt || [],
-        {
-          command: userPromptCommand,
-          type: "command",
-          timeout: 5
-        },
-        {
-          command: saveIntentCommand,
-          type: "command",
-          timeout: 5
-        }
-      ],
-      beforeMCPExecution: [
-        ...cleanedHooks.beforeMCPExecution || [],
-        { command: preToolUseCommand, type: "command", timeout: 5 }
-      ],
-      afterMCPExecution: [
-        ...cleanedHooks.afterMCPExecution || [],
-        { command: postToolUseCommand, type: "command", timeout: 10 }
-      ],
-      beforeShellExecution: [
-        ...cleanedHooks.beforeShellExecution || [],
-        { command: preToolUseCommand, type: "command", timeout: 5 }
-      ],
-      afterShellExecution: [
-        ...cleanedHooks.afterShellExecution || [],
-        { command: postToolUseFailureCommand, type: "command", timeout: 10 }
-      ],
-      beforeReadFile: [
-        ...cleanedHooks.beforeReadFile || [],
-        { command: preToolUseCommand, type: "command", timeout: 5 }
-      ],
-      afterFileEdit: [
-        ...cleanedHooks.afterFileEdit || [],
-        { command: postToolUseCommand, type: "command", timeout: 10 }
-      ],
-      preCompact: [
-        ...cleanedHooks.preCompact || [],
-        { command: preCompactCommand, type: "command", timeout: 15 }
-      ],
-      sessionStart: [
-        ...cleanedHooks.sessionStart || [],
-        { command: sessionStartCommand, type: "command", timeout: 15 }
-      ],
-      sessionEnd: [
-        ...cleanedHooks.sessionEnd || [],
-        { command: sessionEndCommand, type: "command", timeout: 10 }
-      ],
-      stop: [
-        ...cleanedHooks.stop || [],
-        { command: stopCommand, type: "command", timeout: 15 }
-      ],
-      subagentStart: [
-        ...cleanedHooks.subagentStart || [],
-        { command: subagentStartCommand, type: "command", timeout: 10 }
-      ],
-      subagentStop: [
-        ...cleanedHooks.subagentStop || [],
-        { command: subagentStopCommand, type: "command", timeout: 10 }
-      ],
-      taskCompleted: [
-        ...cleanedHooks.taskCompleted || [],
-        { command: taskCompletedCommand, type: "command", timeout: 10 }
-      ],
-      teammateIdle: [
-        ...cleanedHooks.teammateIdle || [],
-        { command: teammateIdleCommand, type: "command", timeout: 10 }
-      ],
-      notification: [
-        ...cleanedHooks.notification || [],
-        { command: notificationCommand, type: "command", timeout: 10 }
-      ],
-      permissionRequest: [
-        ...cleanedHooks.permissionRequest || [],
-        { command: permissionRequestCommand, type: "command", timeout: 10 }
-      ]
-    }
-  };
-  await writeCursorHooksConfig(config, options.scope, options.projectPath);
-  const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
-  return {
-    preToolUse: preToolUseCommand,
-    beforeSubmitPrompt: `${userPromptCommand}, ${saveIntentCommand}`,
-    config: configPath
-  };
-}
-async function readWindsurfHooksConfig(scope, projectPath) {
-  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
-  try {
-    const content = await fs3.readFile(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return { hooks: {} };
-  }
-}
-async function writeWindsurfHooksConfig(config, scope, projectPath) {
-  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
-  const dir = path3.dirname(configPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(configPath, JSON.stringify(config, null, 2));
-}
-async function installWindsurfHookScripts(options) {
-  const existingConfig = await readWindsurfHooksConfig(options.scope, options.projectPath);
-  const filterContextStreamHooks = (hooks) => {
-    if (!hooks) return [];
-    return hooks.filter((h) => {
-      const hook = h;
-      return !hook.command?.toLowerCase().includes("contextstream");
-    });
-  };
-  const cleanedHooks = {};
-  for (const [eventName, entries] of Object.entries(existingConfig.hooks || {})) {
-    cleanedHooks[eventName] = filterContextStreamHooks(entries);
-  }
-  const preToolUseCommand = getHookCommand("pre-tool-use");
-  const userPromptCommand = getHookCommand("user-prompt-submit");
-  const postToolUseCommand = getHookCommand("post-tool-use");
-  const sessionEndCommand = getHookCommand("session-end");
-  const config = {
-    hooks: {
-      ...cleanedHooks,
-      pre_mcp_tool_use: [
-        ...cleanedHooks.pre_mcp_tool_use || [],
-        { command: preToolUseCommand, show_output: true }
-      ],
-      pre_user_prompt: [
-        ...cleanedHooks.pre_user_prompt || [],
-        { command: userPromptCommand }
-      ],
-      pre_read_code: [
-        ...cleanedHooks.pre_read_code || [],
-        { command: preToolUseCommand, show_output: true }
-      ],
-      pre_write_code: [
-        ...cleanedHooks.pre_write_code || [],
-        { command: preToolUseCommand, show_output: true }
-      ],
-      pre_run_command: [
-        ...cleanedHooks.pre_run_command || [],
-        { command: preToolUseCommand, show_output: true }
-      ],
-      post_write_code: [
-        ...cleanedHooks.post_write_code || [],
-        { command: postToolUseCommand, show_output: false }
-      ],
-      post_mcp_tool_use: [
-        ...cleanedHooks.post_mcp_tool_use || [],
-        { command: postToolUseCommand, show_output: false }
-      ],
-      post_cascade_response_with_transcript: [
-        ...cleanedHooks.post_cascade_response_with_transcript || [],
-        { command: sessionEndCommand }
-      ]
-    }
-  };
-  await writeWindsurfHooksConfig(config, options.scope, options.projectPath);
-  const configPath = getWindsurfHooksConfigPath(options.scope, options.projectPath);
-  return {
-    preMcpToolUse: preToolUseCommand,
-    preUserPrompt: 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)
-      };
-    }
-    case "windsurf": {
-      const scripts = await installWindsurfHookScripts({ scope, projectPath });
-      return {
-        editor: "windsurf",
-        installed: [scripts.preMcpToolUse, scripts.preUserPrompt, scripts.config],
-        hooksDir: path3.dirname(scripts.config)
-      };
-    }
-    default:
-      throw new Error(`Unsupported editor: ${editor}`);
-  }
-}
-async function installAllEditorHooks(options) {
-  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor", "windsurf"];
-  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, SessionStart, Pre/PostCompact, PostToolUse |
-| **Cursor** | \`~/.cursor/hooks/\` | preToolUse, beforeSubmitPrompt, before/after MCP+Shell, beforeReadFile, afterFileEdit |
-| **Windsurf** | \`~/.codeium/windsurf/hooks.json\` | pre_mcp_tool_use, pre_user_prompt, pre/post code + command hooks |
-| **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 with enforcement + lifecycle hooks:
-- **preToolUse / beforeMCPExecution / beforeShellExecution / beforeReadFile**: blocks or redirects non-ContextStream-first flows
-- **beforeSubmitPrompt**: injects ContextStream rules reminder + save-intent capture
-- **afterMCPExecution / afterShellExecution / afterFileEdit**: post-action bookkeeping/index updates
-- **sessionStart / preCompact / stop / sessionEnd**: lifecycle persistence and reliability
-
-### Windsurf Hooks
-
-Windsurf uses a \`hooks.json\` configuration file:
-- **pre_mcp_tool_use / pre_read_code / pre_write_code / pre_run_command**: pre-action gating and enforcement
-- **pre_user_prompt**: injects ContextStream-first guidance each prompt
-- **post_write_code / post_mcp_tool_use**: post-action indexing bookkeeping
-- **post_cascade_response_with_transcript**: end-of-response/session capture
-
-#### 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", "windsurf", "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, CLAUDE_ENFORCEMENT_CRITICAL_HOOKS, CURSOR_ENFORCEMENT_CRITICAL_HOOKS, CLINE_PRETOOLUSE_HOOK_SCRIPT, CLINE_USER_PROMPT_HOOK_SCRIPT, CLINE_POSTTOOLUSE_HOOK_SCRIPT, 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/Explore/Task(Explore|Plan)/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=\\"auto\\", 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=\\"auto\\", query=\\"{pattern}\\") instead of {tool}.", file=sys.stderr)
-            sys.exit(2)
-
-    elif tool == "Explore":
-        print("STOP: Use mcp__contextstream__search(mode=\\"auto\\", output_format=\\"paths\\") instead of Explore.", file=sys.stderr)
-        sys.exit(2)
-
-    elif tool == "Task":
-        subagent = inp.get("subagent_type", "") or inp.get("subagentType", "")
-        subagent = subagent.lower()
-        if "explore" in subagent:
-            print("STOP: Use mcp__contextstream__search(mode=\\"auto\\") instead of Task(Explore).", file=sys.stderr)
-            sys.exit(2)
-        if "plan" in subagent:
-            print("STOP: For planning, use mcp__contextstream__search(mode=\\"auto\\", output_format=\\"paths\\") for discovery and mcp__contextstream__session(action=\\"capture_plan\\") for persistence.", 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="auto") 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()
-`;
-    CLAUDE_ENFORCEMENT_CRITICAL_HOOKS = [
-      "PreToolUse",
-      "UserPromptSubmit",
-      "SessionStart",
-      "PreCompact",
-      "PostToolUse"
-    ];
-    CURSOR_ENFORCEMENT_CRITICAL_HOOKS = [
-      "preToolUse",
-      "beforeSubmitPrompt",
-      "beforeMCPExecution",
-      "beforeShellExecution",
-      "beforeReadFile",
-      "afterFileEdit",
-      "sessionStart",
-      "preCompact"
-    ];
-    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=\\"auto\\", 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="auto") 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
-`;
-    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=\\"auto\\", 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
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-import { homedir as homedir3 } from "node:os";
-var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
-var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
-var ENABLED = process.env.CONTEXTSTREAM_AUTO_RULES !== "false";
-var MARKER_FILE = path4.join(homedir3(), ".contextstream", ".auto-rules-ran");
-var COOLDOWN_MS = 4 * 60 * 60 * 1e3;
-function hasRunRecently() {
-  try {
-    if (!fs4.existsSync(MARKER_FILE)) return false;
-    const stat = fs4.statSync(MARKER_FILE);
-    const age = Date.now() - stat.mtimeMs;
-    return age < COOLDOWN_MS;
-  } catch {
-    return false;
-  }
-}
-function markAsRan() {
-  try {
-    const dir = path4.dirname(MARKER_FILE);
-    if (!fs4.existsSync(dir)) {
-      fs4.mkdirSync(dir, { recursive: true });
-    }
-    fs4.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 extractCwd(input) {
-  if (input.cwd) return input.cwd;
-  return process.cwd();
-}
-function hasPythonHooks(settingsPath) {
-  try {
-    if (!fs4.existsSync(settingsPath)) return false;
-    const content = fs4.readFileSync(settingsPath, "utf-8");
-    const settings = JSON.parse(content);
-    const hooks = settings.hooks;
-    if (!hooks) return false;
-    for (const hookType of Object.keys(hooks)) {
-      const matchers = hooks[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 = path4.join(homedir3(), ".claude", "settings.json");
-  const projectSettingsPath = path4.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 (!ENABLED) {
-    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 = extractCwd(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 isDirectRun = process.argv[1]?.includes("auto-rules") || process.argv[2] === "auto-rules";
-if (isDirectRun) {
-  runAutoRulesHook().catch(() => process.exit(0));
-}
-export {
-  runAutoRulesHook
-};