@dyyz1993/pi-coding-agent 0.74.23 → 0.74.25

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

@@ -0,0 +1,552 @@
+import { Type } from "@dyyz1993/pi-ai";
+import { createTypedChannel, defineTool, type ExtensionAPI } from "@dyyz1993/pi-coding-agent";
+import { getRules, invalidateCache } from "./cache.js";
+import { loadConfig } from "./config.js";
+import { buildSystemReminderSection, buildToolReminderSection } from "./injector.js";
+import { matchesAnyGlob } from "./matcher.js";
+import type {
+	InjectedPayload,
+	LifecycleEntry,
+	MatchedRuleDetail,
+	MatchRecord,
+	ParsedRule,
+	RuleDetail,
+	RuleSeverity,
+	RulesChannelContract,
+	RulesChannelEvent,
+	RulesConfig,
+	ScannedDir,
+	SnapshotPayload,
+} from "./types.js";
+import { RULES_CHANNEL_NAME } from "./types.js";
+
+export { createTypedChannel } from "@dyyz1993/pi-coding-agent";
+export { getRules, invalidateCache } from "./cache.js";
+export { loadConfig, resolveDirs } from "./config.js";
+export { buildCompactContext, buildSystemReminderSection, buildToolReminderSection, buildSystemPromptSection, buildToolContextSection } from "./injector.js";
+export { loadRules, parseFrontmatter, parseRuleFile } from "./loader.js";
+export { matchesAnyGlob, matchGlob } from "./matcher.js";
+export type {
+	InjectedPayload,
+	LifecycleEntry,
+	MatchedPayload,
+	MatchRecord,
+	ParsedRule,
+	ReloadedPayload,
+	RuleDetail,
+	RuleFrontmatter,
+	RuleScope,
+	RuleSeverity,
+	RulesChannelContract,
+	RulesChannelEvent,
+	RulesConfig,
+	ScannedDir,
+	SnapshotPayload,
+	UnloadedPayload,
+} from "./types.js";
+
+const READ_TOOLS = new Set(["read", "grep", "glob"]);
+
+export default function rulesEnginePlugin(pi: ExtensionAPI) {
+	let config: RulesConfig | null = null;
+	let rules: ParsedRule[] = [];
+	let cachedMatchHash = "";
+	let hasSentSnapshot = false;
+	let _lastCwd = "";
+	let lastMessages: unknown[] = [];
+	/** Track which rule+file combos have been injected (ruleName -> Set<filePath>) */
+	let injectedRuleFiles: Map<string, Set<string>> = new Map();
+
+	function rebuildMatchHistory(messages: unknown[]): MatchRecord[] {
+		const history: MatchRecord[] = [];
+		for (const msg of messages) {
+			if ((msg as Record<string, unknown>).role !== "toolResult") continue;
+			const details = (msg as { details?: Record<string, unknown> }).details;
+			if (!details?.rulesMatched) continue;
+			const rulesMatched = details.rulesMatched as MatchedRuleDetail[];
+			history.push({
+				filePath: (details.matchedFilePath as string) || "",
+				ruleNames: rulesMatched.map((r) => r.name),
+				toolName: (msg as { toolName?: string }).toolName || "",
+				toolCallId: (msg as { toolCallId?: string }).toolCallId || "",
+				severity: rulesMatched.some((r) => r.severity === "critical" || r.severity === "high") ? "warning" : "info",
+				timestamp: (msg as { timestamp?: number }).timestamp || 0,
+				matchedRuleDetails: rulesMatched,
+			});
+		}
+		return history;
+	}
+
+	const rawChannel = pi.registerChannel(RULES_CHANNEL_NAME);
+	const channel = createTypedChannel<RulesChannelContract>(rawChannel).server;
+
+	channel.handle("getSnapshot", (params) => {
+		const unconditional = getUnconditionalRules();
+		const conditional = getConditionalRules();
+		const matchHistory = rebuildMatchHistory(lastMessages);
+		return {
+			type: "snapshot" as const,
+			rules: rules.map(toRuleDetail),
+			injectedRuleNames: unconditional.map((r) => r.name),
+			totalRules: rules.length,
+			unconditionalCount: unconditional.length,
+			conditionalCount: conditional.length,
+			matchHistory,
+			lifecycleLog: [] as LifecycleEntry[],
+			loadedAt: Date.now(),
+			cacheTTL: config?.cacheTTL || 30000,
+		};
+	});
+
+	function getUnconditionalRules(): ParsedRule[] {
+		return rules.filter((r) => r.isUnconditional);
+	}
+
+	function getConditionalRules(): ParsedRule[] {
+		return rules.filter((r) => !r.isUnconditional);
+	}
+
+	function getMatchingRules(targetPath: string): ParsedRule[] {
+		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: string): Promise<void> {
+		config = await loadConfig(cwd);
+		rules = await getRules(cwd, config);
+	}
+
+	function toRuleDetail(r: ParsedRule): RuleDetail {
+		return {
+			name: r.name,
+			title: r.title,
+			filePath: r.filePath,
+			scope: r.scope,
+			source: r.source,
+			severity: r.frontmatter.severity || ("medium" as RuleSeverity),
+			isUnconditional: r.isUnconditional,
+			globs: r.frontmatter.globs ?? r.frontmatter.paths ?? [],
+			description: r.frontmatter.description,
+		};
+	}
+
+	function buildSnapshot(matchHistory: MatchRecord[], lifecycleLog: LifecycleEntry[]): SnapshotPayload {
+		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 || 30000,
+		};
+	}
+
+	function extractTargetPath(args: Record<string, unknown>): string | undefined {
+		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 undefined;
+	}
+
+	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: Record<string, number> = {};
+				for (const r of rules) {
+					byScope[r.scope] = (byScope[r.scope] || 0) + 1;
+				}
+
+				let output = `# Loaded Rules (${rules.length})\n\n`;
+				output += `Scopes: ${Object.entries(byScope)
+					.map(([k, v]) => `${k}: ${v}`)
+					.join(", ")}\n\n`;
+
+				output += `**Unconditional** (${unconditional.length}):\n`;
+				for (const rule of unconditional) {
+					output += `- ${rule.title} (${rule.source})\n`;
+				}
+
+				output += `\n**Conditional** (${conditional.length}):\n`;
+				for (const rule of conditional) {
+					output += `- ${rule.title} [${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(", ")}] (${rule.source})\n`;
+				}
+
+				return { content: [{ type: "text", text: output }], details: undefined };
+			},
+		}),
+	);
+
+	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}\n\n`;
+				output += `**Unconditional** (always active, ${unconditional.length}):\n`;
+				for (const r of unconditional) {
+					output += `- ${r.title}\n`;
+				}
+				output += `\n**Conditional matches** (${matching.length}):\n`;
+				for (const r of matching) {
+					const sev = r.frontmatter.severity || "medium";
+					output += `- [${sev}] ${r.title} (${(r.frontmatter.globs ?? r.frontmatter.paths)?.join(", ")})\n`;
+				}
+
+				return { content: [{ type: "text", text: output }], details: undefined };
+			},
+		}),
+	);
+
+	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: undefined,
+				};
+			},
+		}),
+	);
+
+	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: undefined,
+					};
+				}
+
+				let output = `# ${rule.title}\n\n`;
+				output += `- **Name**: ${rule.name}\n`;
+				output += `- **Scope**: ${rule.scope}\n`;
+				output += `- **Source**: ${rule.source}\n`;
+				output += `- **File**: ${rule.filePath}\n`;
+				if ((rule.frontmatter.globs ?? rule.frontmatter.paths)?.length) {
+					output += `- **Globs**: ${(rule.frontmatter.globs ?? rule.frontmatter.paths)?.join(", ")}\n`;
+				}
+				if (rule.frontmatter.description) {
+					output += `- **Description**: ${rule.frontmatter.description}\n`;
+				}
+				output += `\n${rule.content}`;
+
+				return { content: [{ type: "text", text: output }], details: undefined };
+			},
+		}),
+	);
+
+	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 = new Map<string, ParsedRule[]>();
+			for (const r of rules) {
+				const list = scopeGroups.get(r.scope) || [];
+				list.push(r);
+				scopeGroups.set(r.scope, list);
+			}
+
+			const scannedDirs: ScannedDir[] = [...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 undefined;
+		}
+
+		const alreadyInjected = lastMessages.some(
+			(msg) =>
+				(msg as Record<string, unknown>).role === "custom" &&
+				(msg as Record<string, unknown>).customType === "rules-engine",
+		);
+		if (alreadyInjected) {
+			channel.emit("injected", {
+				type: "injected",
+				ruleNames: unconditional.map((r) => r.name),
+				systemPromptLength: event.systemPrompt.length,
+				deduplicated: true,
+			});
+			return undefined;
+		}
+
+		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 undefined;
+
+		const targetPath = extractTargetPath(event.input);
+		if (!targetPath) return undefined;
+
+		const matching = getMatchingRules(targetPath);
+		if (matching.length === 0) return undefined;
+
+		const matchedRuleDetails: MatchedRuleDetail[] = matching.map((r) => {
+			const ruleName = r.name;
+			const injectedFiles = injectedRuleFiles.get(ruleName);
+			const wasAlreadyLoaded = injectedFiles !== undefined && injectedFiles.has(targetPath);
+
+			return {
+				name: ruleName,
+				title: r.title,
+				severity: r.frontmatter.severity || ("medium" as RuleSeverity),
+				matchedGlob:
+					(r.frontmatter.globs ?? r.frontmatter.paths)?.find((p) => matchesAnyGlob([p], targetPath)) ||
+					(r.frontmatter.globs ?? r.frontmatter.paths)?.[0] ||
+					"",
+				alreadyLoaded: wasAlreadyLoaded || undefined,
+			};
+		});
+
+		// Determine which rules are newly injected vs already loaded
+		const newRules = matching.filter((r) => {
+			const injectedFiles = injectedRuleFiles.get(r.name);
+			return !injectedFiles || !injectedFiles.has(targetPath);
+		});
+		const allAlreadyLoaded = newRules.length === 0;
+
+		// Record that these rules have now been injected for this file
+		for (const r of matching) {
+			let injectedFiles = injectedRuleFiles.get(r.name);
+			if (!injectedFiles) {
+				injectedFiles = 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 || undefined,
+		});
+
+		// Only inject content for NEW rules (skip if all already loaded)
+		if (allAlreadyLoaded) {
+			return {
+				details: {
+					...((event.details as Record<string, unknown>) || {}),
+					rulesMatched: matchedRuleDetails,
+					matchedFilePath: targetPath,
+				},
+			};
+		}
+
+		const contextSection = buildToolReminderSection(newRules, targetPath);
+
+		return {
+			content: [...event.content, { type: "text" as const, text: `\n\n${contextSection}` }],
+			details: {
+				...((event.details as Record<string, unknown>) || {}),
+				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 || 30000,
+			});
+		}
+
+		return undefined;
+	});
+
+	pi.on("session_compact", async (_event, ctx) => {
+		cachedMatchHash = "";
+		lastMessages = [];
+		injectedRuleFiles = new Map();
+		ctx.ui.setStatus("rules-engine", `Rules: ${rules.length} (re-injected after compact)`);
+	});
+
+	pi.on("session_tree", async () => {
+		cachedMatchHash = "";
+		lastMessages = [];
+		injectedRuleFiles = 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 || 30000,
+			});
+		}
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		channel.emit("unloaded", { type: "unloaded", reason: "session_shutdown" });
+		ctx.ui.setStatus("rules-engine", undefined);
+	});
+}

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

