@oh-my-pi/pi-coding-agent 3.4.1337 → 3.6.1337

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [3.6.1337] - 2026-01-03
+
+## [3.5.1337] - 2026-01-03
+
+### Added
+
+- Added session header and footer output in text mode showing version, model, provider, thinking level, and session ID
+- Added Extension Control Center dashboard accessible via `/extensions` command for unified management of all providers and extensions
+- Added ability to enable/disable individual extensions with persistent settings
+- Added three-column dashboard layout with sidebar tree, extension list, and inspector panel
+- Added fuzzy search filtering for extensions in the dashboard
+- Added keyboard navigation with Tab to cycle panes, j/k for navigation, Space to toggle, Enter to expand/collapse
+
+### Changed
+
+- Redesigned Extension Control Center from 3-column layout to tabbed interface with horizontal provider tabs and 2-column grid
+- Replaced sidebar tree navigation with provider tabs using TAB/Shift+TAB cycling
+
+### Fixed
+
+- Fixed title generation flag not resetting when starting a new session
+
 ## [3.4.1337] - 2026-01-03
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.4.1337",
+	"version": "3.6.1337",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,9 +39,9 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "3.4.1337",
-		"@oh-my-pi/pi-ai": "3.4.1337",
-		"@oh-my-pi/pi-tui": "3.4.1337",
+		"@oh-my-pi/pi-agent-core": "3.6.1337",
+		"@oh-my-pi/pi-ai": "3.6.1337",
+		"@oh-my-pi/pi-tui": "3.6.1337",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
 		"chalk": "^5.5.0",
@@ -52,6 +52,7 @@
 		"highlight.js": "^11.11.1",
 		"marked": "^15.0.12",
 		"minimatch": "^10.1.1",
+		"nanoid": "^5.1.6",
 		"node-html-parser": "^6.1.13",
 		"smol-toml": "^1.6.0",
 		"strip-ansi": "^7.1.2",

package/src/core/sdk.ts

