@dyyz1993/pi-coding-agent 0.74.24 → 0.74.27

package/dist/extensions/rules-engine/index.js

@@ -0,0 +1,1530 @@
+// packages/coding-agent/extensions/rules-engine/index.ts
+import { Type } from "@dyyz1993/pi-ai";
+import { createTypedChannel, defineTool } from "@dyyz1993/pi-coding-agent";
+
+// packages/coding-agent/extensions/rules-engine/cache.js
+import { homedir } from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+var DEFAULT_DIRS = {
+  managed: ["/etc/claude-code/.claude/rules"],
+  user: [path.join(homedir(), ".claude", "rules"), path.join(homedir(), ".config", "opencode", "rules")],
+  pi: [".pi/rules"],
+  project: [".claude/rules", ".opencode/rules", ".trae/rules"]
+};
+function resolveDirs(projectDir, config) {
+  const sources = config.dirs || DEFAULT_DIRS;
+  const result = [];
+  for (const [scope, paths] of Object.entries(sources)) {
+    for (const p of paths) {
+      result.push({
+        scope,
+        dir: p.startsWith("/") || p.startsWith("~") ? p.replace(/^~/, homedir()) : path.resolve(projectDir, p),
+        source: p
+      });
+    }
+  }
+  return result;
+}
+function splitComma(val) {
+  const result = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of val) {
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    else if (ch === "}" || ch === ")" || ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      const trimmed2 = current.trim().replace(/^["']|["']$/g, "");
+      if (trimmed2) result.push(trimmed2);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const trimmed = current.trim().replace(/^["']|["']$/g, "");
+  if (trimmed) result.push(trimmed);
+  return result;
+}
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\n?---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const [, frontmatterStr, body] = match;
+  const data = {};
+  const lines = frontmatterStr.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const rawKey = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "" || value === "null" || value === "undefined") {
+      const listItems = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const subLine = lines[j];
+        if (subLine.match(/^\s*-\s+/)) {
+          listItems.push(
+            subLine.replace(/^\s*-\s+/, "").trim().replace(/^["']|["']$/g, "")
+          );
+          j++;
+        } else if (subLine.trim() === "" || subLine.match(/^\s+/)) {
+          j++;
+        } else {
+          break;
+        }
+      }
+      if (listItems.length > 0) {
+        const camelKey2 = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        data[camelKey2] = listItems;
+        i = j;
+        continue;
+      }
+      value = null;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      try {
+        value = JSON.parse(value.replace(/'/g, '"'));
+      } catch (err) {
+        console.debug("[rules-engine] JSON array parse failed:", err instanceof Error ? err.message : err);
+        value = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
+      }
+    } else if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    if ((camelKey === "paths" || camelKey === "globs") && typeof value === "string") {
+      data[camelKey] = splitComma(value);
+    } else {
+      data[camelKey] = value;
+    }
+    i++;
+  }
+  return { data, body: body.trim() };
+}
+function extractTitle(body) {
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed) {
+      return trimmed.replace(/^#+\s*/, "").replace(/\*\*/g, "");
+    }
+  }
+  return "Untitled Rule";
+}
+function parsePaths(raw) {
+  if (!raw) return [];
+  if (typeof raw === "string") {
+    return raw.split(",").map((g) => g.trim()).filter(Boolean);
+  }
+  if (Array.isArray(raw)) return raw;
+  return [];
+}
+function parseRuleFile(filePath, content) {
+  const { data, body } = parseFrontmatter(content);
+  const rawGlobs = data.globs ?? data.paths;
+  const globs = parsePaths(rawGlobs);
+  const rawPaths = data.paths;
+  const paths = parsePaths(rawPaths);
+  const isUnconditional = globs.length === 0 || globs.length === 1 && globs[0] === "**";
+  const frontmatter = {};
+  if (rawGlobs) {
+    frontmatter.globs = globs;
+    if (rawPaths) {
+      frontmatter.paths = paths;
+    } else {
+      frontmatter.paths = globs;
+    }
+  }
+  if (data.description && typeof data.description === "string") frontmatter.description = data.description;
+  if (data.severity && typeof data.severity === "string")
+    frontmatter.severity = data.severity;
+  if (data.allowedTools)
+    frontmatter.allowedTools = typeof data.allowedTools === "string" ? [data.allowedTools] : data.allowedTools;
+  if (data.whenToUse && typeof data.whenToUse === "string") frontmatter.whenToUse = data.whenToUse;
+  if (data.notifyOnMatch !== void 0)
+    frontmatter.notifyOnMatch = data.notifyOnMatch === "true" || data.notifyOnMatch === true;
+  if (data.skipInPrompt !== void 0)
+    frontmatter.skipInPrompt = data.skipInPrompt === "true" || data.skipInPrompt === true;
+  return {
+    name: path2.basename(filePath, path2.extname(filePath)),
+    filePath,
+    title: extractTitle(body),
+    content: body.trim(),
+    scope: "project",
+    source: "",
+    frontmatter,
+    isUnconditional
+  };
+}
+function scanDir(dir, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scanDir(fullPath, files);
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function loadRules(rulesDir) {
+  const rules = [];
+  const unconditional = [];
+  const conditional = [];
+  if (!fs.existsSync(rulesDir)) {
+    return { rules, unconditional, conditional, loadedAt: Date.now() };
+  }
+  const files = scanDir(rulesDir);
+  for (const filePath of files) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const rule = parseRuleFile(filePath, content);
+    rules.push(rule);
+    if (rule.isUnconditional) {
+      unconditional.push(rule);
+    } else {
+      conditional.push(rule);
+    }
+  }
+  return { rules, unconditional, conditional, loadedAt: Date.now() };
+}
+var cache = null;
+async function getRules(projectDir, config) {
+  if (cache && Date.now() - cache.loadedAt < config.cacheTTL) {
+    return cache.rules;
+  }
+  const rules = await loadAllRules(projectDir, config);
+  cache = { rules, loadedAt: Date.now() };
+  return rules;
+}
+function invalidateCache() {
+  cache = null;
+}
+async function loadAllRules(projectDir, config) {
+  const sources = resolveDirs(projectDir, config);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { scope, dir, source } of sources) {
+    const ruleCache = loadRules(dir);
+    for (const rule of ruleCache.rules) {
+      if (seen.has(rule.filePath)) continue;
+      seen.add(rule.filePath);
+      rule.scope = scope;
+      rule.source = source;
+      result.push(rule);
+    }
+  }
+  return result;
+}
+
+// packages/coding-agent/extensions/rules-engine/config.js
+import * as fs2 from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import * as path3 from "node:path";
+var DEFAULT_CACHE_TTL = 3e4;
+var DEFAULT_DIRS2 = {
+  managed: ["/etc/claude-code/.claude/rules"],
+  user: [path3.join(homedir2(), ".claude", "rules"), path3.join(homedir2(), ".config", "opencode", "rules")],
+  pi: [".pi/rules"],
+  project: [".claude/rules", ".opencode/rules", ".trae/rules"]
+};
+function defaultConfig() {
+  return {
+    cacheTTL: DEFAULT_CACHE_TTL,
+    notifyOnLoad: true,
+    notifyOnMatch: true
+  };
+}
+async function loadConfig(projectDir) {
+  const configFiles = [
+    ".rules-config.json",
+    ".pi/rules-config.json",
+    ".claude/rules-config.json",
+    ".opencode/rules-config.json"
+  ];
+  for (const name of configFiles) {
+    const fp = path3.resolve(projectDir, name);
+    if (!fs2.existsSync(fp)) continue;
+    try {
+      const raw = fs2.readFileSync(fp, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        ...defaultConfig(),
+        ...parsed,
+        cacheTTL: parsed.cacheTTL ?? DEFAULT_CACHE_TTL,
+        notifyOnLoad: parsed.notifyOnLoad ?? true,
+        notifyOnMatch: parsed.notifyOnMatch ?? true
+      };
+    } catch (err) {
+      console.debug("[rules-engine] config parse failed:", err instanceof Error ? err.message : err);
+    }
+  }
+  return defaultConfig();
+}
+function resolveDirs2(projectDir, config) {
+  const sources = config.dirs || DEFAULT_DIRS2;
+  const result = [];
+  for (const [scope, paths] of Object.entries(sources)) {
+    for (const p of paths) {
+      result.push({
+        scope,
+        dir: p.startsWith("/") || p.startsWith("~") ? p.replace(/^~/, homedir2()) : path3.resolve(projectDir, p),
+        source: p
+      });
+    }
+  }
+  return result;
+}
+
+// packages/coding-agent/extensions/rules-engine/injector.js
+var SEVERITY_ICONS = {
+  critical: "\u{1F534}",
+  high: "\u{1F7E0}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F535}",
+  hint: "\u{1F4A1}"
+};
+function buildSystemReminderSection(rules, sources) {
+  if (rules.length === 0) return "";
+  const lines = [
+    "<system-reminder>",
+    `Instructions from: ${sources.join(", ")}`,
+    "The following rules are always active. Follow them strictly.",
+    ""
+  ];
+  for (const rule of rules) {
+    lines.push(`Rule: ${rule.name} \u2014 ${rule.title}`);
+    if (rule.frontmatter.description) {
+      lines.push(`> ${rule.frontmatter.description}`);
+    }
+    lines.push("");
+    lines.push(rule.content);
+    lines.push("");
+  }
+  lines.push("</system-reminder>");
+  return lines.join("\n");
+}
+function buildToolReminderSection(rules, targetPath) {
+  if (rules.length === 0) return "";
+  const lines = [
+    "<system-reminder>",
+    `Conditional rules matched for ${targetPath}:`,
+    ""
+  ];
+  for (const rule of rules) {
+    const severity = rule.frontmatter.severity || "medium";
+    const icon = SEVERITY_ICONS[severity] || "\u{1F7E1}";
+    lines.push(`Rule: ${icon} ${rule.title} [${severity}]`);
+    if (rule.frontmatter.description) {
+      lines.push(`> ${rule.frontmatter.description}`);
+    }
+    lines.push("");
+    lines.push(rule.content);
+    lines.push("");
+  }
+  lines.push("</system-reminder>");
+  return lines.join("\n");
+}
+var buildSystemPromptSection = buildSystemReminderSection;
+var buildToolContextSection = buildToolReminderSection;
+function buildCompactContext(rules) {
+  if (rules.length === 0) return "";
+  const lines = ["## Active Rules (persist across compaction)", ""];
+  for (const rule of rules) {
+    const desc = rule.frontmatter.description || rule.content.split("\n")[0];
+    lines.push(`- **${rule.title}** (${rule.name}): ${desc}`);
+  }
+  return lines.join("\n");
+}
+
+// packages/coding-agent/extensions/rules-engine/matcher.js
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+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 Ignore = 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, cache2, checkUnignored, slices) {
+        const path5 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path5,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path5, cache2, 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, cache2, checkUnignored, slices) {
+        if (path5 in cache2) {
+          return cache2[path5];
+        }
+        if (!slices) {
+          slices = path5.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache2[path5] = this._rules.test(path5, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache2,
+          checkUnignored,
+          slices
+        );
+        return cache2[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 Ignore(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);
+  }
+});
+var import_ignore = __toESM(require_ignore(), 1);
+function expandBraces(pattern) {
+  const braceIndex = pattern.indexOf("{");
+  if (braceIndex === -1) return [pattern];
+  const closeIndex = pattern.indexOf("}", braceIndex);
+  if (closeIndex === -1) return [pattern];
+  const prefix = pattern.slice(0, braceIndex);
+  const suffix = pattern.slice(closeIndex + 1);
+  const options = pattern.slice(braceIndex + 1, closeIndex).split(",");
+  const results = [];
+  for (const opt of options) {
+    results.push(...expandBraces(prefix + opt.trim() + suffix));
+  }
+  return results;
+}
+function expandPatterns(patterns) {
+  const expanded = [];
+  for (const p of patterns) {
+    expanded.push(...expandBraces(p));
+  }
+  return expanded;
+}
+function toRelative(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.startsWith("/") ? normalized.slice(1) : normalized;
+}
+function matchGlob(pattern, target) {
+  if (!pattern || !target) return false;
+  const expanded = expandBraces(pattern);
+  const ig = (0, import_ignore.default)().add(expanded);
+  return ig.ignores(toRelative(target));
+}
+function matchesAnyGlob(globs, filePath) {
+  if (!filePath || globs.length === 0) return false;
+  const expanded = expandPatterns(globs);
+  const ig = (0, import_ignore.default)().add(expanded);
+  return ig.ignores(toRelative(filePath));
+}
+
+// packages/coding-agent/extensions/rules-engine/types.js
+var RULES_CHANNEL_NAME = "rules-engine";
+
+// packages/coding-agent/extensions/rules-engine/index.ts
+import { createTypedChannel as createTypedChannel2 } from "@dyyz1993/pi-coding-agent";
+
+// packages/coding-agent/extensions/rules-engine/loader.js
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+function splitComma2(val) {
+  const result = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of val) {
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    else if (ch === "}" || ch === ")" || ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      const trimmed2 = current.trim().replace(/^["']|["']$/g, "");
+      if (trimmed2) result.push(trimmed2);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const trimmed = current.trim().replace(/^["']|["']$/g, "");
+  if (trimmed) result.push(trimmed);
+  return result;
+}
+function parseFrontmatter2(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\n?---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const [, frontmatterStr, body] = match;
+  const data = {};
+  const lines = frontmatterStr.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
+      continue;
+    }
+    const rawKey = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "" || value === "null" || value === "undefined") {
+      const listItems = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const subLine = lines[j];
+        if (subLine.match(/^\s*-\s+/)) {
+          listItems.push(
+            subLine.replace(/^\s*-\s+/, "").trim().replace(/^["']|["']$/g, "")
+          );
+          j++;
+        } else if (subLine.trim() === "" || subLine.match(/^\s+/)) {
+          j++;
+        } else {
+          break;
+        }
+      }
+      if (listItems.length > 0) {
+        const camelKey2 = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        data[camelKey2] = listItems;
+        i = j;
+        continue;
+      }
+      value = null;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      try {
+        value = JSON.parse(value.replace(/'/g, '"'));
+      } catch (err) {
+        console.debug("[rules-engine] JSON array parse failed:", err instanceof Error ? err.message : err);
+        value = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
+      }
+    } else if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    if ((camelKey === "paths" || camelKey === "globs") && typeof value === "string") {
+      data[camelKey] = splitComma2(value);
+    } else {
+      data[camelKey] = value;
+    }
+    i++;
+  }
+  return { data, body: body.trim() };
+}
+function extractTitle2(body) {
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed) {
+      return trimmed.replace(/^#+\s*/, "").replace(/\*\*/g, "");
+    }
+  }
+  return "Untitled Rule";
+}
+function parsePaths2(raw) {
+  if (!raw) return [];
+  if (typeof raw === "string") {
+    return raw.split(",").map((g) => g.trim()).filter(Boolean);
+  }
+  if (Array.isArray(raw)) return raw;
+  return [];
+}
+function parseRuleFile2(filePath, content) {
+  const { data, body } = parseFrontmatter2(content);
+  const rawGlobs = data.globs ?? data.paths;
+  const globs = parsePaths2(rawGlobs);
+  const rawPaths = data.paths;
+  const paths = parsePaths2(rawPaths);
+  const isUnconditional = globs.length === 0 || globs.length === 1 && globs[0] === "**";
+  const frontmatter = {};
+  if (rawGlobs) {
+    frontmatter.globs = globs;
+    if (rawPaths) {
+      frontmatter.paths = paths;
+    } else {
+      frontmatter.paths = globs;
+    }
+  }
+  if (data.description && typeof data.description === "string") frontmatter.description = data.description;
+  if (data.severity && typeof data.severity === "string")
+    frontmatter.severity = data.severity;
+  if (data.allowedTools)
+    frontmatter.allowedTools = typeof data.allowedTools === "string" ? [data.allowedTools] : data.allowedTools;
+  if (data.whenToUse && typeof data.whenToUse === "string") frontmatter.whenToUse = data.whenToUse;
+  if (data.notifyOnMatch !== void 0)
+    frontmatter.notifyOnMatch = data.notifyOnMatch === "true" || data.notifyOnMatch === true;
+  if (data.skipInPrompt !== void 0)
+    frontmatter.skipInPrompt = data.skipInPrompt === "true" || data.skipInPrompt === true;
+  return {
+    name: path4.basename(filePath, path4.extname(filePath)),
+    filePath,
+    title: extractTitle2(body),
+    content: body.trim(),
+    scope: "project",
+    source: "",
+    frontmatter,
+    isUnconditional
+  };
+}
+function scanDir2(dir, files = []) {
+  if (!fs3.existsSync(dir)) return files;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scanDir2(fullPath, files);
+    } else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function loadRules2(rulesDir) {
+  const rules = [];
+  const unconditional = [];
+  const conditional = [];
+  if (!fs3.existsSync(rulesDir)) {
+    return { rules, unconditional, conditional, loadedAt: Date.now() };
+  }
+  const files = scanDir2(rulesDir);
+  for (const filePath of files) {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const rule = parseRuleFile2(filePath, content);
+    rules.push(rule);
+    if (rule.isUnconditional) {
+      unconditional.push(rule);
+    } else {
+      conditional.push(rule);
+    }
+  }
+  return { rules, unconditional, conditional, loadedAt: Date.now() };
+}
+
+// packages/coding-agent/extensions/rules-engine/index.ts
+var READ_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob"]);
+function rulesEnginePlugin(pi) {
+  let config = null;
+  let rules = [];
+  let cachedMatchHash = "";
+  let hasSentSnapshot = false;
+  let _lastCwd = "";
+  let lastMessages = [];
+  let injectedRuleFiles = /* @__PURE__ */ new Map();
+  function rebuildMatchHistory(messages) {
+    const history = [];
+    for (const msg of messages) {
+      if (msg.role !== "toolResult") continue;
+      const details = msg.details;
+      if (!details?.rulesMatched) continue;
+      const rulesMatched = details.rulesMatched;
+      history.push({
+        filePath: details.matchedFilePath || "",
+        ruleNames: rulesMatched.map((r) => r.name),
+        toolName: msg.toolName || "",
+        toolCallId: msg.toolCallId || "",
+        severity: rulesMatched.some((r) => r.severity === "critical" || r.severity === "high") ? "warning" : "info",
+        timestamp: msg.timestamp || 0,
+        matchedRuleDetails: rulesMatched
+      });
+    }
+    return history;
+  }
+  const rawChannel = pi.registerChannel(RULES_CHANNEL_NAME);
+  const channel = createTypedChannel(rawChannel).server;
+  channel.handle("getSnapshot", (params) => {
+    const unconditional = getUnconditionalRules();
+    const conditional = getConditionalRules();
+    const matchHistory = rebuildMatchHistory(lastMessages);
+    return {
+      type: "snapshot",
+      rules: rules.map(toRuleDetail),
+      injectedRuleNames: unconditional.map((r) => r.name),
+      totalRules: rules.length,
+      unconditionalCount: unconditional.length,
+      conditionalCount: conditional.length,
+      matchHistory,
+      lifecycleLog: [],
+      loadedAt: Date.now(),
+      cacheTTL: config?.cacheTTL || 3e4
+    };
+  });
+  function getUnconditionalRules() {
+    return rules.filter((r) => r.isUnconditional);
+  }
+  function getConditionalRules() {
+    return rules.filter((r) => !r.isUnconditional);
+  }
+  function getMatchingRules(targetPath) {
+    return getConditionalRules().filter((rule) => {
+      const globs = rule.frontmatter.globs ?? rule.frontmatter.paths;
+      if (!globs || globs.length === 0) return false;
+      return matchesAnyGlob(globs, targetPath);
+    });
+  }
+  async function refreshRules(cwd) {
+    config = await loadConfig(cwd);
+    rules = await getRules(cwd, config);
+  }
+  function toRuleDetail(r) {
+    return {
+      name: r.name,
+      title: r.title,
+      filePath: r.filePath,
+      scope: r.scope,
+      source: r.source,
+      severity: r.frontmatter.severity || "medium",
+      isUnconditional: r.isUnconditional,
+      globs: r.frontmatter.globs ?? r.frontmatter.paths ?? [],
+      description: r.frontmatter.description
+    };
+  }
+  function buildSnapshot(matchHistory, lifecycleLog) {
+    const unconditional = getUnconditionalRules();
+    const conditional = getConditionalRules();
+    return {
+      type: "snapshot",
+      rules: rules.map(toRuleDetail),
+      injectedRuleNames: unconditional.map((r) => r.name),
+      totalRules: rules.length,
+      unconditionalCount: unconditional.length,
+      conditionalCount: conditional.length,
+      matchHistory,
+      lifecycleLog,
+      loadedAt: Date.now(),
+      cacheTTL: config?.cacheTTL || 3e4
+    };
+  }
+  function extractTargetPath(args) {
+    if ("filePath" in args && typeof args.filePath === "string") return args.filePath;
+    if ("path" in args && typeof args.path === "string") return args.path;
+    if ("pattern" in args && typeof args.pattern === "string") return args.pattern;
+    return void 0;
+  }
+  pi.registerTool(
+    defineTool({
+      name: "rules_list",
+      label: "List Rules",
+      description: "List all discovered rules from all configured directories across all scopes",
+      parameters: Type.Object({}),
+      async execute() {
+        const unconditional = getUnconditionalRules();
+        const conditional = getConditionalRules();
+        const byScope = {};
+        for (const r of rules) {
+          byScope[r.scope] = (byScope[r.scope] || 0) + 1;
+        }
+        let output = `# Loaded Rules (${rules.length})
+
+`;
+        output += `Scopes: ${Object.entries(byScope).map(([k, v]) => `${k}: ${v}`).join(", ")}
+
+`;
+        output += `**Unconditional** (${unconditional.length}):
+`;
+        for (const rule of unconditional) {
+          output += `- ${rule.title} (${rule.source})
+`;
+        }
+        output += `
+**Conditional** (${conditional.length}):
+`;
+        for (const rule of conditional) {
+          output += `- ${rule.title} [${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(", ")}] (${rule.source})
+`;
+        }
+        return { content: [{ type: "text", text: output }], details: void 0 };
+      }
+    })
+  );
+  pi.registerTool(
+    defineTool({
+      name: "rules_match",
+      label: "Match Rules",
+      description: "Find conditional rules that match a given file path by glob pattern",
+      parameters: Type.Object({
+        filePath: Type.String({ description: "File path to match" })
+      }),
+      async execute(_id, params) {
+        const matching = getMatchingRules(params.filePath);
+        const unconditional = getUnconditionalRules();
+        let output = `# Rule Match: ${params.filePath}
+
+`;
+        output += `**Unconditional** (always active, ${unconditional.length}):
+`;
+        for (const r of unconditional) {
+          output += `- ${r.title}
+`;
+        }
+        output += `
+**Conditional matches** (${matching.length}):
+`;
+        for (const r of matching) {
+          const sev = r.frontmatter.severity || "medium";
+          output += `- [${sev}] ${r.title} (${(r.frontmatter.globs ?? r.frontmatter.paths)?.join(", ")})
+`;
+        }
+        return { content: [{ type: "text", text: output }], details: void 0 };
+      }
+    })
+  );
+  pi.registerTool(
+    defineTool({
+      name: "rules_reload",
+      label: "Reload Rules",
+      description: "Force reload all rules from disk (clears cache and re-reads config)",
+      parameters: Type.Object({}),
+      async execute(_id, _params, _signal, _onUpdate, ctx) {
+        invalidateCache();
+        await refreshRules(ctx.cwd);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Rules reloaded: ${rules.length} total (${getUnconditionalRules().length} unconditional, ${getConditionalRules().length} conditional)`
+            }
+          ],
+          details: void 0
+        };
+      }
+    })
+  );
+  pi.registerTool(
+    defineTool({
+      name: "rules_show",
+      label: "Show Rule",
+      description: "Show the full content of a specific rule by name",
+      parameters: Type.Object({
+        name: Type.String({ description: "Rule name (filename without .md)" })
+      }),
+      async execute(_id, params) {
+        const rule = rules.find((r) => r.name === params.name);
+        if (!rule) {
+          return {
+            content: [{ type: "text", text: `Rule '${params.name}' not found` }],
+            isError: true,
+            details: void 0
+          };
+        }
+        let output = `# ${rule.title}
+
+`;
+        output += `- **Name**: ${rule.name}
+`;
+        output += `- **Scope**: ${rule.scope}
+`;
+        output += `- **Source**: ${rule.source}
+`;
+        output += `- **File**: ${rule.filePath}
+`;
+        if ((rule.frontmatter.globs ?? rule.frontmatter.paths)?.length) {
+          output += `- **Globs**: ${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(", ")}
+`;
+        }
+        if (rule.frontmatter.description) {
+          output += `- **Description**: ${rule.frontmatter.description}
+`;
+        }
+        output += `
+${rule.content}`;
+        return { content: [{ type: "text", text: output }], details: void 0 };
+      }
+    })
+  );
+  pi.registerCommand("rules", {
+    description: "Rules management (list, reload, check <path>, active)",
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/);
+      const sub = parts[0] || "list";
+      if (sub === "list" || sub === "ls") {
+        ctx.ui.notify(
+          `${rules.length} rules loaded (${getUnconditionalRules().length} unconditional, ${getConditionalRules().length} conditional)`,
+          "info"
+        );
+      } else if (sub === "reload") {
+        invalidateCache();
+        await refreshRules(ctx.cwd);
+        ctx.ui.notify(`Rules reloaded: ${rules.length} total`, "info");
+      } else if (sub === "check" && parts[1]) {
+        const target = parts.slice(1).join(" ");
+        const matching = getMatchingRules(target);
+        ctx.ui.notify(
+          matching.length > 0 ? `${matching.length} rules match ${target}: ${matching.map((r) => r.title).join(", ")}` : `No conditional rules match ${target}`,
+          "info"
+        );
+      } else if (sub === "active") {
+        const active = getUnconditionalRules();
+        ctx.ui.notify(
+          `Active: ${active.length} unconditional (in system prompt), ${getConditionalRules().length} conditional (on file match)`,
+          "info"
+        );
+      } else {
+        ctx.ui.notify("Usage: /rules [list|reload|check <path>|active]", "info");
+      }
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    _lastCwd = ctx.cwd;
+    await refreshRules(ctx.cwd);
+    ctx.ui.setStatus("rules-engine", `Rules: ${rules.length}`);
+    const unconditional = getUnconditionalRules();
+    const conditional = getConditionalRules();
+    if (!hasSentSnapshot) {
+      hasSentSnapshot = true;
+      const scopeGroups = /* @__PURE__ */ new Map();
+      for (const r of rules) {
+        const list = scopeGroups.get(r.scope) || [];
+        list.push(r);
+        scopeGroups.set(r.scope, list);
+      }
+      const scannedDirs = [...scopeGroups.entries()].map(([scope, scopeRules]) => ({
+        dir: scopeRules[0]?.source || scope,
+        fileCount: scopeRules.length,
+        ruleNames: scopeRules.map((r) => r.name)
+      }));
+      channel.emit(
+        "snapshot",
+        buildSnapshot(
+          [],
+          [
+            {
+              event: "loaded",
+              message: `Loaded ${rules.length} rules (${unconditional.length} unconditional, ${conditional.length} conditional)`,
+              ruleCount: rules.length,
+              timestamp: Date.now(),
+              details: {
+                scannedDirs,
+                configSource: config ? ".rules-config.json" : "default",
+                cacheHit: false
+              }
+            }
+          ]
+        )
+      );
+    }
+  });
+  pi.on("before_agent_start", async (event) => {
+    const unconditional = getUnconditionalRules();
+    if (unconditional.length === 0) {
+      channel.emit("injected", {
+        type: "injected",
+        ruleNames: [],
+        systemPromptLength: event.systemPrompt.length
+      });
+      return void 0;
+    }
+    const alreadyInjected = lastMessages.some(
+      (msg) => msg.role === "custom" && msg.customType === "rules-engine"
+    );
+    if (alreadyInjected) {
+      channel.emit("injected", {
+        type: "injected",
+        ruleNames: unconditional.map((r) => r.name),
+        systemPromptLength: event.systemPrompt.length,
+        deduplicated: true
+      });
+      return void 0;
+    }
+    const sources = [...new Set(unconditional.map((r) => r.source))];
+    const reminderContent = buildSystemReminderSection(unconditional, sources);
+    channel.emit("injected", {
+      type: "injected",
+      ruleNames: unconditional.map((r) => r.name),
+      systemPromptLength: event.systemPrompt.length
+    });
+    return {
+      message: {
+        customType: "rules-engine",
+        content: reminderContent,
+        display: false
+      }
+    };
+  });
+  pi.on("tool_result", async (event) => {
+    if (!READ_TOOLS.has(event.toolName)) return void 0;
+    const targetPath = extractTargetPath(event.input);
+    if (!targetPath) return void 0;
+    const matching = getMatchingRules(targetPath);
+    if (matching.length === 0) return void 0;
+    const matchedRuleDetails = matching.map((r) => {
+      const ruleName = r.name;
+      const injectedFiles = injectedRuleFiles.get(ruleName);
+      const wasAlreadyLoaded = injectedFiles !== void 0 && injectedFiles.has(targetPath);
+      return {
+        name: ruleName,
+        title: r.title,
+        severity: r.frontmatter.severity || "medium",
+        matchedGlob: (r.frontmatter.globs ?? r.frontmatter.paths)?.find((p) => matchesAnyGlob([p], targetPath)) || (r.frontmatter.globs ?? r.frontmatter.paths)?.[0] || "",
+        alreadyLoaded: wasAlreadyLoaded || void 0
+      };
+    });
+    const newRules = matching.filter((r) => {
+      const injectedFiles = injectedRuleFiles.get(r.name);
+      return !injectedFiles || !injectedFiles.has(targetPath);
+    });
+    const allAlreadyLoaded = newRules.length === 0;
+    for (const r of matching) {
+      let injectedFiles = injectedRuleFiles.get(r.name);
+      if (!injectedFiles) {
+        injectedFiles = /* @__PURE__ */ new Set();
+        injectedRuleFiles.set(r.name, injectedFiles);
+      }
+      injectedFiles.add(targetPath);
+    }
+    const hasCritical = matching.some((r) => r.frontmatter.severity === "critical");
+    const hasHigh = matching.some((r) => r.frontmatter.severity === "high");
+    channel.emit("matched", {
+      type: "matched",
+      filePath: targetPath,
+      matchedRules: matchedRuleDetails,
+      toolName: event.toolName,
+      toolCallId: event.toolCallId,
+      severity: hasCritical ? "warning" : hasHigh ? "warning" : "info",
+      timestamp: Date.now(),
+      alreadyLoaded: allAlreadyLoaded || void 0
+    });
+    if (allAlreadyLoaded) {
+      return {
+        details: {
+          ...event.details || {},
+          rulesMatched: matchedRuleDetails,
+          matchedFilePath: targetPath
+        }
+      };
+    }
+    const contextSection = buildToolReminderSection(newRules, targetPath);
+    return {
+      content: [...event.content, { type: "text", text: `
+
+${contextSection}` }],
+      details: {
+        ...event.details || {},
+        rulesMatched: matchedRuleDetails,
+        matchedFilePath: targetPath
+      }
+    };
+  });
+  pi.on("context", async (event) => {
+    lastMessages = event.messages;
+    const matchHistory = rebuildMatchHistory(event.messages);
+    const hash = JSON.stringify(matchHistory.map((r) => `${r.toolCallId}:${r.filePath}`));
+    if (hash !== cachedMatchHash) {
+      cachedMatchHash = hash;
+      const unconditional = getUnconditionalRules();
+      const conditional = getConditionalRules();
+      channel.emit("snapshot", {
+        type: "snapshot",
+        rules: rules.map(toRuleDetail),
+        injectedRuleNames: unconditional.map((r) => r.name),
+        totalRules: rules.length,
+        unconditionalCount: unconditional.length,
+        conditionalCount: conditional.length,
+        matchHistory,
+        lifecycleLog: [],
+        loadedAt: Date.now(),
+        cacheTTL: config?.cacheTTL || 3e4
+      });
+    }
+    return void 0;
+  });
+  pi.on("session_compact", async (_event, ctx) => {
+    cachedMatchHash = "";
+    lastMessages = [];
+    injectedRuleFiles = /* @__PURE__ */ new Map();
+    ctx.ui.setStatus("rules-engine", `Rules: ${rules.length} (re-injected after compact)`);
+  });
+  pi.on("session_tree", async () => {
+    cachedMatchHash = "";
+    lastMessages = [];
+    injectedRuleFiles = /* @__PURE__ */ new Map();
+  });
+  pi.on("turn_end", async () => {
+    if (lastMessages.length === 0 && rules.length > 0) return;
+    const matchHistory = rebuildMatchHistory(lastMessages);
+    const hash = JSON.stringify(matchHistory.map((r) => `${r.toolCallId}:${r.filePath}`));
+    if (hash !== cachedMatchHash) {
+      cachedMatchHash = hash;
+      channel.emit("snapshot", {
+        type: "snapshot",
+        rules: rules.map(toRuleDetail),
+        injectedRuleNames: getUnconditionalRules().map((r) => r.name),
+        totalRules: rules.length,
+        unconditionalCount: getUnconditionalRules().length,
+        conditionalCount: getConditionalRules().length,
+        matchHistory,
+        lifecycleLog: [],
+        loadedAt: Date.now(),
+        cacheTTL: config?.cacheTTL || 3e4
+      });
+    }
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    channel.emit("unloaded", { type: "unloaded", reason: "session_shutdown" });
+    ctx.ui.setStatus("rules-engine", void 0);
+  });
+}
+export {
+  buildCompactContext,
+  buildSystemPromptSection,
+  buildSystemReminderSection,
+  buildToolContextSection,
+  buildToolReminderSection,
+  createTypedChannel2 as createTypedChannel,
+  rulesEnginePlugin as default,
+  getRules,
+  invalidateCache,
+  loadConfig,
+  loadRules2 as loadRules,
+  matchGlob,
+  matchesAnyGlob,
+  parseFrontmatter2 as parseFrontmatter,
+  parseRuleFile2 as parseRuleFile,
+  resolveDirs2 as resolveDirs
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["index.ts", "config.ts", "loader.ts", "cache.ts", "config.ts", "injector.ts", "../../../../node_modules/ignore/index.js", "matcher.ts", "types.ts", "loader.ts"],
  "sourcesContent": ["import { Type } from \"@dyyz1993/pi-ai\";\nimport { createTypedChannel, defineTool, type ExtensionAPI } from \"@dyyz1993/pi-coding-agent\";\nimport { getRules, invalidateCache } from \"./cache.js\";\nimport { loadConfig } from \"./config.js\";\nimport { buildSystemReminderSection, buildToolReminderSection } from \"./injector.js\";\nimport { matchesAnyGlob } from \"./matcher.js\";\nimport type {\n\tInjectedPayload,\n\tLifecycleEntry,\n\tMatchedRuleDetail,\n\tMatchRecord,\n\tParsedRule,\n\tRuleDetail,\n\tRuleSeverity,\n\tRulesChannelContract,\n\tRulesChannelEvent,\n\tRulesConfig,\n\tScannedDir,\n\tSnapshotPayload,\n} from \"./types.js\";\nimport { RULES_CHANNEL_NAME } from \"./types.js\";\n\nexport { createTypedChannel } from \"@dyyz1993/pi-coding-agent\";\nexport { getRules, invalidateCache } from \"./cache.js\";\nexport { loadConfig, resolveDirs } from \"./config.js\";\nexport { buildCompactContext, buildSystemReminderSection, buildToolReminderSection, buildSystemPromptSection, buildToolContextSection } from \"./injector.js\";\nexport { loadRules, parseFrontmatter, parseRuleFile } from \"./loader.js\";\nexport { matchesAnyGlob, matchGlob } from \"./matcher.js\";\nexport type {\n\tInjectedPayload,\n\tLifecycleEntry,\n\tMatchedPayload,\n\tMatchRecord,\n\tParsedRule,\n\tReloadedPayload,\n\tRuleDetail,\n\tRuleFrontmatter,\n\tRuleScope,\n\tRuleSeverity,\n\tRulesChannelContract,\n\tRulesChannelEvent,\n\tRulesConfig,\n\tScannedDir,\n\tSnapshotPayload,\n\tUnloadedPayload,\n} from \"./types.js\";\n\nconst READ_TOOLS = new Set([\"read\", \"grep\", \"glob\"]);\n\nexport default function rulesEnginePlugin(pi: ExtensionAPI) {\n\tlet config: RulesConfig | null = null;\n\tlet rules: ParsedRule[] = [];\n\tlet cachedMatchHash = \"\";\n\tlet hasSentSnapshot = false;\n\tlet _lastCwd = \"\";\n\tlet lastMessages: unknown[] = [];\n\t/** Track which rule+file combos have been injected (ruleName -> Set<filePath>) */\n\tlet injectedRuleFiles: Map<string, Set<string>> = new Map();\n\n\tfunction rebuildMatchHistory(messages: unknown[]): MatchRecord[] {\n\t\tconst history: MatchRecord[] = [];\n\t\tfor (const msg of messages) {\n\t\t\tif ((msg as Record<string, unknown>).role !== \"toolResult\") continue;\n\t\t\tconst details = (msg as { details?: Record<string, unknown> }).details;\n\t\t\tif (!details?.rulesMatched) continue;\n\t\t\tconst rulesMatched = details.rulesMatched as MatchedRuleDetail[];\n\t\t\thistory.push({\n\t\t\t\tfilePath: (details.matchedFilePath as string) || \"\",\n\t\t\t\truleNames: rulesMatched.map((r) => r.name),\n\t\t\t\ttoolName: (msg as { toolName?: string }).toolName || \"\",\n\t\t\t\ttoolCallId: (msg as { toolCallId?: string }).toolCallId || \"\",\n\t\t\t\tseverity: rulesMatched.some((r) => r.severity === \"critical\" || r.severity === \"high\") ? \"warning\" : \"info\",\n\t\t\t\ttimestamp: (msg as { timestamp?: number }).timestamp || 0,\n\t\t\t\tmatchedRuleDetails: rulesMatched,\n\t\t\t});\n\t\t}\n\t\treturn history;\n\t}\n\n\tconst rawChannel = pi.registerChannel(RULES_CHANNEL_NAME);\n\tconst channel = createTypedChannel<RulesChannelContract>(rawChannel).server;\n\n\tchannel.handle(\"getSnapshot\", (params) => {\n\t\tconst unconditional = getUnconditionalRules();\n\t\tconst conditional = getConditionalRules();\n\t\tconst matchHistory = rebuildMatchHistory(lastMessages);\n\t\treturn {\n\t\t\ttype: \"snapshot\" as const,\n\t\t\trules: rules.map(toRuleDetail),\n\t\t\tinjectedRuleNames: unconditional.map((r) => r.name),\n\t\t\ttotalRules: rules.length,\n\t\t\tunconditionalCount: unconditional.length,\n\t\t\tconditionalCount: conditional.length,\n\t\t\tmatchHistory,\n\t\t\tlifecycleLog: [] as LifecycleEntry[],\n\t\t\tloadedAt: Date.now(),\n\t\t\tcacheTTL: config?.cacheTTL || 30000,\n\t\t};\n\t});\n\n\tfunction getUnconditionalRules(): ParsedRule[] {\n\t\treturn rules.filter((r) => r.isUnconditional);\n\t}\n\n\tfunction getConditionalRules(): ParsedRule[] {\n\t\treturn rules.filter((r) => !r.isUnconditional);\n\t}\n\n\tfunction getMatchingRules(targetPath: string): ParsedRule[] {\n\t\treturn getConditionalRules().filter((rule) => {\n\t\t\tconst globs = rule.frontmatter.globs ?? rule.frontmatter.paths;\n\t\t\tif (!globs || globs.length === 0) return false;\n\t\t\treturn matchesAnyGlob(globs, targetPath);\n\t\t});\n\t}\n\n\tasync function refreshRules(cwd: string): Promise<void> {\n\t\tconfig = await loadConfig(cwd);\n\t\trules = await getRules(cwd, config);\n\t}\n\n\tfunction toRuleDetail(r: ParsedRule): RuleDetail {\n\t\treturn {\n\t\t\tname: r.name,\n\t\t\ttitle: r.title,\n\t\t\tfilePath: r.filePath,\n\t\t\tscope: r.scope,\n\t\t\tsource: r.source,\n\t\t\tseverity: r.frontmatter.severity || (\"medium\" as RuleSeverity),\n\t\t\tisUnconditional: r.isUnconditional,\n\t\t\tglobs: r.frontmatter.globs ?? r.frontmatter.paths ?? [],\n\t\t\tdescription: r.frontmatter.description,\n\t\t};\n\t}\n\n\tfunction buildSnapshot(matchHistory: MatchRecord[], lifecycleLog: LifecycleEntry[]): SnapshotPayload {\n\t\tconst unconditional = getUnconditionalRules();\n\t\tconst conditional = getConditionalRules();\n\t\treturn {\n\t\t\ttype: \"snapshot\",\n\t\t\trules: rules.map(toRuleDetail),\n\t\t\tinjectedRuleNames: unconditional.map((r) => r.name),\n\t\t\ttotalRules: rules.length,\n\t\t\tunconditionalCount: unconditional.length,\n\t\t\tconditionalCount: conditional.length,\n\t\t\tmatchHistory,\n\t\t\tlifecycleLog,\n\t\t\tloadedAt: Date.now(),\n\t\t\tcacheTTL: config?.cacheTTL || 30000,\n\t\t};\n\t}\n\n\tfunction extractTargetPath(args: Record<string, unknown>): string | undefined {\n\t\tif (\"filePath\" in args && typeof args.filePath === \"string\") return args.filePath;\n\t\tif (\"path\" in args && typeof args.path === \"string\") return args.path;\n\t\tif (\"pattern\" in args && typeof args.pattern === \"string\") return args.pattern;\n\t\treturn undefined;\n\t}\n\n\tpi.registerTool(\n\t\tdefineTool({\n\t\t\tname: \"rules_list\",\n\t\t\tlabel: \"List Rules\",\n\t\t\tdescription: \"List all discovered rules from all configured directories across all scopes\",\n\t\t\tparameters: Type.Object({}),\n\t\t\tasync execute() {\n\t\t\t\tconst unconditional = getUnconditionalRules();\n\t\t\t\tconst conditional = getConditionalRules();\n\n\t\t\t\tconst byScope: Record<string, number> = {};\n\t\t\t\tfor (const r of rules) {\n\t\t\t\t\tbyScope[r.scope] = (byScope[r.scope] || 0) + 1;\n\t\t\t\t}\n\n\t\t\t\tlet output = `# Loaded Rules (${rules.length})\\n\\n`;\n\t\t\t\toutput += `Scopes: ${Object.entries(byScope)\n\t\t\t\t\t.map(([k, v]) => `${k}: ${v}`)\n\t\t\t\t\t.join(\", \")}\\n\\n`;\n\n\t\t\t\toutput += `**Unconditional** (${unconditional.length}):\\n`;\n\t\t\t\tfor (const rule of unconditional) {\n\t\t\t\t\toutput += `- ${rule.title} (${rule.source})\\n`;\n\t\t\t\t}\n\n\t\t\t\toutput += `\\n**Conditional** (${conditional.length}):\\n`;\n\t\t\t\tfor (const rule of conditional) {\n\t\t\t\t\toutput += `- ${rule.title} [${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(\", \")}] (${rule.source})\\n`;\n\t\t\t\t}\n\n\t\t\t\treturn { content: [{ type: \"text\", text: output }], details: undefined };\n\t\t\t},\n\t\t}),\n\t);\n\n\tpi.registerTool(\n\t\tdefineTool({\n\t\t\tname: \"rules_match\",\n\t\t\tlabel: \"Match Rules\",\n\t\t\tdescription: \"Find conditional rules that match a given file path by glob pattern\",\n\t\t\tparameters: Type.Object({\n\t\t\t\tfilePath: Type.String({ description: \"File path to match\" }),\n\t\t\t}),\n\t\t\tasync execute(_id, params) {\n\t\t\t\tconst matching = getMatchingRules(params.filePath);\n\t\t\t\tconst unconditional = getUnconditionalRules();\n\n\t\t\t\tlet output = `# Rule Match: ${params.filePath}\\n\\n`;\n\t\t\t\toutput += `**Unconditional** (always active, ${unconditional.length}):\\n`;\n\t\t\t\tfor (const r of unconditional) {\n\t\t\t\t\toutput += `- ${r.title}\\n`;\n\t\t\t\t}\n\t\t\t\toutput += `\\n**Conditional matches** (${matching.length}):\\n`;\n\t\t\t\tfor (const r of matching) {\n\t\t\t\t\tconst sev = r.frontmatter.severity || \"medium\";\n\t\t\t\t\toutput += `- [${sev}] ${r.title} (${(r.frontmatter.globs ?? r.frontmatter.paths)?.join(\", \")})\\n`;\n\t\t\t\t}\n\n\t\t\t\treturn { content: [{ type: \"text\", text: output }], details: undefined };\n\t\t\t},\n\t\t}),\n\t);\n\n\tpi.registerTool(\n\t\tdefineTool({\n\t\t\tname: \"rules_reload\",\n\t\t\tlabel: \"Reload Rules\",\n\t\t\tdescription: \"Force reload all rules from disk (clears cache and re-reads config)\",\n\t\t\tparameters: Type.Object({}),\n\t\t\tasync execute(_id, _params, _signal, _onUpdate, ctx) {\n\t\t\t\tinvalidateCache();\n\t\t\t\tawait refreshRules(ctx.cwd);\n\t\t\t\treturn {\n\t\t\t\t\tcontent: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\ttype: \"text\",\n\t\t\t\t\t\t\ttext: `Rules reloaded: ${rules.length} total (${getUnconditionalRules().length} unconditional, ${getConditionalRules().length} conditional)`,\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t\tdetails: undefined,\n\t\t\t\t};\n\t\t\t},\n\t\t}),\n\t);\n\n\tpi.registerTool(\n\t\tdefineTool({\n\t\t\tname: \"rules_show\",\n\t\t\tlabel: \"Show Rule\",\n\t\t\tdescription: \"Show the full content of a specific rule by name\",\n\t\t\tparameters: Type.Object({\n\t\t\t\tname: Type.String({ description: \"Rule name (filename without .md)\" }),\n\t\t\t}),\n\t\t\tasync execute(_id, params) {\n\t\t\t\tconst rule = rules.find((r) => r.name === params.name);\n\t\t\t\tif (!rule) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tcontent: [{ type: \"text\", text: `Rule '${params.name}' not found` }],\n\t\t\t\t\t\tisError: true,\n\t\t\t\t\t\tdetails: undefined,\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tlet output = `# ${rule.title}\\n\\n`;\n\t\t\t\toutput += `- **Name**: ${rule.name}\\n`;\n\t\t\t\toutput += `- **Scope**: ${rule.scope}\\n`;\n\t\t\t\toutput += `- **Source**: ${rule.source}\\n`;\n\t\t\t\toutput += `- **File**: ${rule.filePath}\\n`;\n\t\t\t\tif ((rule.frontmatter.globs ?? rule.frontmatter.paths)?.length) {\n\t\t\t\t\toutput += `- **Globs**: ${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(\", \")}\\n`;\n\t\t\t\t}\n\t\t\t\tif (rule.frontmatter.description) {\n\t\t\t\t\toutput += `- **Description**: ${rule.frontmatter.description}\\n`;\n\t\t\t\t}\n\t\t\t\toutput += `\\n${rule.content}`;\n\n\t\t\t\treturn { content: [{ type: \"text\", text: output }], details: undefined };\n\t\t\t},\n\t\t}),\n\t);\n\n\tpi.registerCommand(\"rules\", {\n\t\tdescription: \"Rules management (list, reload, check <path>, active)\",\n\t\thandler: async (args, ctx) => {\n\t\t\tconst parts = args.trim().split(/\\s+/);\n\t\t\tconst sub = parts[0] || \"list\";\n\n\t\t\tif (sub === \"list\" || sub === \"ls\") {\n\t\t\t\tctx.ui.notify(\n\t\t\t\t\t`${rules.length} rules loaded (${getUnconditionalRules().length} unconditional, ${getConditionalRules().length} conditional)`,\n\t\t\t\t\t\"info\",\n\t\t\t\t);\n\t\t\t} else if (sub === \"reload\") {\n\t\t\t\tinvalidateCache();\n\t\t\t\tawait refreshRules(ctx.cwd);\n\t\t\t\tctx.ui.notify(`Rules reloaded: ${rules.length} total`, \"info\");\n\t\t\t} else if (sub === \"check\" && parts[1]) {\n\t\t\t\tconst target = parts.slice(1).join(\" \");\n\t\t\t\tconst matching = getMatchingRules(target);\n\t\t\t\tctx.ui.notify(\n\t\t\t\t\tmatching.length > 0\n\t\t\t\t\t\t? `${matching.length} rules match ${target}: ${matching.map((r) => r.title).join(\", \")}`\n\t\t\t\t\t\t: `No conditional rules match ${target}`,\n\t\t\t\t\t\"info\",\n\t\t\t\t);\n\t\t\t} else if (sub === \"active\") {\n\t\t\t\tconst active = getUnconditionalRules();\n\t\t\t\tctx.ui.notify(\n\t\t\t\t\t`Active: ${active.length} unconditional (in system prompt), ${getConditionalRules().length} conditional (on file match)`,\n\t\t\t\t\t\"info\",\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tctx.ui.notify(\"Usage: /rules [list|reload|check <path>|active]\", \"info\");\n\t\t\t}\n\t\t},\n\t});\n\n\tpi.on(\"session_start\", async (_event, ctx) => {\n\t\t_lastCwd = ctx.cwd;\n\t\tawait refreshRules(ctx.cwd);\n\t\tctx.ui.setStatus(\"rules-engine\", `Rules: ${rules.length}`);\n\n\t\tconst unconditional = getUnconditionalRules();\n\t\tconst conditional = getConditionalRules();\n\n\t\tif (!hasSentSnapshot) {\n\t\t\thasSentSnapshot = true;\n\n\t\t\tconst scopeGroups = new Map<string, ParsedRule[]>();\n\t\t\tfor (const r of rules) {\n\t\t\t\tconst list = scopeGroups.get(r.scope) || [];\n\t\t\t\tlist.push(r);\n\t\t\t\tscopeGroups.set(r.scope, list);\n\t\t\t}\n\n\t\t\tconst scannedDirs: ScannedDir[] = [...scopeGroups.entries()].map(([scope, scopeRules]) => ({\n\t\t\t\tdir: scopeRules[0]?.source || scope,\n\t\t\t\tfileCount: scopeRules.length,\n\t\t\t\truleNames: scopeRules.map((r) => r.name),\n\t\t\t}));\n\n\t\t\tchannel.emit(\n\t\t\t\t\"snapshot\",\n\t\t\t\tbuildSnapshot(\n\t\t\t\t\t[],\n\t\t\t\t\t[\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tevent: \"loaded\",\n\t\t\t\t\t\t\tmessage: `Loaded ${rules.length} rules (${unconditional.length} unconditional, ${conditional.length} conditional)`,\n\t\t\t\t\t\t\truleCount: rules.length,\n\t\t\t\t\t\t\ttimestamp: Date.now(),\n\t\t\t\t\t\t\tdetails: {\n\t\t\t\t\t\t\t\tscannedDirs,\n\t\t\t\t\t\t\t\tconfigSource: config ? \".rules-config.json\" : \"default\",\n\t\t\t\t\t\t\t\tcacheHit: false,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t),\n\t\t\t);\n\t\t}\n\t});\n\n\tpi.on(\"before_agent_start\", async (event) => {\n\t\tconst unconditional = getUnconditionalRules();\n\n\t\tif (unconditional.length === 0) {\n\t\t\tchannel.emit(\"injected\", {\n\t\t\t\ttype: \"injected\",\n\t\t\t\truleNames: [],\n\t\t\t\tsystemPromptLength: event.systemPrompt.length,\n\t\t\t});\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst alreadyInjected = lastMessages.some(\n\t\t\t(msg) =>\n\t\t\t\t(msg as Record<string, unknown>).role === \"custom\" &&\n\t\t\t\t(msg as Record<string, unknown>).customType === \"rules-engine\",\n\t\t);\n\t\tif (alreadyInjected) {\n\t\t\tchannel.emit(\"injected\", {\n\t\t\t\ttype: \"injected\",\n\t\t\t\truleNames: unconditional.map((r) => r.name),\n\t\t\t\tsystemPromptLength: event.systemPrompt.length,\n\t\t\t\tdeduplicated: true,\n\t\t\t});\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst sources = [...new Set(unconditional.map((r) => r.source))];\n\t\tconst reminderContent = buildSystemReminderSection(unconditional, sources);\n\n\t\tchannel.emit(\"injected\", {\n\t\t\ttype: \"injected\",\n\t\t\truleNames: unconditional.map((r) => r.name),\n\t\t\tsystemPromptLength: event.systemPrompt.length,\n\t\t});\n\n\t\treturn {\n\t\t\tmessage: {\n\t\t\t\tcustomType: \"rules-engine\",\n\t\t\t\tcontent: reminderContent,\n\t\t\t\tdisplay: false,\n\t\t\t},\n\t\t};\n\t});\n\n\tpi.on(\"tool_result\", async (event) => {\n\t\tif (!READ_TOOLS.has(event.toolName)) return undefined;\n\n\t\tconst targetPath = extractTargetPath(event.input);\n\t\tif (!targetPath) return undefined;\n\n\t\tconst matching = getMatchingRules(targetPath);\n\t\tif (matching.length === 0) return undefined;\n\n\t\tconst matchedRuleDetails: MatchedRuleDetail[] = matching.map((r) => {\n\t\t\tconst ruleName = r.name;\n\t\t\tconst injectedFiles = injectedRuleFiles.get(ruleName);\n\t\t\tconst wasAlreadyLoaded = injectedFiles !== undefined && injectedFiles.has(targetPath);\n\n\t\t\treturn {\n\t\t\t\tname: ruleName,\n\t\t\t\ttitle: r.title,\n\t\t\t\tseverity: r.frontmatter.severity || (\"medium\" as RuleSeverity),\n\t\t\t\tmatchedGlob:\n\t\t\t\t\t(r.frontmatter.globs ?? r.frontmatter.paths)?.find((p) => matchesAnyGlob([p], targetPath)) ||\n\t\t\t\t\t(r.frontmatter.globs ?? r.frontmatter.paths)?.[0] ||\n\t\t\t\t\t\"\",\n\t\t\t\talreadyLoaded: wasAlreadyLoaded || undefined,\n\t\t\t};\n\t\t});\n\n\t\t// Determine which rules are newly injected vs already loaded\n\t\tconst newRules = matching.filter((r) => {\n\t\t\tconst injectedFiles = injectedRuleFiles.get(r.name);\n\t\t\treturn !injectedFiles || !injectedFiles.has(targetPath);\n\t\t});\n\t\tconst allAlreadyLoaded = newRules.length === 0;\n\n\t\t// Record that these rules have now been injected for this file\n\t\tfor (const r of matching) {\n\t\t\tlet injectedFiles = injectedRuleFiles.get(r.name);\n\t\t\tif (!injectedFiles) {\n\t\t\t\tinjectedFiles = new Set();\n\t\t\t\tinjectedRuleFiles.set(r.name, injectedFiles);\n\t\t\t}\n\t\t\tinjectedFiles.add(targetPath);\n\t\t}\n\n\t\tconst hasCritical = matching.some((r) => r.frontmatter.severity === \"critical\");\n\t\tconst hasHigh = matching.some((r) => r.frontmatter.severity === \"high\");\n\n\t\tchannel.emit(\"matched\", {\n\t\t\ttype: \"matched\",\n\t\t\tfilePath: targetPath,\n\t\t\tmatchedRules: matchedRuleDetails,\n\t\t\ttoolName: event.toolName,\n\t\t\ttoolCallId: event.toolCallId,\n\t\t\tseverity: hasCritical ? \"warning\" : hasHigh ? \"warning\" : \"info\",\n\t\t\ttimestamp: Date.now(),\n\t\t\talreadyLoaded: allAlreadyLoaded || undefined,\n\t\t});\n\n\t\t// Only inject content for NEW rules (skip if all already loaded)\n\t\tif (allAlreadyLoaded) {\n\t\t\treturn {\n\t\t\t\tdetails: {\n\t\t\t\t\t...((event.details as Record<string, unknown>) || {}),\n\t\t\t\t\trulesMatched: matchedRuleDetails,\n\t\t\t\t\tmatchedFilePath: targetPath,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\n\t\tconst contextSection = buildToolReminderSection(newRules, targetPath);\n\n\t\treturn {\n\t\t\tcontent: [...event.content, { type: \"text\" as const, text: `\\n\\n${contextSection}` }],\n\t\t\tdetails: {\n\t\t\t\t...((event.details as Record<string, unknown>) || {}),\n\t\t\t\trulesMatched: matchedRuleDetails,\n\t\t\t\tmatchedFilePath: targetPath,\n\t\t\t},\n\t\t};\n\t});\n\n\tpi.on(\"context\", async (event) => {\n\t\tlastMessages = event.messages;\n\t\tconst matchHistory = rebuildMatchHistory(event.messages);\n\n\t\tconst hash = JSON.stringify(matchHistory.map((r) => `${r.toolCallId}:${r.filePath}`));\n\t\tif (hash !== cachedMatchHash) {\n\t\t\tcachedMatchHash = hash;\n\t\t\tconst unconditional = getUnconditionalRules();\n\t\t\tconst conditional = getConditionalRules();\n\t\t\tchannel.emit(\"snapshot\", {\n\t\t\t\ttype: \"snapshot\",\n\t\t\t\trules: rules.map(toRuleDetail),\n\t\t\t\tinjectedRuleNames: unconditional.map((r) => r.name),\n\t\t\t\ttotalRules: rules.length,\n\t\t\t\tunconditionalCount: unconditional.length,\n\t\t\t\tconditionalCount: conditional.length,\n\t\t\t\tmatchHistory,\n\t\t\t\tlifecycleLog: [],\n\t\t\t\tloadedAt: Date.now(),\n\t\t\t\tcacheTTL: config?.cacheTTL || 30000,\n\t\t\t});\n\t\t}\n\n\t\treturn undefined;\n\t});\n\n\tpi.on(\"session_compact\", async (_event, ctx) => {\n\t\tcachedMatchHash = \"\";\n\t\tlastMessages = [];\n\t\tinjectedRuleFiles = new Map();\n\t\tctx.ui.setStatus(\"rules-engine\", `Rules: ${rules.length} (re-injected after compact)`);\n\t});\n\n\tpi.on(\"session_tree\", async () => {\n\t\tcachedMatchHash = \"\";\n\t\tlastMessages = [];\n\t\tinjectedRuleFiles = new Map();\n\t});\n\n\tpi.on(\"turn_end\", async () => {\n\t\tif (lastMessages.length === 0 && rules.length > 0) return;\n\t\tconst matchHistory = rebuildMatchHistory(lastMessages);\n\t\tconst hash = JSON.stringify(matchHistory.map((r) => `${r.toolCallId}:${r.filePath}`));\n\t\tif (hash !== cachedMatchHash) {\n\t\t\tcachedMatchHash = hash;\n\t\t\tchannel.emit(\"snapshot\", {\n\t\t\t\ttype: \"snapshot\",\n\t\t\t\trules: rules.map(toRuleDetail),\n\t\t\t\tinjectedRuleNames: getUnconditionalRules().map((r) => r.name),\n\t\t\t\ttotalRules: rules.length,\n\t\t\t\tunconditionalCount: getUnconditionalRules().length,\n\t\t\t\tconditionalCount: getConditionalRules().length,\n\t\t\t\tmatchHistory,\n\t\t\t\tlifecycleLog: [],\n\t\t\t\tloadedAt: Date.now(),\n\t\t\t\tcacheTTL: config?.cacheTTL || 30000,\n\t\t\t});\n\t\t}\n\t});\n\n\tpi.on(\"session_shutdown\", async (_event, ctx) => {\n\t\tchannel.emit(\"unloaded\", { type: \"unloaded\", reason: \"session_shutdown\" });\n\t\tctx.ui.setStatus(\"rules-engine\", undefined);\n\t});\n}\n", "import * as fs from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport * as path from \"node:path\";\nimport type { RulesConfig } from \"./types.js\";\n\nconst DEFAULT_CACHE_TTL = 30_000;\n\nconst DEFAULT_DIRS = {\n\tmanaged: [\"/etc/claude-code/.claude/rules\"],\n\tuser: [path.join(homedir(), \".claude\", \"rules\"), path.join(homedir(), \".config\", \"opencode\", \"rules\")],\n\tpi: [\".pi/rules\"],\n\tproject: [\".claude/rules\", \".opencode/rules\", \".trae/rules\"],\n};\n\nfunction defaultConfig(): RulesConfig {\n\treturn {\n\t\tcacheTTL: DEFAULT_CACHE_TTL,\n\t\tnotifyOnLoad: true,\n\t\tnotifyOnMatch: true,\n\t};\n}\n\nexport async function loadConfig(projectDir: string): Promise<RulesConfig> {\n\tconst configFiles = [\n\t\t\".rules-config.json\",\n\t\t\".pi/rules-config.json\",\n\t\t\".claude/rules-config.json\",\n\t\t\".opencode/rules-config.json\",\n\t];\n\n\tfor (const name of configFiles) {\n\t\tconst fp = path.resolve(projectDir, name);\n\t\tif (!fs.existsSync(fp)) continue;\n\t\ttry {\n\t\t\tconst raw = fs.readFileSync(fp, \"utf-8\");\n\t\t\tconst parsed = JSON.parse(raw);\n\t\t\treturn {\n\t\t\t\t...defaultConfig(),\n\t\t\t\t...parsed,\n\t\t\t\tcacheTTL: parsed.cacheTTL ?? DEFAULT_CACHE_TTL,\n\t\t\t\tnotifyOnLoad: parsed.notifyOnLoad ?? true,\n\t\t\t\tnotifyOnMatch: parsed.notifyOnMatch ?? true,\n\t\t\t};\n\t\t} catch (err) {\n\t\t\tconsole.debug(\"[rules-engine] config parse failed:\", err instanceof Error ? err.message : err);\n\t\t}\n\t}\n\n\treturn defaultConfig();\n}\n\nexport function resolveDirs(\n\tprojectDir: string,\n\tconfig: RulesConfig,\n): Array<{ scope: string; dir: string; source: string }> {\n\tconst sources = config.dirs || DEFAULT_DIRS;\n\tconst result: Array<{ scope: string; dir: string; source: string }> = [];\n\n\tfor (const [scope, paths] of Object.entries(sources)) {\n\t\tfor (const p of paths) {\n\t\t\tresult.push({\n\t\t\t\tscope,\n\t\t\t\tdir: p.startsWith(\"/\") || p.startsWith(\"~\") ? p.replace(/^~/, homedir()) : path.resolve(projectDir, p),\n\t\t\t\tsource: p,\n\t\t\t});\n\t\t}\n\t}\n\n\treturn result;\n}\n", "import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { ParsedRule, RuleCache, RuleFrontmatter } from \"./types.js\";\n\nfunction splitComma(val: string): string[] {\n\tconst result: string[] = [];\n\tlet depth = 0;\n\tlet current = \"\";\n\tfor (const ch of val) {\n\t\tif (ch === \"{\" || ch === \"(\" || ch === \"[\") depth++;\n\t\telse if (ch === \"}\" || ch === \")\" || ch === \"]\") depth--;\n\n\t\tif (ch === \",\" && depth === 0) {\n\t\t\tconst trimmed = current.trim().replace(/^[\"']|[\"']$/g, \"\");\n\t\t\tif (trimmed) result.push(trimmed);\n\t\t\tcurrent = \"\";\n\t\t} else {\n\t\t\tcurrent += ch;\n\t\t}\n\t}\n\tconst trimmed = current.trim().replace(/^[\"']|[\"']$/g, \"\");\n\tif (trimmed) result.push(trimmed);\n\treturn result;\n}\n\nexport function parseFrontmatter(content: string): { data: Record<string, unknown>; body: string } {\n\tconst frontmatterRegex = /^---\\r?\\n([\\s\\S]*?)\\n?---\\r?\\n([\\s\\S]*)$/;\n\tconst match = content.match(frontmatterRegex);\n\n\tif (!match) {\n\t\treturn { data: {}, body: content };\n\t}\n\n\tconst [, frontmatterStr, body] = match;\n\tconst data: Record<string, unknown> = {};\n\n\tconst lines = frontmatterStr.split(\"\\n\");\n\tlet i = 0;\n\twhile (i < lines.length) {\n\t\tconst line = lines[i];\n\t\tconst colonIndex = line.indexOf(\":\");\n\t\tif (colonIndex === -1) {\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst rawKey = line.slice(0, colonIndex).trim();\n\t\tlet value: string | string[] | null = line.slice(colonIndex + 1).trim();\n\n\t\tif (value === \"\" || value === \"null\" || value === \"undefined\") {\n\t\t\tconst listItems: string[] = [];\n\t\t\tlet j = i + 1;\n\t\t\twhile (j < lines.length) {\n\t\t\t\tconst subLine = lines[j];\n\t\t\t\tif (subLine.match(/^\\s*-\\s+/)) {\n\t\t\t\t\tlistItems.push(\n\t\t\t\t\t\tsubLine\n\t\t\t\t\t\t\t.replace(/^\\s*-\\s+/, \"\")\n\t\t\t\t\t\t\t.trim()\n\t\t\t\t\t\t\t.replace(/^[\"']|[\"']$/g, \"\"),\n\t\t\t\t\t);\n\t\t\t\t\tj++;\n\t\t\t\t} else if (subLine.trim() === \"\" || subLine.match(/^\\s+/)) {\n\t\t\t\t\tj++;\n\t\t\t\t} else {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (listItems.length > 0) {\n\t\t\t\tconst camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n\t\t\t\tdata[camelKey] = listItems;\n\t\t\t\ti = j;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tvalue = null;\n\t\t} else if (value.startsWith(\"[\") && value.endsWith(\"]\")) {\n\t\t\ttry {\n\t\t\t\tvalue = JSON.parse(value.replace(/'/g, '\"'));\n\t\t\t} catch (err) {\n\t\t\t\tconsole.debug(\"[rules-engine] JSON array parse failed:\", err instanceof Error ? err.message : err);\n\t\t\t\tvalue = (value as string)\n\t\t\t\t\t.slice(1, -1)\n\t\t\t\t\t.split(\",\")\n\t\t\t\t\t.map((v: string) => v.trim().replace(/^[\"']|[\"']$/g, \"\"));\n\t\t\t}\n\t\t} else if (value.startsWith('\"') && value.endsWith('\"')) {\n\t\t\tvalue = value.slice(1, -1);\n\t\t} else if (value.startsWith(\"'\") && value.endsWith(\"'\")) {\n\t\t\tvalue = value.slice(1, -1);\n\t\t}\n\n\t\tconst camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n\n\t\tif ((camelKey === \"paths\" || camelKey === \"globs\") && typeof value === \"string\") {\n\t\t\tdata[camelKey] = splitComma(value);\n\t\t} else {\n\t\t\tdata[camelKey] = value;\n\t\t}\n\t\ti++;\n\t}\n\n\treturn { data, body: body.trim() };\n}\n\nfunction extractTitle(body: string): string {\n\tfor (const line of body.split(\"\\n\")) {\n\t\tconst trimmed = line.trim();\n\t\tif (trimmed) {\n\t\t\treturn trimmed.replace(/^#+\\s*/, \"\").replace(/\\*\\*/g, \"\");\n\t\t}\n\t}\n\treturn \"Untitled Rule\";\n}\n\nfunction parsePaths(raw: unknown): string[] {\n\tif (!raw) return [];\n\tif (typeof raw === \"string\") {\n\t\treturn raw\n\t\t\t.split(\",\")\n\t\t\t.map((g) => g.trim())\n\t\t\t.filter(Boolean);\n\t}\n\tif (Array.isArray(raw)) return raw as string[];\n\treturn [];\n}\n\nexport function parseRuleFile(filePath: string, content: string): ParsedRule {\n\tconst { data, body } = parseFrontmatter(content);\n\tconst rawGlobs = data.globs ?? data.paths;\n\tconst globs = parsePaths(rawGlobs);\n\tconst rawPaths = data.paths;\n\tconst paths = parsePaths(rawPaths);\n\tconst isUnconditional = globs.length === 0 || (globs.length === 1 && globs[0] === \"**\");\n\n\tconst frontmatter: RuleFrontmatter = {};\n\tif (rawGlobs) {\n\t\tfrontmatter.globs = globs;\n\t\tif (rawPaths) {\n\t\t\tfrontmatter.paths = paths;\n\t\t} else {\n\t\t\tfrontmatter.paths = globs;\n\t\t}\n\t}\n\tif (data.description && typeof data.description === \"string\") frontmatter.description = data.description;\n\tif (data.severity && typeof data.severity === \"string\")\n\t\tfrontmatter.severity = data.severity as ParsedRule[\"frontmatter\"][\"severity\"];\n\tif (data.allowedTools)\n\t\tfrontmatter.allowedTools =\n\t\t\ttypeof data.allowedTools === \"string\" ? [data.allowedTools] : (data.allowedTools as string[]);\n\tif (data.whenToUse && typeof data.whenToUse === \"string\") frontmatter.whenToUse = data.whenToUse;\n\tif (data.notifyOnMatch !== undefined)\n\t\tfrontmatter.notifyOnMatch = data.notifyOnMatch === \"true\" || data.notifyOnMatch === true;\n\tif (data.skipInPrompt !== undefined)\n\t\tfrontmatter.skipInPrompt = data.skipInPrompt === \"true\" || data.skipInPrompt === true;\n\n\treturn {\n\t\tname: path.basename(filePath, path.extname(filePath)),\n\t\tfilePath,\n\t\ttitle: extractTitle(body),\n\t\tcontent: body.trim(),\n\t\tscope: \"project\",\n\t\tsource: \"\",\n\t\tfrontmatter,\n\t\tisUnconditional,\n\t};\n}\n\nfunction scanDir(dir: string, files: string[] = []): string[] {\n\tif (!fs.existsSync(dir)) return files;\n\tconst entries = fs.readdirSync(dir, { withFileTypes: true });\n\tfor (const entry of entries) {\n\t\tconst fullPath = path.join(dir, entry.name);\n\t\tif (entry.isDirectory()) {\n\t\t\tscanDir(fullPath, files);\n\t\t} else if (entry.isFile() && (entry.name.endsWith(\".md\") || entry.name.endsWith(\".mdc\"))) {\n\t\t\tfiles.push(fullPath);\n\t\t}\n\t}\n\treturn files;\n}\n\nexport function loadRules(rulesDir: string): RuleCache {\n\tconst rules: ParsedRule[] = [];\n\tconst unconditional: ParsedRule[] = [];\n\tconst conditional: ParsedRule[] = [];\n\n\tif (!fs.existsSync(rulesDir)) {\n\t\treturn { rules, unconditional, conditional, loadedAt: Date.now() };\n\t}\n\n\tconst files = scanDir(rulesDir);\n\n\tfor (const filePath of files) {\n\t\tconst content = fs.readFileSync(filePath, \"utf-8\");\n\t\tconst rule = parseRuleFile(filePath, content);\n\t\trules.push(rule);\n\t\tif (rule.isUnconditional) {\n\t\t\tunconditional.push(rule);\n\t\t} else {\n\t\t\tconditional.push(rule);\n\t\t}\n\t}\n\n\treturn { rules, unconditional, conditional, loadedAt: Date.now() };\n}\n", "import { resolveDirs } from \"./config.js\";\nimport { loadRules } from \"./loader.js\";\nimport type { ParsedRule, RulesConfig } from \"./types.js\";\n\nlet cache: { rules: ParsedRule[]; loadedAt: number } | null = null;\n\nexport async function getRules(projectDir: string, config: RulesConfig): Promise<ParsedRule[]> {\n\tif (cache && Date.now() - cache.loadedAt < config.cacheTTL) {\n\t\treturn cache.rules;\n\t}\n\n\tconst rules = await loadAllRules(projectDir, config);\n\tcache = { rules, loadedAt: Date.now() };\n\treturn rules;\n}\n\nexport function invalidateCache(): void {\n\tcache = null;\n}\n\nasync function loadAllRules(projectDir: string, config: RulesConfig): Promise<ParsedRule[]> {\n\tconst sources = resolveDirs(projectDir, config);\n\tconst result: ParsedRule[] = [];\n\tconst seen = new Set<string>();\n\n\tfor (const { scope, dir, source } of sources) {\n\t\tconst ruleCache = loadRules(dir);\n\t\tfor (const rule of ruleCache.rules) {\n\t\t\tif (seen.has(rule.filePath)) continue;\n\t\t\tseen.add(rule.filePath);\n\t\t\trule.scope = scope as ParsedRule[\"scope\"];\n\t\t\trule.source = source;\n\t\t\tresult.push(rule);\n\t\t}\n\t}\n\n\treturn result;\n}\n", "import * as fs from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport * as path from \"node:path\";\nimport type { RulesConfig } from \"./types.js\";\n\nconst DEFAULT_CACHE_TTL = 30_000;\n\nconst DEFAULT_DIRS = {\n\tmanaged: [\"/etc/claude-code/.claude/rules\"],\n\tuser: [path.join(homedir(), \".claude\", \"rules\"), path.join(homedir(), \".config\", \"opencode\", \"rules\")],\n\tpi: [\".pi/rules\"],\n\tproject: [\".claude/rules\", \".opencode/rules\", \".trae/rules\"],\n};\n\nfunction defaultConfig(): RulesConfig {\n\treturn {\n\t\tcacheTTL: DEFAULT_CACHE_TTL,\n\t\tnotifyOnLoad: true,\n\t\tnotifyOnMatch: true,\n\t};\n}\n\nexport async function loadConfig(projectDir: string): Promise<RulesConfig> {\n\tconst configFiles = [\n\t\t\".rules-config.json\",\n\t\t\".pi/rules-config.json\",\n\t\t\".claude/rules-config.json\",\n\t\t\".opencode/rules-config.json\",\n\t];\n\n\tfor (const name of configFiles) {\n\t\tconst fp = path.resolve(projectDir, name);\n\t\tif (!fs.existsSync(fp)) continue;\n\t\ttry {\n\t\t\tconst raw = fs.readFileSync(fp, \"utf-8\");\n\t\t\tconst parsed = JSON.parse(raw);\n\t\t\treturn {\n\t\t\t\t...defaultConfig(),\n\t\t\t\t...parsed,\n\t\t\t\tcacheTTL: parsed.cacheTTL ?? DEFAULT_CACHE_TTL,\n\t\t\t\tnotifyOnLoad: parsed.notifyOnLoad ?? true,\n\t\t\t\tnotifyOnMatch: parsed.notifyOnMatch ?? true,\n\t\t\t};\n\t\t} catch (err) {\n\t\t\tconsole.debug(\"[rules-engine] config parse failed:\", err instanceof Error ? err.message : err);\n\t\t}\n\t}\n\n\treturn defaultConfig();\n}\n\nexport function resolveDirs(\n\tprojectDir: string,\n\tconfig: RulesConfig,\n): Array<{ scope: string; dir: string; source: string }> {\n\tconst sources = config.dirs || DEFAULT_DIRS;\n\tconst result: Array<{ scope: string; dir: string; source: string }> = [];\n\n\tfor (const [scope, paths] of Object.entries(sources)) {\n\t\tfor (const p of paths) {\n\t\t\tresult.push({\n\t\t\t\tscope,\n\t\t\t\tdir: p.startsWith(\"/\") || p.startsWith(\"~\") ? p.replace(/^~/, homedir()) : path.resolve(projectDir, p),\n\t\t\t\tsource: p,\n\t\t\t});\n\t\t}\n\t}\n\n\treturn result;\n}\n", "import type { ParsedRule } from \"./types.js\";\n\nconst SEVERITY_ICONS: Record<string, string> = {\n\tcritical: \"\uD83D\uDD34\",\n\thigh: \"\uD83D\uDFE0\",\n\tmedium: \"\uD83D\uDFE1\",\n\tlow: \"\uD83D\uDD35\",\n\thint: \"\uD83D\uDCA1\",\n};\n\nexport function buildSystemReminderSection(rules: ParsedRule[], sources: string[]): string {\n\tif (rules.length === 0) return \"\";\n\n\tconst lines: string[] = [\n\t\t\"<system-reminder>\",\n\t\t`Instructions from: ${sources.join(\", \")}`,\n\t\t\"The following rules are always active. Follow them strictly.\",\n\t\t\"\",\n\t];\n\n\tfor (const rule of rules) {\n\t\tlines.push(`Rule: ${rule.name} \u2014 ${rule.title}`);\n\t\tif (rule.frontmatter.description) {\n\t\t\tlines.push(`> ${rule.frontmatter.description}`);\n\t\t}\n\t\tlines.push(\"\");\n\t\tlines.push(rule.content);\n\t\tlines.push(\"\");\n\t}\n\n\tlines.push(\"</system-reminder>\");\n\treturn lines.join(\"\\n\");\n}\n\nexport function buildToolReminderSection(rules: ParsedRule[], targetPath: string): string {\n\tif (rules.length === 0) return \"\";\n\n\tconst lines: string[] = [\n\t\t\"<system-reminder>\",\n\t\t`Conditional rules matched for ${targetPath}:`,\n\t\t\"\",\n\t];\n\n\tfor (const rule of rules) {\n\t\tconst severity = rule.frontmatter.severity || \"medium\";\n\t\tconst icon = SEVERITY_ICONS[severity] || \"\uD83D\uDFE1\";\n\t\tlines.push(`Rule: ${icon} ${rule.title} [${severity}]`);\n\t\tif (rule.frontmatter.description) {\n\t\t\tlines.push(`> ${rule.frontmatter.description}`);\n\t\t}\n\t\tlines.push(\"\");\n\t\tlines.push(rule.content);\n\t\tlines.push(\"\");\n\t}\n\n\tlines.push(\"</system-reminder>\");\n\treturn lines.join(\"\\n\");\n}\n\nexport const buildSystemPromptSection = buildSystemReminderSection;\nexport const buildToolContextSection = buildToolReminderSection;\n\nexport function buildCompactContext(rules: ParsedRule[]): string {\n\tif (rules.length === 0) return \"\";\n\n\tconst lines: string[] = [\"## Active Rules (persist across compaction)\", \"\"];\n\n\tfor (const rule of rules) {\n\t\tconst desc = rule.frontmatter.description || rule.content.split(\"\\n\")[0];\n\t\tlines.push(`- **${rule.title}** (${rule.name}): ${desc}`);\n\t}\n\n\treturn lines.join(\"\\n\");\n}\n", "// A simple implementation of make-array\nfunction makeArray (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst UNDEFINED = undefined\nconst EMPTY = ''\nconst SPACE = ' '\nconst ESCAPE = '\\\\'\nconst REGEX_TEST_BLANK_LINE = /^\\s+$/\nconst REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\\\]|^)\\\\$/\nconst REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/\nconst REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\\\#/\nconst REGEX_SPLITALL_CRLF = /\\r?\\n/g\n\n// Invalid:\n// - /foo,\n// - ./foo,\n// - ../foo,\n// - .\n// - ..\n// Valid:\n// - .foo\nconst REGEX_TEST_INVALID_PATH = /^\\.{0,2}\\/|^\\.{1,2}$/\n\nconst REGEX_TEST_TRAILING_SLASH = /\\/$/\n\nconst SLASH = '/'\n\n// Do not use ternary expression here, since \"istanbul ignore next\" is buggy\nlet TMP_KEY_IGNORE = 'node-ignore'\n/* istanbul ignore else */\nif (typeof Symbol !== 'undefined') {\n  TMP_KEY_IGNORE = Symbol.for('node-ignore')\n}\nconst KEY_IGNORE = TMP_KEY_IGNORE\n\nconst define = (object, key, value) => {\n  Object.defineProperty(object, key, {value})\n  return value\n}\n\nconst REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g\n\nconst RETURN_FALSE = () => false\n\n// Sanitize the range of a regular expression\n// The cases are complicated, see test cases for details\nconst sanitizeRange = range => range.replace(\n  REGEX_REGEXP_RANGE,\n  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)\n    ? match\n    // Invalid range (out of order) which is ok for gitignore rules but\n    //   fatal for JavaScript regular expression, so eliminate it.\n    : EMPTY\n)\n\n// See fixtures #59\nconst cleanRangeBackSlash = slashes => {\n  const {length} = slashes\n  return slashes.slice(0, length - length % 2)\n}\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\nconst REPLACERS = [\n\n  [\n    // Remove BOM\n    // TODO:\n    // Other similar zero-width characters?\n    /^\\uFEFF/,\n    () => EMPTY\n  ],\n\n  // > Trailing spaces are ignored unless they are quoted with backslash (\"\\\")\n  [\n    // (a\\ ) -> (a )\n    // (a  ) -> (a)\n    // (a ) -> (a)\n    // (a \\ ) -> (a  )\n    /((?:\\\\\\\\)*?)(\\\\?\\s+)$/,\n    (_, m1, m2) => m1 + (\n      m2.indexOf('\\\\') === 0\n        ? SPACE\n        : EMPTY\n    )\n  ],\n\n  // Replace (\\ ) with ' '\n  // (\\ ) -> ' '\n  // (\\\\ ) -> '\\\\ '\n  // (\\\\\\ ) -> '\\\\ '\n  [\n    /(\\\\+?)\\s/g,\n    (_, m1) => {\n      const {length} = m1\n      return m1.slice(0, length - length % 2) + SPACE\n    }\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\$.|*+(){^]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^'\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/'\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*\\\\\\*\\\\\\*\\\\\\//,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?'\n  ],\n\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    /^(?=[^^])/,\n    function startingReplacer () {\n      // If has a slash `/` at the beginning or middle\n      return !/\\/(?!$)/.test(this)\n        // > Prior to 2.22.1\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n\n        // After 2.22.1 (compatible but clearer)\n        // > If there is a separator at the beginning or middle (or both)\n        // > of the pattern, then the pattern is relative to the directory\n        // > level of the particular .gitignore file itself.\n        // > Otherwise the pattern may also match at any level below\n        // > the .gitignore level.\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (_, index, str) => index + 6 < str.length\n\n      // case: /**/\n      // > A slash followed by two consecutive asterisks then a slash matches\n      // >   zero or more directories.\n      // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n      // '/**/'\n      ? '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder\n      : '\\\\/.+'\n  ],\n\n  // normal intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule,\n    //    coz trailing single wildcard will be handed by [trailing wildcard]\n    /(^|[^\\\\]+)(\\\\\\*)+(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (_, p1, p2) => {\n      // 1.\n      // > An asterisk \"*\" matches anything except a slash.\n      // 2.\n      // > Other consecutive asterisks are considered regular asterisks\n      // > and will match according to the previous rules.\n      const unescaped = p2.replace(/\\\\\\*/g, '[^\\\\/]*')\n      return p1 + unescaped\n    }\n  ],\n\n  [\n    // unescape, revert step 3 except for back slash\n    // For example, if a user escape a '\\\\*',\n    // after step 3, the result will be '\\\\\\\\\\\\*'\n    /\\\\\\\\\\\\(?=[$.|*+(){^])/g,\n    () => ESCAPE\n  ],\n\n  [\n    // '\\\\\\\\' -> '\\\\'\n    /\\\\\\\\/g,\n    () => ESCAPE\n  ],\n\n  [\n    // > The range notation, e.g. [a-zA-Z],\n    // > can be used to match one of the characters in a range.\n\n    // `\\` is escaped by step 3\n    /(\\\\)?\\[([^\\]/]*?)(\\\\*)($|\\])/g,\n    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE\n      // '\\\\[bar]' -> '\\\\\\\\[bar\\\\]'\n      ? `\\\\[${range}${cleanRangeBackSlash(endEscape)}${close}`\n      : close === ']'\n        ? endEscape.length % 2 === 0\n          // A normal case, and it is a range notation\n          // '[bar]'\n          // '[bar\\\\\\\\]'\n          ? `[${sanitizeRange(range)}${endEscape}]`\n          // Invalid range notaton\n          // '[bar\\\\]' -> '[bar\\\\\\\\]'\n          : '[]'\n        : '[]'\n  ],\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    /(?:[^*])$/,\n\n    // WTF!\n    // https://git-scm.com/docs/gitignore\n    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)\n    // which re-fixes #24, #38\n\n    // > If there is a separator at the end of the pattern then the pattern\n    // > will only match directories, otherwise the pattern can match both\n    // > files and directories.\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    match => /\\/$/.test(match)\n      // foo/ will not match 'foo'\n      ? `${match}$`\n      // foo matches 'foo' and 'foo/'\n      : `${match}(?=$|\\\\/$)`\n  ]\n]\n\nconst REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\\\\/)?\\\\\\*$/\nconst MODE_IGNORE = 'regex'\nconst MODE_CHECK_IGNORE = 'checkRegex'\nconst UNDERSCORE = '_'\n\nconst TRAILING_WILD_CARD_REPLACERS = {\n  [MODE_IGNORE] (_, p1) {\n    const prefix = p1\n      // '\\^':\n      // '/*' does not match EMPTY\n      // '/*' does not match everything\n\n      // '\\\\\\/':\n      // 'abc/*' does not match 'abc/'\n      ? `${p1}[^/]+`\n\n      // 'a*' matches 'a'\n      // 'a*' matches 'aa'\n      : '[^/]*'\n\n    return `${prefix}(?=$|\\\\/$)`\n  },\n\n  [MODE_CHECK_IGNORE] (_, p1) {\n    // When doing `git check-ignore`\n    const prefix = p1\n      // '\\\\\\/':\n      // 'abc/*' DOES match 'abc/' !\n      ? `${p1}[^/]*`\n\n      // 'a*' matches 'a'\n      // 'a*' matches 'aa'\n      : '[^/]*'\n\n    return `${prefix}(?=$|\\\\/$)`\n  }\n}\n\n// @param {pattern}\nconst makeRegexPrefix = pattern => REPLACERS.reduce(\n  (prev, [matcher, replacer]) =>\n    prev.replace(matcher, replacer.bind(pattern)),\n  pattern\n)\n\nconst isString = subject => typeof subject === 'string'\n\n// > A blank line matches no files, so it can serve as a separator for readability.\nconst checkPattern = pattern => pattern\n  && isString(pattern)\n  && !REGEX_TEST_BLANK_LINE.test(pattern)\n  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)\n\n  // > A line starting with # serves as a comment.\n  && pattern.indexOf('#') !== 0\n\nconst splitPattern = pattern => pattern\n.split(REGEX_SPLITALL_CRLF)\n.filter(Boolean)\n\nclass IgnoreRule {\n  constructor (\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    prefix\n  ) {\n    this.pattern = pattern\n    this.mark = mark\n    this.negative = negative\n\n    define(this, 'body', body)\n    define(this, 'ignoreCase', ignoreCase)\n    define(this, 'regexPrefix', prefix)\n  }\n\n  get regex () {\n    const key = UNDERSCORE + MODE_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_IGNORE, key)\n  }\n\n  get checkRegex () {\n    const key = UNDERSCORE + MODE_CHECK_IGNORE\n\n    if (this[key]) {\n      return this[key]\n    }\n\n    return this._make(MODE_CHECK_IGNORE, key)\n  }\n\n  _make (mode, key) {\n    const str = this.regexPrefix.replace(\n      REGEX_REPLACE_TRAILING_WILDCARD,\n\n      // It does not need to bind pattern\n      TRAILING_WILD_CARD_REPLACERS[mode]\n    )\n\n    const regex = this.ignoreCase\n      ? new RegExp(str, 'i')\n      : new RegExp(str)\n\n    return define(this, key, regex)\n  }\n}\n\nconst createRule = ({\n  pattern,\n  mark\n}, ignoreCase) => {\n  let negative = false\n  let body = pattern\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (body.indexOf('!') === 0) {\n    negative = true\n    body = body.substr(1)\n  }\n\n  body = body\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')\n\n  const regexPrefix = makeRegexPrefix(body)\n\n  return new IgnoreRule(\n    pattern,\n    mark,\n    body,\n    ignoreCase,\n    negative,\n    regexPrefix\n  )\n}\n\nclass RuleManager {\n  constructor (ignoreCase) {\n    this._ignoreCase = ignoreCase\n    this._rules = []\n  }\n\n  _add (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE]) {\n      this._rules = this._rules.concat(pattern._rules._rules)\n      this._added = true\n      return\n    }\n\n    if (isString(pattern)) {\n      pattern = {\n        pattern\n      }\n    }\n\n    if (checkPattern(pattern.pattern)) {\n      const rule = createRule(pattern, this._ignoreCase)\n      this._added = true\n      this._rules.push(rule)\n    }\n  }\n\n  // @param {Array<string> | string | Ignore} pattern\n  add (pattern) {\n    this._added = false\n\n    makeArray(\n      isString(pattern)\n        ? splitPattern(pattern)\n        : pattern\n    ).forEach(this._add, this)\n\n    return this._added\n  }\n\n  // Test one single path without recursively checking parent directories\n  //\n  // - checkUnignored `boolean` whether should check if the path is unignored,\n  //   setting `checkUnignored` to `false` could reduce additional\n  //   path matching.\n  // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`\n\n  // @returns {TestResult} true if a file is ignored\n  test (path, checkUnignored, mode) {\n    let ignored = false\n    let unignored = false\n    let matchedRule\n\n    this._rules.forEach(rule => {\n      const {negative} = rule\n\n      //          |           ignored : unignored\n      // -------- | ---------------------------------------\n      // negative |   0:0   |   0:1   |   1:0   |   1:1\n      // -------- | ------- | ------- | ------- | --------\n      //     0    |  TEST   |  TEST   |  SKIP   |    X\n      //     1    |  TESTIF |  SKIP   |  TEST   |    X\n\n      // - SKIP: always skip\n      // - TEST: always test\n      // - TESTIF: only test if checkUnignored\n      // - X: that never happen\n      if (\n        unignored === negative && ignored !== unignored\n        || negative && !ignored && !unignored && !checkUnignored\n      ) {\n        return\n      }\n\n      const matched = rule[mode].test(path)\n\n      if (!matched) {\n        return\n      }\n\n      ignored = !negative\n      unignored = negative\n\n      matchedRule = negative\n        ? UNDEFINED\n        : rule\n    })\n\n    const ret = {\n      ignored,\n      unignored\n    }\n\n    if (matchedRule) {\n      ret.rule = matchedRule\n    }\n\n    return ret\n  }\n}\n\nconst throwError = (message, Ctor) => {\n  throw new Ctor(message)\n}\n\nconst checkPath = (path, originalPath, doThrow) => {\n  if (!isString(path)) {\n    return doThrow(\n      `path must be a string, but got \\`${originalPath}\\``,\n      TypeError\n    )\n  }\n\n  // We don't know if we should ignore EMPTY, so throw\n  if (!path) {\n    return doThrow(`path must not be empty`, TypeError)\n  }\n\n  // Check if it is a relative path\n  if (checkPath.isNotRelative(path)) {\n    const r = '`path.relative()`d'\n    return doThrow(\n      `path should be a ${r} string, but got \"${originalPath}\"`,\n      RangeError\n    )\n  }\n\n  return true\n}\n\nconst isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)\n\ncheckPath.isNotRelative = isNotRelative\n\n// On windows, the following function will be replaced\n/* istanbul ignore next */\ncheckPath.convert = p => p\n\n\nclass Ignore {\n  constructor ({\n    ignorecase = true,\n    ignoreCase = ignorecase,\n    allowRelativePaths = false\n  } = {}) {\n    define(this, KEY_IGNORE, true)\n\n    this._rules = new RuleManager(ignoreCase)\n    this._strictPathCheck = !allowRelativePaths\n    this._initCache()\n  }\n\n  _initCache () {\n    // A cache for the result of `.ignores()`\n    this._ignoreCache = Object.create(null)\n\n    // A cache for the result of `.test()`\n    this._testCache = Object.create(null)\n  }\n\n  add (pattern) {\n    if (this._rules.add(pattern)) {\n      // Some rules have just added to the ignore,\n      //   making the behavior changed,\n      //   so we need to re-initialize the result cache\n      this._initCache()\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  // @returns {TestResult}\n  _test (originalPath, cache, checkUnignored, slices) {\n    const path = originalPath\n      // Supports nullable path\n      && checkPath.convert(originalPath)\n\n    checkPath(\n      path,\n      originalPath,\n      this._strictPathCheck\n        ? throwError\n        : RETURN_FALSE\n    )\n\n    return this._t(path, cache, checkUnignored, slices)\n  }\n\n  checkIgnore (path) {\n    // If the path doest not end with a slash, `.ignores()` is much equivalent\n    //   to `git check-ignore`\n    if (!REGEX_TEST_TRAILING_SLASH.test(path)) {\n      return this.test(path)\n    }\n\n    const slices = path.split(SLASH).filter(Boolean)\n    slices.pop()\n\n    if (slices.length) {\n      const parent = this._t(\n        slices.join(SLASH) + SLASH,\n        this._testCache,\n        true,\n        slices\n      )\n\n      if (parent.ignored) {\n        return parent\n      }\n    }\n\n    return this._rules.test(path, false, MODE_CHECK_IGNORE)\n  }\n\n  _t (\n    // The path to be tested\n    path,\n\n    // The cache for the result of a certain checking\n    cache,\n\n    // Whether should check if the path is unignored\n    checkUnignored,\n\n    // The path slices\n    slices\n  ) {\n    if (path in cache) {\n      return cache[path]\n    }\n\n    if (!slices) {\n      // path/to/a.js\n      // ['path', 'to', 'a.js']\n      slices = path.split(SLASH).filter(Boolean)\n    }\n\n    slices.pop()\n\n    // If the path has no parent directory, just test it\n    if (!slices.length) {\n      return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE)\n    }\n\n    const parent = this._t(\n      slices.join(SLASH) + SLASH,\n      cache,\n      checkUnignored,\n      slices\n    )\n\n    // If the path contains a parent directory, check the parent first\n    return cache[path] = parent.ignored\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      ? parent\n      : this._rules.test(path, checkUnignored, MODE_IGNORE)\n  }\n\n  ignores (path) {\n    return this._test(path, this._ignoreCache, false).ignored\n  }\n\n  createFilter () {\n    return path => !this.ignores(path)\n  }\n\n  filter (paths) {\n    return makeArray(paths).filter(this.createFilter())\n  }\n\n  // @returns {TestResult}\n  test (path) {\n    return this._test(path, this._testCache, true)\n  }\n}\n\nconst factory = options => new Ignore(options)\n\nconst isPathValid = path =>\n  checkPath(path && checkPath.convert(path), path, RETURN_FALSE)\n\n/* istanbul ignore next */\nconst setupWindows = () => {\n  /* eslint no-control-regex: \"off\" */\n  const makePosix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[\"<>|\\u0000-\\u001F]+/u.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/')\n\n  checkPath.convert = makePosix\n\n  // 'C:\\\\foo'     <- 'C:\\\\foo' has been converted to 'C:/'\n  // 'd:\\\\foo'\n  const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\\//i\n  checkPath.isNotRelative = path =>\n    REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path)\n    || isNotRelative(path)\n}\n\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore next */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && process.platform === 'win32'\n) {\n  setupWindows()\n}\n\n// COMMONJS_EXPORTS ////////////////////////////////////////////////////////////\n\nmodule.exports = factory\n\n// Although it is an anti-pattern,\n//   it is still widely misused by a lot of libraries in github\n// Ref: https://github.com/search?q=ignore.default%28%29&type=code\nfactory.default = factory\n\nmodule.exports.isPathValid = isPathValid\n\n// For testing purposes\ndefine(module.exports, Symbol.for('setupWindows'), setupWindows)\n", "import ignore from \"ignore\";\n\nfunction expandBraces(pattern: string): string[] {\n\tconst braceIndex = pattern.indexOf(\"{\");\n\tif (braceIndex === -1) return [pattern];\n\tconst closeIndex = pattern.indexOf(\"}\", braceIndex);\n\tif (closeIndex === -1) return [pattern];\n\n\tconst prefix = pattern.slice(0, braceIndex);\n\tconst suffix = pattern.slice(closeIndex + 1);\n\tconst options = pattern.slice(braceIndex + 1, closeIndex).split(\",\");\n\n\tconst results: string[] = [];\n\tfor (const opt of options) {\n\t\tresults.push(...expandBraces(prefix + opt.trim() + suffix));\n\t}\n\treturn results;\n}\n\nfunction expandPatterns(patterns: string[]): string[] {\n\tconst expanded: string[] = [];\n\tfor (const p of patterns) {\n\t\texpanded.push(...expandBraces(p));\n\t}\n\treturn expanded;\n}\n\nfunction toRelative(filePath: string): string {\n\tconst normalized = filePath.replace(/\\\\/g, \"/\");\n\treturn normalized.startsWith(\"/\") ? normalized.slice(1) : normalized;\n}\n\nexport function matchGlob(pattern: string, target: string): boolean {\n\tif (!pattern || !target) return false;\n\tconst expanded = expandBraces(pattern);\n\tconst ig = ignore().add(expanded);\n\treturn ig.ignores(toRelative(target));\n}\n\nexport function matchesAnyGlob(globs: string[], filePath: string): boolean {\n\tif (!filePath || globs.length === 0) return false;\n\tconst expanded = expandPatterns(globs);\n\tconst ig = ignore().add(expanded);\n\treturn ig.ignores(toRelative(filePath));\n}\n\nexport function createMatcher(globs: string[]): (filePath: string) => boolean {\n\tif (globs.length === 0) return () => false;\n\tconst expanded = expandPatterns(globs);\n\tconst ig = ignore().add(expanded);\n\treturn (filePath: string) => ig.ignores(toRelative(filePath));\n}\n", "export type RuleSeverity = \"critical\" | \"high\" | \"medium\" | \"low\" | \"hint\";\n\nexport type RuleScope = \"user\" | \"pi\" | \"project\" | \"managed\";\n\nexport interface RuleFrontmatter {\n\tglobs?: string[];\n\tpaths?: string[];\n\tdescription?: string;\n\tseverity?: RuleSeverity;\n\tallowedTools?: string[];\n\twhenToUse?: string;\n\tversion?: string;\n\tmodel?: string;\n\tskills?: string;\n\teffort?: string;\n\tuserInvocable?: string;\n\tcontext?: \"inline\" | \"fork\";\n\tagent?: string;\n\tshell?: string;\n\tnotifyOnMatch?: boolean;\n\tskipInPrompt?: boolean;\n}\n\nexport interface ParsedRule {\n\tname: string;\n\tfilePath: string;\n\ttitle: string;\n\tcontent: string;\n\tscope: RuleScope;\n\tsource: string;\n\tfrontmatter: RuleFrontmatter;\n\tisUnconditional: boolean;\n}\n\nexport interface RuleCache {\n\trules: ParsedRule[];\n\tunconditional: ParsedRule[];\n\tconditional: ParsedRule[];\n\tloadedAt: number;\n}\n\nexport interface CachedRules {\n\trules: ParsedRule[];\n\tloadedAt: number;\n}\n\nexport interface RulesConfig {\n\tcacheTTL: number;\n\tnotifyOnLoad: boolean;\n\tnotifyOnMatch: boolean;\n\tdirs?: {\n\t\tuser?: string[];\n\t\tpi?: string[];\n\t\tproject?: string[];\n\t\tmanaged?: string[];\n\t};\n}\n\nexport interface RuleDetail {\n\tname: string;\n\ttitle: string;\n\tfilePath: string;\n\tscope: RuleScope;\n\tsource: string;\n\tseverity: RuleSeverity;\n\tisUnconditional: boolean;\n\tglobs: string[];\n\tdescription?: string;\n}\n\nexport interface ScannedDir {\n\tdir: string;\n\tfileCount: number;\n\truleNames: string[];\n}\n\nexport interface MatchedRuleDetail {\n\tname: string;\n\ttitle: string;\n\tseverity: RuleSeverity;\n\tmatchedGlob: string;\n}\n\nexport interface MatchRecord {\n\tfilePath: string;\n\truleNames: string[];\n\ttoolName: string;\n\ttoolCallId: string;\n\tseverity: \"info\" | \"warning\";\n\ttimestamp: number;\n\tmatchedRuleDetails?: MatchedRuleDetail[];\n}\n\nexport interface LifecycleEntry {\n\tevent: \"loaded\" | \"restored\" | \"injected\" | \"reloaded\" | \"unloaded\" | \"expired\";\n\tmessage: string;\n\truleCount?: number;\n\ttimestamp: number;\n\tdetails?: {\n\t\tscannedDirs?: ScannedDir[];\n\t\tconfigSource?: string;\n\t\tcacheHit?: boolean;\n\t\tinjectedRules?: Array<{ name: string; promptDelta: number }>;\n\t};\n}\n\nexport interface SnapshotPayload {\n\ttype: \"snapshot\";\n\trules: RuleDetail[];\n\tinjectedRuleNames: string[];\n\ttotalRules: number;\n\tunconditionalCount: number;\n\tconditionalCount: number;\n\tmatchHistory: MatchRecord[];\n\tlifecycleLog: LifecycleEntry[];\n\tloadedAt: number;\n\tcacheTTL: number;\n}\n\nexport interface MatchedPayload {\n\ttype: \"matched\";\n\tfilePath: string;\n\tmatchedRules: MatchedRuleDetail[];\n\ttoolName: string;\n\ttoolCallId: string;\n\tseverity: \"info\" | \"warning\";\n\ttimestamp: number;\n}\n\nexport interface InjectedPayload {\n\ttype: \"injected\";\n\truleNames: string[];\n\tsystemPromptLength: number;\n}\n\nexport interface ReloadedPayload {\n\ttype: \"reloaded\";\n\trules: RuleDetail[];\n\tloadedAt: number;\n}\n\nexport interface UnloadedPayload {\n\ttype: \"unloaded\";\n\treason: string;\n}\n\nexport type RulesChannelEvent = SnapshotPayload | MatchedPayload | InjectedPayload | ReloadedPayload | UnloadedPayload;\n\nexport const RULES_CHANNEL_NAME = \"rules-engine\";\n\nexport interface RulesChannelContract {\n\tmethods: {\n\t\tgetSnapshot: {\n\t\t\tparams: { cwd?: string };\n\t\t\treturn: SnapshotPayload;\n\t\t};\n\t};\n\tevents: {\n\t\tsnapshot: SnapshotPayload;\n\t\tmatched: MatchedPayload;\n\t\tinjected: InjectedPayload;\n\t\treloaded: ReloadedPayload;\n\t\tunloaded: UnloadedPayload;\n\t};\n}\n", "import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { ParsedRule, RuleCache, RuleFrontmatter } from \"./types.js\";\n\nfunction splitComma(val: string): string[] {\n\tconst result: string[] = [];\n\tlet depth = 0;\n\tlet current = \"\";\n\tfor (const ch of val) {\n\t\tif (ch === \"{\" || ch === \"(\" || ch === \"[\") depth++;\n\t\telse if (ch === \"}\" || ch === \")\" || ch === \"]\") depth--;\n\n\t\tif (ch === \",\" && depth === 0) {\n\t\t\tconst trimmed = current.trim().replace(/^[\"']|[\"']$/g, \"\");\n\t\t\tif (trimmed) result.push(trimmed);\n\t\t\tcurrent = \"\";\n\t\t} else {\n\t\t\tcurrent += ch;\n\t\t}\n\t}\n\tconst trimmed = current.trim().replace(/^[\"']|[\"']$/g, \"\");\n\tif (trimmed) result.push(trimmed);\n\treturn result;\n}\n\nexport function parseFrontmatter(content: string): { data: Record<string, unknown>; body: string } {\n\tconst frontmatterRegex = /^---\\r?\\n([\\s\\S]*?)\\n?---\\r?\\n([\\s\\S]*)$/;\n\tconst match = content.match(frontmatterRegex);\n\n\tif (!match) {\n\t\treturn { data: {}, body: content };\n\t}\n\n\tconst [, frontmatterStr, body] = match;\n\tconst data: Record<string, unknown> = {};\n\n\tconst lines = frontmatterStr.split(\"\\n\");\n\tlet i = 0;\n\twhile (i < lines.length) {\n\t\tconst line = lines[i];\n\t\tconst colonIndex = line.indexOf(\":\");\n\t\tif (colonIndex === -1) {\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst rawKey = line.slice(0, colonIndex).trim();\n\t\tlet value: string | string[] | null = line.slice(colonIndex + 1).trim();\n\n\t\tif (value === \"\" || value === \"null\" || value === \"undefined\") {\n\t\t\tconst listItems: string[] = [];\n\t\t\tlet j = i + 1;\n\t\t\twhile (j < lines.length) {\n\t\t\t\tconst subLine = lines[j];\n\t\t\t\tif (subLine.match(/^\\s*-\\s+/)) {\n\t\t\t\t\tlistItems.push(\n\t\t\t\t\t\tsubLine\n\t\t\t\t\t\t\t.replace(/^\\s*-\\s+/, \"\")\n\t\t\t\t\t\t\t.trim()\n\t\t\t\t\t\t\t.replace(/^[\"']|[\"']$/g, \"\"),\n\t\t\t\t\t);\n\t\t\t\t\tj++;\n\t\t\t\t} else if (subLine.trim() === \"\" || subLine.match(/^\\s+/)) {\n\t\t\t\t\tj++;\n\t\t\t\t} else {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (listItems.length > 0) {\n\t\t\t\tconst camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n\t\t\t\tdata[camelKey] = listItems;\n\t\t\t\ti = j;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tvalue = null;\n\t\t} else if (value.startsWith(\"[\") && value.endsWith(\"]\")) {\n\t\t\ttry {\n\t\t\t\tvalue = JSON.parse(value.replace(/'/g, '\"'));\n\t\t\t} catch (err) {\n\t\t\t\tconsole.debug(\"[rules-engine] JSON array parse failed:\", err instanceof Error ? err.message : err);\n\t\t\t\tvalue = (value as string)\n\t\t\t\t\t.slice(1, -1)\n\t\t\t\t\t.split(\",\")\n\t\t\t\t\t.map((v: string) => v.trim().replace(/^[\"']|[\"']$/g, \"\"));\n\t\t\t}\n\t\t} else if (value.startsWith('\"') && value.endsWith('\"')) {\n\t\t\tvalue = value.slice(1, -1);\n\t\t} else if (value.startsWith(\"'\") && value.endsWith(\"'\")) {\n\t\t\tvalue = value.slice(1, -1);\n\t\t}\n\n\t\tconst camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n\n\t\tif ((camelKey === \"paths\" || camelKey === \"globs\") && typeof value === \"string\") {\n\t\t\tdata[camelKey] = splitComma(value);\n\t\t} else {\n\t\t\tdata[camelKey] = value;\n\t\t}\n\t\ti++;\n\t}\n\n\treturn { data, body: body.trim() };\n}\n\nfunction extractTitle(body: string): string {\n\tfor (const line of body.split(\"\\n\")) {\n\t\tconst trimmed = line.trim();\n\t\tif (trimmed) {\n\t\t\treturn trimmed.replace(/^#+\\s*/, \"\").replace(/\\*\\*/g, \"\");\n\t\t}\n\t}\n\treturn \"Untitled Rule\";\n}\n\nfunction parsePaths(raw: unknown): string[] {\n\tif (!raw) return [];\n\tif (typeof raw === \"string\") {\n\t\treturn raw\n\t\t\t.split(\",\")\n\t\t\t.map((g) => g.trim())\n\t\t\t.filter(Boolean);\n\t}\n\tif (Array.isArray(raw)) return raw as string[];\n\treturn [];\n}\n\nexport function parseRuleFile(filePath: string, content: string): ParsedRule {\n\tconst { data, body } = parseFrontmatter(content);\n\tconst rawGlobs = data.globs ?? data.paths;\n\tconst globs = parsePaths(rawGlobs);\n\tconst rawPaths = data.paths;\n\tconst paths = parsePaths(rawPaths);\n\tconst isUnconditional = globs.length === 0 || (globs.length === 1 && globs[0] === \"**\");\n\n\tconst frontmatter: RuleFrontmatter = {};\n\tif (rawGlobs) {\n\t\tfrontmatter.globs = globs;\n\t\tif (rawPaths) {\n\t\t\tfrontmatter.paths = paths;\n\t\t} else {\n\t\t\tfrontmatter.paths = globs;\n\t\t}\n\t}\n\tif (data.description && typeof data.description === \"string\") frontmatter.description = data.description;\n\tif (data.severity && typeof data.severity === \"string\")\n\t\tfrontmatter.severity = data.severity as ParsedRule[\"frontmatter\"][\"severity\"];\n\tif (data.allowedTools)\n\t\tfrontmatter.allowedTools =\n\t\t\ttypeof data.allowedTools === \"string\" ? [data.allowedTools] : (data.allowedTools as string[]);\n\tif (data.whenToUse && typeof data.whenToUse === \"string\") frontmatter.whenToUse = data.whenToUse;\n\tif (data.notifyOnMatch !== undefined)\n\t\tfrontmatter.notifyOnMatch = data.notifyOnMatch === \"true\" || data.notifyOnMatch === true;\n\tif (data.skipInPrompt !== undefined)\n\t\tfrontmatter.skipInPrompt = data.skipInPrompt === \"true\" || data.skipInPrompt === true;\n\n\treturn {\n\t\tname: path.basename(filePath, path.extname(filePath)),\n\t\tfilePath,\n\t\ttitle: extractTitle(body),\n\t\tcontent: body.trim(),\n\t\tscope: \"project\",\n\t\tsource: \"\",\n\t\tfrontmatter,\n\t\tisUnconditional,\n\t};\n}\n\nfunction scanDir(dir: string, files: string[] = []): string[] {\n\tif (!fs.existsSync(dir)) return files;\n\tconst entries = fs.readdirSync(dir, { withFileTypes: true });\n\tfor (const entry of entries) {\n\t\tconst fullPath = path.join(dir, entry.name);\n\t\tif (entry.isDirectory()) {\n\t\t\tscanDir(fullPath, files);\n\t\t} else if (entry.isFile() && (entry.name.endsWith(\".md\") || entry.name.endsWith(\".mdc\"))) {\n\t\t\tfiles.push(fullPath);\n\t\t}\n\t}\n\treturn files;\n}\n\nexport function loadRules(rulesDir: string): RuleCache {\n\tconst rules: ParsedRule[] = [];\n\tconst unconditional: ParsedRule[] = [];\n\tconst conditional: ParsedRule[] = [];\n\n\tif (!fs.existsSync(rulesDir)) {\n\t\treturn { rules, unconditional, conditional, loadedAt: Date.now() };\n\t}\n\n\tconst files = scanDir(rulesDir);\n\n\tfor (const filePath of files) {\n\t\tconst content = fs.readFileSync(filePath, \"utf-8\");\n\t\tconst rule = parseRuleFile(filePath, content);\n\t\trules.push(rule);\n\t\tif (rule.isUnconditional) {\n\t\t\tunconditional.push(rule);\n\t\t} else {\n\t\t\tconditional.push(rule);\n\t\t}\n\t}\n\n\treturn { rules, unconditional, conditional, loadedAt: Date.now() };\n}\n"],
  "mappings": "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",
  "names": ["path", "trimmed", "camelKey", "fs", "homedir", "path", "DEFAULT_DIRS", "resolveDirs", "path", "cache", "ignore", "createTypedChannel", "fs", "path", "splitComma", "trimmed", "parseFrontmatter", "camelKey", "extractTitle", "parsePaths", "parseRuleFile", "scanDir", "loadRules"]
}