@@ -0,0 +1,68 @@
+// packages/coding-agent/extensions/rules-engine/injector.ts
+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");
+}
+export {
+  buildCompactContext,
+  buildSystemPromptSection,
+  buildSystemReminderSection,
+  buildToolContextSection,
+  buildToolReminderSection
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,74 @@
+import type { ParsedRule } from "./types.js";
+
+const SEVERITY_ICONS: Record<string, string> = {
+	critical: "🔴",
+	high: "🟠",
+	medium: "🟡",
+	low: "🔵",
+	hint: "💡",
+};
+
+export function buildSystemReminderSection(rules: ParsedRule[], sources: string[]): string {
+	if (rules.length === 0) return "";
+
+	const lines: string[] = [
+		"<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} — ${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");
+}
+
+export function buildToolReminderSection(rules: ParsedRule[], targetPath: string): string {
+	if (rules.length === 0) return "";
+
+	const lines: string[] = [
+		"<system-reminder>",
+		`Conditional rules matched for ${targetPath}:`,
+		"",
+	];
+
+	for (const rule of rules) {
+		const severity = rule.frontmatter.severity || "medium";
+		const icon = SEVERITY_ICONS[severity] || "🟡";
+		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");
+}
+
+export const buildSystemPromptSection = buildSystemReminderSection;
+export const buildToolContextSection = buildToolReminderSection;
+
+export function buildCompactContext(rules: ParsedRule[]): string {
+	if (rules.length === 0) return "";
+
+	const lines: string[] = ["## 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");
+}