refactor(llm): remove content enhancement rules and update related modules

- Deleted the content enhancement rules module and its associated logic from the LLM text generation process.
- Updated the getLLMText function to remove enhancement rule application.
- Refactored normalizeLLMBody and related tests to support asynchronous processing.
- Adjusted route handlers to ensure proper content type headers for markdown responses.

Author: SeieunYoo

docs/app/_llms/content-enhancement-rules.ts

@@ -1,35 +1,22 @@
 import type { LLMPage, Section } from "./types";
 import { getGitHubSourceUrl } from "./config";
 import { normalizeLLMBody } from "./normalize-llm-body";
-import { CONTENT_ENHANCEMENT_RULES } from "./content-enhancement-rules";
 
 export async function getLLMText(page: LLMPage, section: Section): Promise<string> {
-  const processed = normalizeLLMBody(await page.data.getText("processed"));
+  const processed = await normalizeLLMBody(await page.data.getText("processed"));
   const sourceUrl = getGitHubSourceUrl(section, page.path);
 
-  let content = `# ${page.data.title}
-
+  return `# ${page.data.title}
 URL: ${page.url}
 Source: ${sourceUrl}
 
 ${page.data.description ?? ""}
 
 ${processed}`;
-
-  // Apply content enhancement rules
-  for (const rule of CONTENT_ENHANCEMENT_RULES) {
-    if (rule.shouldApply(page, section)) {
-      console.log(`[getLLMText] Applying enhancement rule: ${rule.name}`);
-      content = await rule.enhance(content, page);
-    }
-  }
-
-  // Normalize the final content after enhancements
-  return normalizeLLMBody(content);
 }
 
 export async function getLLMTextForFullCompilation(page: LLMPage): Promise<string> {
-  const processed = normalizeLLMBody(await page.data.getText("processed"));
+  const processed = await normalizeLLMBody(await page.data.getText("processed"));
 
   return `file: ${page.path}
 

docs/app/_llms/get-llm-text.ts

@@ -3,11 +3,11 @@ import { normalizeLLMBody } from "./normalize-llm-body";
 import { normalizeForAssert, readFixture } from "./test-utils";
 
 describe("normalizeLLMBody pipeline", () => {
-  it("applies ComponentExample and CodeBlockTabs rules together", () => {
+  it("applies ComponentExample and CodeBlockTabs rules together", async () => {
     const input = readFixture("pipeline", "combined.input.mdx");
     const expected = readFixture("pipeline", "combined.output.mdx");
 
-    const actual = normalizeLLMBody(input);
+    const actual = await normalizeLLMBody(input);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });

docs/app/_llms/normalize-llm-body.pipeline.test.ts

@@ -54,16 +54,64 @@ function hasChildren(node: RootContent): node is RootContent & { children: RootC
   return "children" in node && Array.isArray(node.children);
 }
 
-function transformNodes(nodes: RootContent[], rules: Rule[], context: RuleContext): RootContent[] {
+/*
+  비동기 rule의 결과를 트리 전체에서 미리 수집합니다.
+  재귀 async 호출을 하나의 await로 줄여 Next.js AsyncLocalStorage Map 폭발을 방지합니다. (Map maximum size exceeded 에러)
+*/
+async function collectAsyncResults(
+  nodes: RootContent[],
+  rules: Rule[],
+  context: RuleContext,
+  cache: Map<MdxJsxFlowElement, RootContent[]>,
+): Promise<void> {
+  const promises: Promise<void>[] = [];
+
+  function walk(nodes: RootContent[]): void {
+    for (const node of nodes) {
+      if (isMdxJsxFlowElement(node)) {
+        const matchedRule = rules.find((rule) => rule.match(node));
+        if (matchedRule) {
+          const result = matchedRule.transform(node, context);
+          if (result instanceof Promise) {
+            promises.push(
+              result
+                .then((r) => cache.set(node, r))
+                .catch(() => cache.set(node, [node]))
+                .then(() => {}),
+            );
+          } else {
+            cache.set(node, result);
+          }
+          continue;
+        }
+      }
+      if (hasChildren(node)) walk(node.children);
+    }
+  }
+
+  walk(nodes);
+  await Promise.all(promises);
+}
+
+/*
+  async 결과가 캐시된 상태에서 동기적으로 트리를 변환합니다.
+*/
+function transformNodesSync(
+  nodes: RootContent[],
+  rules: Rule[],
+  context: RuleContext,
+  cache: Map<MdxJsxFlowElement, RootContent[]>,
+): RootContent[] {
   const transformed: RootContent[] = [];
 
   for (const node of nodes) {
     if (isMdxJsxFlowElement(node)) {
       const matchedRule = rules.find((rule) => rule.match(node));
       if (matchedRule) {
         try {
-          const nextNodes = matchedRule.transform(node, context);
-          transformed.push(...transformNodes(nextNodes, rules, context));
+          const cachedOrResult = cache.get(node) ?? matchedRule.transform(node, context);
+          const nextNodes = cachedOrResult instanceof Promise ? [node] : cachedOrResult;
+          transformed.push(...transformNodesSync(nextNodes, rules, context, cache));
         } catch {
           transformed.push(node);
         }
@@ -74,7 +122,7 @@ function transformNodes(nodes: RootContent[], rules: Rule[], context: RuleContex
     if (hasChildren(node)) {
       transformed.push({
         ...node,
-        children: transformNodes(node.children, rules, context),
+        children: transformNodesSync(node.children, rules, context, cache),
       } as RootContent);
       continue;
     }
@@ -85,7 +133,10 @@ function transformNodes(nodes: RootContent[], rules: Rule[], context: RuleContex
   return transformed;
 }
 
-export function normalizeLLMBodyWithRules(content: string | undefined, rules: Rule[]): string {
+export async function normalizeLLMBodyWithRules(
+  content: string | undefined,
+  rules: Rule[],
+): Promise<string> {
   if (!content) return "";
 
   const context: RuleContext = {
@@ -94,14 +145,20 @@ export function normalizeLLMBodyWithRules(content: string | undefined, rules: Ru
   };
 
   const tree = processor.parse(content) as Root;
-  tree.children = transformNodes(tree.children as RootContent[], rules, context);
+
+  // 1단계: async rule 결과를 한 번의 await로 모두 수집
+  const cache = new Map<MdxJsxFlowElement, RootContent[]>();
+  await collectAsyncResults(tree.children as RootContent[], rules, context, cache);
+
+  // 2단계: 캐시된 결과로 동기 변환
+  tree.children = transformNodesSync(tree.children as RootContent[], rules, context, cache);
 
   return processor
     .stringify(tree)
     .replace(/\n{3,}/g, "\n\n")
     .trim();
 }
 
-export function normalizeLLMBody(content?: string): string {
+export async function normalizeLLMBody(content?: string): Promise<string> {
   return normalizeLLMBodyWithRules(content, activeRules);
 }

docs/app/_llms/normalize-llm-body.ts

@@ -4,29 +4,29 @@ import { normalizeForAssert, readFixture } from "../test-utils";
 import { codeBlockTabsRule } from "./codeblock-tabs-rule";
 
 describe("codeBlockTabsRule", () => {
-  it("converts known package managers to sorted markdown list", () => {
+  it("converts known package managers to sorted markdown list", async () => {
     const input = readFixture("codeblock-tabs", "basic.input.mdx");
     const expected = readFixture("codeblock-tabs", "basic.output.mdx");
 
-    const actual = normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
+    const actual = await normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });
 
-  it("sorts known managers first and appends unknown managers", () => {
+  it("sorts known managers first and appends unknown managers", async () => {
     const input = readFixture("codeblock-tabs", "partial.input.mdx");
     const expected = readFixture("codeblock-tabs", "partial.output.mdx");
 
-    const actual = normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
+    const actual = await normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });
 
-  it("keeps the original node when tabs are malformed", () => {
+  it("keeps the original node when tabs are malformed", async () => {
     const input = readFixture("codeblock-tabs", "malformed.input.mdx");
     const expected = readFixture("codeblock-tabs", "malformed.output.mdx");
 
-    const actual = normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
+    const actual = await normalizeLLMBodyWithRules(input, [codeBlockTabsRule]);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });

docs/app/_llms/rules/codeblock-tabs-rule.test.ts

@@ -4,20 +4,20 @@ import { normalizeForAssert, readFixture } from "../test-utils";
 import { componentExampleRule } from "./component-example-rule";
 
 describe("componentExampleRule", () => {
-  it("adds preview heading when name ends with /preview", () => {
+  it("adds preview heading when name ends with /preview", async () => {
     const input = readFixture("component-example", "component-example.input.mdx");
     const expected = readFixture("component-example", "component-example.output.mdx");
 
-    const actual = normalizeLLMBodyWithRules(input, [componentExampleRule]);
+    const actual = await normalizeLLMBodyWithRules(input, [componentExampleRule]);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });
 
-  it("unwraps non-preview examples without adding a heading", () => {
+  it("unwraps non-preview examples without adding a heading", async () => {
     const input = readFixture("component-example", "non-preview.input.mdx");
     const expected = readFixture("component-example", "non-preview.output.mdx");
 
-    const actual = normalizeLLMBodyWithRules(input, [componentExampleRule]);
+    const actual = await normalizeLLMBodyWithRules(input, [componentExampleRule]);
 
     expect(normalizeForAssert(actual)).toBe(normalizeForAssert(expected));
   });

docs/app/_llms/rules/component-example-rule.test.ts

@@ -0,0 +1,44 @@
+export interface EstreeNode {
+  type: string;
+}
+
+export interface ProgramNode extends EstreeNode {
+  type: "Program";
+  body: EstreeNode[];
+}
+
+export interface ExpressionStatementNode extends EstreeNode {
+  type: "ExpressionStatement";
+  expression: EstreeNode;
+}
+
+export interface ArrayExpressionNode extends EstreeNode {
+  type: "ArrayExpression";
+  elements: (EstreeNode | null)[];
+}
+
+export interface LiteralNode extends EstreeNode {
+  type: "Literal";
+  value: unknown;
+}
+
+export function isProgramNode(node: unknown): node is ProgramNode {
+  return Boolean(node) && typeof node === "object" && (node as EstreeNode).type === "Program";
+}
+
+export function isExpressionStatementNode(node: unknown): node is ExpressionStatementNode {
+  return (
+    Boolean(node) &&
+    typeof node === "object" &&
+    (node as EstreeNode).type === "ExpressionStatement" &&
+    "expression" in (node as ExpressionStatementNode)
+  );
+}
+
+export function isLiteralNode(node: unknown): node is LiteralNode {
+  return Boolean(node) && typeof node === "object" && (node as EstreeNode).type === "Literal";
+}
+
+export function isStringLiteral(node: unknown): node is LiteralNode & { value: string } {
+  return isLiteralNode(node) && typeof (node as LiteralNode).value === "string";
+}