@dyyz1993/pi-coding-agent 0.74.23 → 0.74.25

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

@@ -0,0 +1,232 @@
+// packages/coding-agent/extensions/rules-engine/config.ts
+import { homedir } from "node:os";
+import * as path 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;
+}
+
+// packages/coding-agent/extensions/rules-engine/loader.ts
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+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() };
+}
+
+// packages/coding-agent/extensions/rules-engine/cache.ts
+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;
+}
+export {
+  getRules,
+  invalidateCache
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["config.ts", "loader.ts", "cache.ts"],
  "sourcesContent": ["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"],
  "mappings": "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",
  "names": ["path", "trimmed", "camelKey"]
}


package/dist/extensions/rules-engine/cache.ts

@@ -0,0 +1,38 @@
+import { resolveDirs } from "./config.js";
+import { loadRules } from "./loader.js";
+import type { ParsedRule, RulesConfig } from "./types.js";
+
+let cache: { rules: ParsedRule[]; loadedAt: number } | null = null;
+
+export async function getRules(projectDir: string, config: RulesConfig): Promise<ParsedRule[]> {
+	if (cache && Date.now() - cache.loadedAt < config.cacheTTL) {
+		return cache.rules;
+	}
+
+	const rules = await loadAllRules(projectDir, config);
+	cache = { rules, loadedAt: Date.now() };
+	return rules;
+}
+
+export function invalidateCache(): void {
+	cache = null;
+}
+
+async function loadAllRules(projectDir: string, config: RulesConfig): Promise<ParsedRule[]> {
+	const sources = resolveDirs(projectDir, config);
+	const result: ParsedRule[] = [];
+	const seen = new Set<string>();
+
+	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 as ParsedRule["scope"];
+			rule.source = source;
+			result.push(rule);
+		}
+	}
+
+	return result;
+}

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

@@ -0,0 +1,63 @@
+// packages/coding-agent/extensions/rules-engine/config.ts
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+var DEFAULT_CACHE_TTL = 3e4;
+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 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 = path.resolve(projectDir, name);
+    if (!fs.existsSync(fp)) continue;
+    try {
+      const raw = fs.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 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;
+}
+export {
+  loadConfig,
+  resolveDirs
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/extensions/rules-engine/config.ts

@@ -0,0 +1,70 @@
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+import type { RulesConfig } from "./types.js";
+
+const DEFAULT_CACHE_TTL = 30_000;
+
+const 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 defaultConfig(): RulesConfig {
+	return {
+		cacheTTL: DEFAULT_CACHE_TTL,
+		notifyOnLoad: true,
+		notifyOnMatch: true,
+	};
+}
+
+export async function loadConfig(projectDir: string): Promise<RulesConfig> {
+	const configFiles = [
+		".rules-config.json",
+		".pi/rules-config.json",
+		".claude/rules-config.json",
+		".opencode/rules-config.json",
+	];
+
+	for (const name of configFiles) {
+		const fp = path.resolve(projectDir, name);
+		if (!fs.existsSync(fp)) continue;
+		try {
+			const raw = fs.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();
+}
+
+export function resolveDirs(
+	projectDir: string,
+	config: RulesConfig,
+): Array<{ scope: string; dir: string; source: string }> {
+	const sources = config.dirs || DEFAULT_DIRS;
+	const result: Array<{ scope: string; dir: string; source: string }> = [];
+
+	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;
+}