@@ -79,8 +79,10 @@ import {
 	createLsTool,
 	createReadOnlyTools,
 	createReadTool,
+	createRulebookTool,
 	createWriteTool,
 	editTool,
+	filterRulebookRules,
 	findTool,
 	grepTool,
 	lsTool,
@@ -604,7 +606,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const skills = options.skills ?? discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
 	time("discoverSkills");
 
-	// Discover TTSR rules
+	// Discover rules
 	const ttsrManager = createTtsrManager(settingsManager.getTtsrSettings());
 	const rulesResult = loadCapability<Rule>(ruleCapability.id, { cwd });
 	for (const rule of rulesResult.items) {
@@ -614,6 +616,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	time("discoverTtsrRules");
 
+	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
+	const rulebookRules = filterRulebookRules(rulesResult.items);
+	time("filterRulebookRules");
+
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
 	time("discoverContextFiles");
 
@@ -757,6 +763,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	let allToolsArray: Tool[] = [...builtInTools, ...wrappedCustomTools];
 
+	// Add rulebook tool if there are rules with descriptions (always enabled, regardless of --tools)
+	if (rulebookRules.length > 0) {
+		allToolsArray.push(createRulebookTool(rulebookRules));
+	}
+
 	// Filter out hidden tools unless explicitly requested
 	if (options.explicitTools) {
 		const explicitSet = new Set(options.explicitTools);
@@ -781,6 +792,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		cwd,
 		skills,
 		contextFiles,
+		rulebookRules,
 	});
 	time("buildSystemPrompt");
 
@@ -791,6 +803,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			cwd,
 			skills,
 			contextFiles,
+			rulebookRules,
 			customPrompt: options.systemPrompt,
 		});
 	} else {

package/src/core/session-manager.ts

@@ -13,6 +13,7 @@ import {
 import { join, resolve } from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent } from "@oh-my-pi/pi-ai";
+import { nanoid } from "nanoid";
 import { getAgentDir as getDefaultAgentDir } from "../config";
 import {
 	type BashExecutionMessage,
@@ -196,11 +197,10 @@ export type ReadonlySessionManager = Pick<
 /** Generate a unique short ID (8 hex chars, collision-checked) */
 function generateId(byId: { has(id: string): boolean }): string {
 	for (let i = 0; i < 100; i++) {
-		const id = crypto.randomUUID().slice(0, 8);
+		const id = nanoid(8);
 		if (!byId.has(id)) return id;
 	}
-	// Fallback to full UUID if somehow we have collisions
-	return crypto.randomUUID();
+	return nanoid(); // fallback to full nanoid
 }
 
 /** Migrate v1 → v2: add id/parentId tree structure. Mutates in place. */
@@ -451,42 +451,105 @@ export function loadEntriesFromFile(filePath: string): FileEntry[] {
 	return entries;
 }
 
-function isValidSessionFile(filePath: string): boolean {
-	try {
-		const fd = openSync(filePath, "r");
-		const buffer = Buffer.alloc(512);
-		const bytesRead = readSync(fd, buffer, 0, 512, 0);
-		closeSync(fd);
-		const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
-		if (!firstLine) return false;
-		const header = JSON.parse(firstLine);
-		return header.type === "session" && typeof header.id === "string";
-	} catch {
-		return false;
+/**
+ * Lightweight metadata for a session file, used in session picker UI.
+ * Uses lazy getters to defer string formatting until actually displayed.
+ */
+class RecentSessionInfo {
+	readonly path: string;
+	readonly mtime: number;
+
+	#fullName: string | undefined;
+	#name: string | undefined;
+	#timeAgo: string | undefined;
+
+	constructor(path: string, mtime: number, header: Record<string, unknown>) {
+		this.path = path;
+		this.mtime = mtime;
+
+		// Extract title from session header, falling back to id if title is missing
+		const trystr = (v: unknown) => (typeof v === "string" ? v : undefined);
+		this.#fullName = trystr(header.title) ?? trystr(header.id);
+	}
+
+	/** Full session name from header, or filename without extension as fallback */
+	get fullName(): string {
+		if (this.#fullName) return this.#fullName;
+		this.#fullName = this.path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
+		return this.#fullName;
+	}
+
+	/** Truncated name for display (max 40 chars) */
+	get name(): string {
+		if (this.#name) return this.#name;
+		const fullName = this.fullName;
+		this.#name = fullName.length <= 40 ? fullName : `${fullName.slice(0, 37)}...`;
+		return this.#name;
+	}
+
+	/** Human-readable relative time (e.g., "2 hours ago") */
+	get timeAgo(): string {
+		if (this.#timeAgo) return this.#timeAgo;
+		this.#timeAgo = formatTimeAgo(new Date(this.mtime));
+		return this.#timeAgo;
 	}
 }
 
-/** Exported for testing */
-export function findMostRecentSession(sessionDir: string): string | null {
+/**
+ * Reads all session files from the directory and returns them sorted by mtime (newest first).
+ * Uses low-level file I/O to efficiently read only the first 512 bytes of each file
+ * to extract the JSON header without loading entire session logs into memory.
+ */
+function getSortedSessions(sessionDir: string): RecentSessionInfo[] {
 	try {
-		const files = readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => join(sessionDir, f))
-			.filter(isValidSessionFile)
-			.map((path) => ({ path, mtime: statSync(path).mtime }))
-			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-
-		return files[0]?.path || null;
+		// Reusable buffer for reading file headers
+		const buf = Buffer.allocUnsafe(512);
+
+		/**
+		 * Reads the first line (JSON header) from an open file descriptor.
+		 * Returns null if the file is empty or doesn't start with valid JSON.
+		 */
+		const readHeader = (fd: number) => {
+			const bytesRead = readSync(fd, buf, 0, 512, 0);
+			if (bytesRead === 0) return null;
+			const sub = buf.subarray(0, bytesRead);
+			// Quick check: first char must be '{' for valid JSON object
+			if (sub.at(0) !== "{".charCodeAt(0)) return null;
+			// Find end of first JSON line
+			const eol = sub.indexOf("}\n");
+			if (eol <= 0) return null;
+			return JSON.parse(sub.toString("utf8", 0, eol + 1));
+		};
+
+		return readdirSync(sessionDir)
+			.map((f) => {
+				try {
+					if (!f.endsWith(".jsonl")) return null;
+					const path = join(sessionDir, f);
+					const fd = openSync(path, "r");
+					try {
+						const header = readHeader(fd);
+						if (!header) return null;
+						const mtime = statSync(path).mtimeMs;
+						return new RecentSessionInfo(path, mtime, header);
+					} finally {
+						closeSync(fd);
+					}
+				} catch {
+					return null;
+				}
+			})
+			.filter((x) => x !== null)
+			.sort((a, b) => b.mtime - a.mtime); // Sort newest first
 	} catch {
-		return null;
+		return [];
 	}
 }
 
-/** Recent session info for display */
-export interface RecentSessionInfo {
-	name: string;
-	path: string;
-	timeAgo: string;
+/** Exported for testing */
+export function findMostRecentSession(sessionDir: string): string | null {
+	const sessions = getSortedSessions(sessionDir);
+	return sessions[0]?.path || null;
 }
 
 /** Format a time difference as a human-readable string */
@@ -506,41 +569,7 @@ function formatTimeAgo(date: Date): string {
 
 /** Get recent sessions for display in welcome screen */
 export function getRecentSessions(sessionDir: string, limit = 3): RecentSessionInfo[] {
-	try {
-		const files = readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => join(sessionDir, f))
-			.filter(isValidSessionFile)
-			.map((path) => {
-				const stat = statSync(path);
-				// Try to get session title or id from first line
-				let name = path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
-				try {
-					const content = readFileSync(path, "utf-8");
-					const firstLine = content.split("\n")[0];
-					if (firstLine) {
-						const header = JSON.parse(firstLine) as SessionHeader;
-						if (header.type === "session") {
-							// Prefer title over id
-							name = header.title ?? header.id ?? name;
-						}
-					}
-				} catch {
-					// Use filename as fallback
-				}
-				return { path, name, mtime: stat.mtime };
-			})
-			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-			.slice(0, limit);
-
-		return files.map((f) => ({
-			name: f.name.length > 40 ? `${f.name.slice(0, 37)}...` : f.name,
-			path: f.path,
-			timeAgo: formatTimeAgo(f.mtime),
-		}));
-	} catch {
-		return [];
-	}
+	return getSortedSessions(sessionDir).slice(0, limit);
 }
 
 /**
@@ -588,7 +617,7 @@ export class SessionManager {
 		if (existsSync(this.sessionFile)) {
 			this.fileEntries = loadEntriesFromFile(this.sessionFile);
 			const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
-			this.sessionId = header?.id ?? crypto.randomUUID();
+			this.sessionId = header?.id ?? nanoid();
 			this.sessionTitle = header?.title;
 
 			if (migrateToCurrentVersion(this.fileEntries)) {
@@ -603,7 +632,7 @@ export class SessionManager {
 	}
 
 	newSession(options?: NewSessionOptions): string | undefined {
-		this.sessionId = crypto.randomUUID();
+		this.sessionId = nanoid();
 		const timestamp = new Date().toISOString();
 		const header: SessionHeader = {
 			type: "session",
@@ -1081,7 +1110,7 @@ export class SessionManager {
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
 		const pathWithoutLabels = path.filter((e) => e.type !== "label");
 
-		const newSessionId = crypto.randomUUID();
+		const newSessionId = nanoid();
 		const timestamp = new Date().toISOString();
 		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 		const newSessionFile = join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);

package/src/core/settings-manager.ts

@@ -105,6 +105,7 @@ export interface Settings {
 	edit?: EditSettings;
 	ttsr?: TtsrSettings;
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
+	disabledExtensions?: string[]; // Individual extension IDs that are disabled (e.g., "skill:commit")
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -594,6 +595,38 @@ export class SettingsManager {
 		this.save();
 	}
 
+	getDisabledExtensions(): string[] {
+		return [...(this.settings.disabledExtensions ?? [])];
+	}
+
+	setDisabledExtensions(extensionIds: string[]): void {
+		this.globalSettings.disabledExtensions = extensionIds;
+		this.save();
+	}
+
+	isExtensionEnabled(extensionId: string): boolean {
+		return !(this.settings.disabledExtensions ?? []).includes(extensionId);
+	}
+
+	enableExtension(extensionId: string): void {
+		const disabled = this.globalSettings.disabledExtensions ?? [];
+		const index = disabled.indexOf(extensionId);
+		if (index !== -1) {
+			disabled.splice(index, 1);
+			this.globalSettings.disabledExtensions = disabled;
+			this.save();
+		}
+	}
+
+	disableExtension(extensionId: string): void {
+		const disabled = this.globalSettings.disabledExtensions ?? [];
+		if (!disabled.includes(extensionId)) {
+			disabled.push(extensionId);
+			this.globalSettings.disabledExtensions = disabled;
+			this.save();
+		}
+	}
+
 	getTtsrSettings(): TtsrSettings {
 		return this.settings.ttsr ?? {};
 	}

package/src/core/system-prompt.ts

@@ -5,12 +5,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
+import type { Rule } from "../capability/rule";
 import { systemPromptCapability } from "../capability/system-prompt";
 import { getDocsPath, getExamplesPath, getReadmePath } from "../config";
 import { type ContextFile, loadSync, type SystemPrompt as SystemPromptFile } from "../discovery/index";
 import type { SkillsSettings } from "./settings-manager";
 import { formatSkillsForPrompt, loadSkills, type Skill } from "./skills";
 import type { ToolName } from "./tools/index";
+import { formatRulesForPrompt } from "./tools/rulebook";
 
 /**
  * Execute a git command synchronously and return stdout or null on failure.
@@ -238,6 +240,8 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string; depth?: number }>;
 	/** Pre-loaded skills (skips discovery if provided). */
 	skills?: Skill[];
+	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
+	rulebookRules?: Rule[];
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -250,6 +254,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		cwd,
 		contextFiles: providedContextFiles,
 		skills: providedSkills,
+		rulebookRules,
 	} = options;
 	const resolvedCwd = cwd ?? process.cwd();
 	const resolvedCustomPrompt = resolvePromptInput(customPrompt, "system prompt");
@@ -310,6 +315,11 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 			prompt += formatSkillsForPrompt(skills);
 		}
 
+		// Append rules section (always enabled when rules exist)
+		if (rulebookRules && rulebookRules.length > 0) {
+			prompt += formatRulesForPrompt(rulebookRules);
+		}
+
 		// Add date/time and working directory last
 		prompt += `\nCurrent date and time: ${dateTime}`;
 		prompt += `\nCurrent working directory: ${resolvedCwd}`;
@@ -419,6 +429,11 @@ Documentation:
 		prompt += formatSkillsForPrompt(skills);
 	}
 
+	// Append rules section (always enabled when rules exist)
+	if (rulebookRules && rulebookRules.length > 0) {
+		prompt += formatRulesForPrompt(rulebookRules);
+	}
+
 	// Add date/time and working directory last
 	prompt += `\nCurrent date and time: ${dateTime}`;
 	prompt += `\nCurrent working directory: ${resolvedCwd}`;

package/src/core/title-generator.ts

@@ -4,6 +4,7 @@
 
 import type { Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
+import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
 import { findSmolModel } from "./model-resolver";
 
@@ -43,21 +44,35 @@ export async function generateSessionTitle(
 	savedSmolModel?: string,
 ): Promise<string | null> {
 	const model = await findTitleModel(registry, savedSmolModel);
-	if (!model) return null;
+	if (!model) {
+		logger.debug("title-generator: no smol model found");
+		return null;
+	}
 
 	const apiKey = await registry.getApiKey(model);
-	if (!apiKey) return null;
+	if (!apiKey) {
+		logger.debug("title-generator: no API key for model", { provider: model.provider, id: model.id });
+		return null;
+	}
 
 	// Truncate message if too long
 	const truncatedMessage =
 		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
 
+	const request = {
+		model: `${model.provider}/${model.id}`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		userMessage: `<user-message>\n${truncatedMessage}\n</user-message>`,
+		maxTokens: 30,
+	};
+	logger.debug("title-generator: request", request);
+
 	try {
 		const response = await completeSimple(
 			model,
 			{
-				systemPrompt: TITLE_SYSTEM_PROMPT,
-				messages: [{ role: "user", content: truncatedMessage, timestamp: Date.now() }],
+				systemPrompt: request.systemPrompt,
+				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
 			},
 			{
 				apiKey,
@@ -74,13 +89,20 @@ export async function generateSessionTitle(
 		}
 		title = title.trim();
 
-		if (!title || title.length > 60) {
+		logger.debug("title-generator: response", {
+			title,
+			usage: response.usage,
+			stopReason: response.stopReason,
+		});
+
+		if (!title) {
 			return null;
 		}
 
 		// Clean up: remove quotes, trailing punctuation
 		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
-	} catch {
+	} catch (err) {
+		logger.debug("title-generator: error", { error: err instanceof Error ? err.message : String(err) });
 		return null;
 	}
 }

package/src/core/tools/index.ts

@@ -24,6 +24,12 @@ export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./no
 export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
 export { createReadTool, type ReadToolDetails, readTool } from "./read";
 export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
+export {
+	createRulebookTool,
+	filterRulebookRules,
+	formatRulesForPrompt,
+	type RulebookToolDetails,
+} from "./rulebook";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
 export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch";

package/src/core/tools/rulebook.ts

@@ -0,0 +1,124 @@
+/**
+ * Rulebook Tool
+ *
+ * Allows the agent to fetch full content of rules that have descriptions.
+ * Rules are listed in the system prompt with name + description; this tool
+ * retrieves the complete rule content on demand.
+ */
+
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import type { Rule } from "../../capability/rule";
+
+export interface RulebookToolDetails {
+	type: "rulebook";
+	ruleName: string;
+	found: boolean;
+	content?: string;
+}
+
+const rulebookSchema = Type.Object({
+	name: Type.String({ description: "The name of the rule to fetch" }),
+});
+
+/**
+ * Create a rulebook tool with access to discovered rules.
+ * @param rules - Array of discovered rules (non-TTSR rules with descriptions)
+ */
+export function createRulebookTool(rules: Rule[]): AgentTool<typeof rulebookSchema> {
+	// Build lookup map for O(1) access
+	const ruleMap = new Map<string, Rule>();
+	for (const rule of rules) {
+		ruleMap.set(rule.name, rule);
+	}
+
+	const ruleNames = rules.map((r) => r.name);
+
+	return {
+		name: "rulebook",
+		label: "Rulebook",
+		description: `Fetch the full content of a project rule by name. Use this when a rule listed in <available_rules> is relevant to your current task. Available: ${ruleNames.join(", ") || "(none)"}`,
+		parameters: rulebookSchema,
+		execute: async (_toolCallId: string, { name }: { name: string }) => {
+			const rule = ruleMap.get(name);
+
+			if (!rule) {
+				const available = ruleNames.join(", ");
+				return {
+					content: [{ type: "text", text: `Rule "${name}" not found. Available rules: ${available || "(none)"}` }],
+					details: {
+						type: "rulebook",
+						ruleName: name,
+						found: false,
+					} satisfies RulebookToolDetails,
+				};
+			}
+
+			return {
+				content: [{ type: "text", text: `# Rule: ${rule.name}\n\n${rule.content}` }],
+				details: {
+					type: "rulebook",
+					ruleName: name,
+					found: true,
+					content: rule.content,
+				} satisfies RulebookToolDetails,
+			};
+		},
+	};
+}
+
+/**
+ * Filter rules to only those suitable for the rulebook (have descriptions, no TTSR trigger).
+ */
+export function filterRulebookRules(rules: Rule[]): Rule[] {
+	return rules.filter((rule) => {
+		// Exclude TTSR rules (handled separately by streaming)
+		if (rule.ttsrTrigger) return false;
+		// Exclude always-apply rules (already in context)
+		if (rule.alwaysApply) return false;
+		// Must have a description for agent to know when to fetch
+		if (!rule.description) return false;
+		return true;
+	});
+}
+
+/**
+ * Format rules for inclusion in the system prompt.
+ * Lists rule names and descriptions so the agent knows what's available.
+ */
+export function formatRulesForPrompt(rules: Rule[]): string {
+	if (rules.length === 0) {
+		return "";
+	}
+
+	const lines = [
+		"\n\n## Available Rules",
+		"",
+		"The following project rules are available. Use the `rulebook` tool to fetch a rule's full content when it's relevant to your task.",
+		"",
+		"<available_rules>",
+	];
+
+	for (const rule of rules) {
+		lines.push("  <rule>");
+		lines.push(`    <name>${escapeXml(rule.name)}</name>`);
+		lines.push(`    <description>${escapeXml(rule.description || "")}</description>`);
+		if (rule.globs && rule.globs.length > 0) {
+			lines.push(`    <globs>${escapeXml(rule.globs.join(", "))}</globs>`);
+		}
+		lines.push("  </rule>");
+	}
+
+	lines.push("</available_rules>");
+
+	return lines.join("\n");
+}
+
+function escapeXml(str: string): string {
+	return str
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}