@contextstream/mcp-server 0.4.60 → 0.4.61

package/dist/hooks/auto-rules.js

@@ -1,13 +1,1157 @@
 #!/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/",
+      // 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",
+      // 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;
+    }
+    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,
+            // 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;
+    }
+    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,
+            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;
+    }
+    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,
+            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;
+    }
+    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",
+    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"
+    ]);
+    IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".svn",
+      ".hg",
+      "target",
+      "dist",
+      "build",
+      "out",
+      ".next",
+      ".nuxt",
+      "__pycache__",
+      ".pytest_cache",
+      ".mypy_cache",
+      "venv",
+      ".venv",
+      "env",
+      ".env",
+      "vendor",
+      "coverage",
+      ".coverage",
+      ".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 = 1024 * 1024;
+    MAX_BATCH_BYTES = 10 * 1024 * 1024;
+    LARGE_FILE_THRESHOLD = 2 * 1024 * 1024;
+    MAX_FILES_PER_BATCH = 200;
+    gitContextCache = /* @__PURE__ */ new Map();
+  }
+});
 
 // src/hooks-config.ts
 var hooks_config_exports = {};
@@ -22,6 +1166,7 @@ __export(hooks_config_exports, {
   PRETOOLUSE_HOOK_SCRIPT: () => PRETOOLUSE_HOOK_SCRIPT,
   USER_PROMPT_HOOK_SCRIPT: () => USER_PROMPT_HOOK_SCRIPT,
   buildHooksConfig: () => buildHooksConfig,
+  clearProjectIndex: () => clearProjectIndex,
   generateAllHooksDocumentation: () => generateAllHooksDocumentation,
   generateHooksDocumentation: () => generateHooksDocumentation,
   getClaudeSettingsPath: () => getClaudeSettingsPath,
@@ -51,17 +1196,17 @@ __export(hooks_config_exports, {
   writeCursorHooksConfig: () => writeCursorHooksConfig,
   writeIndexStatus: () => writeIndexStatus
 });
-import * as fs from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as fsSync from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
+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 = path.join(localAppData, "ContextStream", "contextstream-mcp.exe");
+      const windowsBinaryPath = path3.join(localAppData, "ContextStream", "contextstream-mcp.exe");
       if (fsSync.existsSync(windowsBinaryPath)) {
         return `"${windowsBinaryPath}" hook ${hookName}`;
       }
@@ -73,8 +1218,8 @@ function getHookCommand(hookName) {
     }
   }
   try {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const indexPath = path.join(__dirname, "index.js");
+    const __dirname = path3.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path3.join(__dirname, "index.js");
     if (fsSync.existsSync(indexPath)) {
       return `node "${indexPath}" hook ${hookName}`;
     }
@@ -84,15 +1229,15 @@ function getHookCommand(hookName) {
 }
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
-    return path.join(homedir(), ".claude", "settings.json");
+    return path3.join(homedir2(), ".claude", "settings.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".claude", "settings.json");
+  return path3.join(projectPath, ".claude", "settings.json");
 }
 function getHooksDir() {
-  return path.join(homedir(), ".claude", "hooks");
+  return path3.join(homedir2(), ".claude", "hooks");
 }
 function buildHooksConfig(options) {
   const userPromptHooks = [
@@ -268,7 +1413,7 @@ function buildHooksConfig(options) {
 }
 async function installHookScripts(options) {
   const hooksDir = getHooksDir();
-  await fs.mkdir(hooksDir, { recursive: true });
+  await fs3.mkdir(hooksDir, { recursive: true });
   const result = {
     preToolUse: getHookCommand("pre-tool-use"),
     userPrompt: getHookCommand("user-prompt-submit")
@@ -287,7 +1432,7 @@ async function installHookScripts(options) {
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const content = await fs.readFile(settingsPath, "utf-8");
+    const content = await fs3.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -295,9 +1440,9 @@ async function readClaudeSettings(scope, projectPath) {
 }
 async function writeClaudeSettings(settings, scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path.dirname(settingsPath);
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  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 };
@@ -447,12 +1592,12 @@ If you prefer to configure manually, add to \`~/.claude/settings.json\`:
 `.trim();
 }
 function getIndexStatusPath() {
-  return path.join(homedir(), ".contextstream", "indexed-projects.json");
+  return path3.join(homedir2(), ".contextstream", "indexed-projects.json");
 }
 async function readIndexStatus() {
   const statusPath = getIndexStatusPath();
   try {
-    const content = await fs.readFile(statusPath, "utf-8");
+    const content = await fs3.readFile(statusPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, projects: {} };
@@ -460,13 +1605,13 @@ async function readIndexStatus() {
 }
 async function writeIndexStatus(status) {
   const statusPath = getIndexStatusPath();
-  const dir = path.dirname(statusPath);
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(statusPath, JSON.stringify(status, null, 2));
+  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 = path.resolve(projectPath);
+  const resolvedPath = path3.resolve(projectPath);
   status.projects[resolvedPath] = {
     indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_id: options?.project_id,
@@ -476,18 +1621,25 @@ async function markProjectIndexed(projectPath, options) {
 }
 async function unmarkProjectIndexed(projectPath) {
   const status = await readIndexStatus();
-  const resolvedPath = path.resolve(projectPath);
+  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 path.join(homedir(), "Documents", "Cline", "Rules", "Hooks");
+    return path3.join(homedir2(), "Documents", "Cline", "Rules", "Hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".clinerules", "hooks");
+  return path3.join(projectPath, ".clinerules", "hooks");
 }
 function getHookWrapperScript(hookName) {
   const isWindows = process.platform === "win32";
@@ -511,107 +1663,107 @@ exec ${command}
 }
 async function installClineHookScripts(options) {
   const hooksDir = getClineHooksDir(options.scope, options.projectPath);
-  await fs.mkdir(hooksDir, { recursive: true });
+  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 = path.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  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 fs.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getRooCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path.join(homedir(), ".roo", "hooks");
+    return path3.join(homedir2(), ".roo", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".roo", "hooks");
+  return path3.join(projectPath, ".roo", "hooks");
 }
 async function installRooCodeHookScripts(options) {
   const hooksDir = getRooCodeHooksDir(options.scope, options.projectPath);
-  await fs.mkdir(hooksDir, { recursive: true });
+  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 = path.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  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 fs.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getKiloCodeHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path.join(homedir(), ".kilocode", "hooks");
+    return path3.join(homedir2(), ".kilocode", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".kilocode", "hooks");
+  return path3.join(projectPath, ".kilocode", "hooks");
 }
 async function installKiloCodeHookScripts(options) {
   const hooksDir = getKiloCodeHooksDir(options.scope, options.projectPath);
-  await fs.mkdir(hooksDir, { recursive: true });
+  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 = path.join(hooksDir, `PreToolUse${preToolUseWrapper.extension}`);
-  const userPromptPath = path.join(hooksDir, `UserPromptSubmit${userPromptWrapper.extension}`);
-  const postToolUsePath = path.join(hooksDir, `PostToolUse${postWriteWrapper.extension}`);
-  await fs.writeFile(preToolUsePath, preToolUseWrapper.content, { mode: 493 });
-  await fs.writeFile(userPromptPath, userPromptWrapper.content, { mode: 493 });
+  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 fs.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
+    await fs3.writeFile(postToolUsePath, postWriteWrapper.content, { mode: 493 });
     result.postToolUse = postToolUsePath;
   }
   return result;
 }
 function getCursorHooksConfigPath(scope, projectPath) {
   if (scope === "global") {
-    return path.join(homedir(), ".cursor", "hooks.json");
+    return path3.join(homedir2(), ".cursor", "hooks.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".cursor", "hooks.json");
+  return path3.join(projectPath, ".cursor", "hooks.json");
 }
 function getCursorHooksDir(scope, projectPath) {
   if (scope === "global") {
-    return path.join(homedir(), ".cursor", "hooks");
+    return path3.join(homedir2(), ".cursor", "hooks");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path.join(projectPath, ".cursor", "hooks");
+  return path3.join(projectPath, ".cursor", "hooks");
 }
 async function readCursorHooksConfig(scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs3.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, hooks: {} };
@@ -619,13 +1771,13 @@ async function readCursorHooksConfig(scope, projectPath) {
 }
 async function writeCursorHooksConfig(config, scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
-  const dir = path.dirname(configPath);
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  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 fs.mkdir(hooksDir, { recursive: true });
+  await fs3.mkdir(hooksDir, { recursive: true });
   const existingConfig = await readCursorHooksConfig(options.scope, options.projectPath);
   const filterContextStreamHooks = (hooks) => {
     if (!hooks) return [];
@@ -1637,18 +2789,18 @@ if __name__ == "__main__":
 });
 
 // src/hooks/auto-rules.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { homedir as homedir2 } from "node:os";
+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 = path2.join(homedir2(), ".contextstream", ".auto-rules-ran");
+var MARKER_FILE = path4.join(homedir3(), ".contextstream", ".auto-rules-ran");
 var COOLDOWN_MS = 4 * 60 * 60 * 1e3;
 function hasRunRecently() {
   try {
-    if (!fs2.existsSync(MARKER_FILE)) return false;
-    const stat = fs2.statSync(MARKER_FILE);
+    if (!fs4.existsSync(MARKER_FILE)) return false;
+    const stat = fs4.statSync(MARKER_FILE);
     const age = Date.now() - stat.mtimeMs;
     return age < COOLDOWN_MS;
   } catch {
@@ -1657,11 +2809,11 @@ function hasRunRecently() {
 }
 function markAsRan() {
   try {
-    const dir = path2.dirname(MARKER_FILE);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    const dir = path4.dirname(MARKER_FILE);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
-    fs2.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    fs4.writeFileSync(MARKER_FILE, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }
@@ -1690,8 +2842,8 @@ function extractCwd(input) {
 }
 function hasPythonHooks(settingsPath) {
   try {
-    if (!fs2.existsSync(settingsPath)) return false;
-    const content = fs2.readFileSync(settingsPath, "utf-8");
+    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;
@@ -1715,8 +2867,8 @@ function hasPythonHooks(settingsPath) {
   }
 }
 function detectPythonHooks(cwd) {
-  const globalSettingsPath = path2.join(homedir2(), ".claude", "settings.json");
-  const projectSettingsPath = path2.join(cwd, ".claude", "settings.json");
+  const globalSettingsPath = path4.join(homedir3(), ".claude", "settings.json");
+  const projectSettingsPath = path4.join(cwd, ".claude", "settings.json");
   return {
     global: hasPythonHooks(globalSettingsPath),
     project: hasPythonHooks(projectSettingsPath)