rules injection signature on tool call

.gitignore

···
 node_modules
+dist

src/index.ts

···
 
 /**
  * Registry to track which rules have been read in each session.
+ * Uses WeakMap for automatic cleanup when sessions are garbage collected.
  */
 const sessionRulesRead = new Map<string, Set<string>>();
 
+/**
+ * Cleanup old sessions to prevent memory leaks.
+ * Should be called periodically or when sessions exceed a threshold.
+ */
+function cleanupOldSessions(maxSessions = 1000): void {
+	if (sessionRulesRead.size > maxSessions) {
+		const entries = Array.from(sessionRulesRead.entries());
+		// Remove oldest half
+		for (let i = 0; i < entries.length / 2; i++) {
+			sessionRulesRead.delete(entries[i]![0]);
+		}
+	}
+}
+
+/**
+ * Checks if rules should be prompted for a session/language combo.
+ * Returns true if this is the first time, and marks it as read.
+ */
+function shouldPromptForRules(sessionID: string, language: string): boolean {
+	if (!sessionRulesRead.has(sessionID)) {
+		sessionRulesRead.set(sessionID, new Set());
+	}
+
+	const rulesSet = sessionRulesRead.get(sessionID);
+	if (!rulesSet || rulesSet.has(language)) {
+		return false;
+	}
+
+	rulesSet.add(language);
+	return true;
+}
+
 export const LangRulesPlugin: Plugin = async ({ client, directory }) => {
 	return {
 		tool: {
···
 					if (sessionID) {
 						if (!sessionRulesRead.has(sessionID)) {
 							sessionRulesRead.set(sessionID, new Set());
+							cleanupOldSessions();
 						}
 
-						sessionRulesRead.get(sessionID)?.add(languageFile);
+						const rulesSet = sessionRulesRead.get(sessionID);
+						if (rulesSet) {
+							rulesSet.add(languageFile);
+						}
 					}
 
 					const paths = [`${directory}/.rules/${languageFile}.md`];
···
 
 					for (const rulePath of paths) {
 						try {
-							const content = readFileSync(rulePath).toString();
+							const content = readFileSync(rulePath, "utf-8");
 							if (content.trim()) return content.trim();
-						} catch {}
+						} catch (error) {}
 					}
 
 					return `No rule file found for '${languageFile}'`;
···
 			}),
 		},
 
-		"tool.execute.before": async (input) => {
-			const { sessionID, args } = input as {
-				tool: string;
-				sessionID: string;
-				callID: string;
-				args?: Record<string, unknown>;
-			};
+		"tool.execute.before": async (input, output) => {
+			const { sessionID } = input;
+			const { args } = output;
 
 			if (!sessionID) return;
 
 			const filePath = (args?.filePath as string) || (args?.path as string);
-			if (!filePath) return;
+			if (!filePath || typeof filePath !== "string") return;
 
 			const language = getLanguageFromFilePath(filePath);
-			const ext = filePath.split(".").pop()?.toLowerCase() || "";
+			if (!language) return;
 
-			if (language && !sessionRulesRead.get(sessionID)?.has(language))
+			if (shouldPromptForRules(sessionID, language)) {
+				const ext = filePath.split(".").pop()?.toLowerCase() || "";
 				client.session.prompt({
 					path: {
 						id: sessionID,
···
 							{
 								synthetic: true,
 								type: "text",
-								text: `**Hint:** You're about to modify a \`${ext}\` file (${language}). Consider reading the ${language} coding rules: \`langrules({ language: '${language}' }})\``,
+								text: `**Hint:** You're about to modify a \`${ext}\` file (${language}). Consider reading the ${language} coding rules: \`langrules({ language: '${language}' })\``,
 							},
 						],
 					},
 				});
+			}
 		},
 	};
 };