-if (!process.env.OPENAI_API_KEY) {
-    throw new Error('OPENAI_API_KEY is not set');
-}

   if (!filePathArg) {
       throw new Error('File path is required');
   }
+  if (!process.env.OPENAI_API_KEY) {
+      throw new Error('OPENAI_API_KEY is required');
+  }

-async function generateDescription({
+const MAX_CHARS = 250;
+const MAX_ATTEMPTS = 3;
+
+async function generateDescription({
     articleText,
     frontmatterAttributes,
-    previousAttempt
+    previousAttempt,
+    attempt = 1
 }: {
     articleText: string;
     frontmatterAttributes: Record<string, any>;
     previousAttempt?: {
         text: string;
         characterCount: number;
-    };
+    };
+    attempt?: number;
 }) {

-    if (characterCount > 250) {
-        console.log(`Character count is too long (${characterCount}), generating again...`);
-        return generateDescription({
+    if (characterCount > MAX_CHARS) {
+        if (attempt >= MAX_ATTEMPTS) {
+            const clipped = normalized.slice(0, MAX_CHARS);
+            return { description: clipped, characterCount: MAX_CHARS };
+        }
+        console.log(`Over limit (${characterCount} chars). Regenerating (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`);
+        return generateDescription({
             articleText,
             frontmatterAttributes,
             previousAttempt: {
-                text,
-                characterCount
-            }
+                text: normalized,
+                characterCount
+            },
+            attempt: attempt + 1
         });
     }

-    const dom = new JSDOM(html);
-    const articleElement = dom.window.document.querySelector('article');
-    const articleText = articleElement ? articleElement.textContent : '';
+    const dom = new JSDOM(html);
+    const articleElement =
+        dom.window.document.querySelector('article, main') ?? dom.window.document.body;
+    const articleText = (articleElement?.textContent || '').replace(/\s+/g, ' ').trim();

-    const { articleText, frontmatterAttributes } = await getDocPageContent(resolvedPath);
-
-    if (!articleText || !frontmatterAttributes) {
-        throw new Error('Article text or frontmatter attributes are undefined');
-    }
-
-    const { description, characterCount } = await generateDescription({
-        articleText,
-        frontmatterAttributes
-    });
+    const { articleText, frontmatterAttributes } = await getDocPageContent(resolvedPath);
+    const pageContent =
+        articleText ||
+        [frontmatterAttributes?.title, frontmatterAttributes?.description, frontmatterAttributes?.summary]
+            .filter(Boolean)
+            .join(': ');
+    if (!pageContent) {
+        throw new Error('No content available to generate a description');
+    }
+    const { description, characterCount } = await generateDescription({
+        articleText: pageContent,
+        frontmatterAttributes
+    });

-const isDirect = import.meta.url === pathToFileURL(process.argv[1]).href;
+const scriptPath = process.argv[1]?.endsWith('tsx') ? process.argv[2] : process.argv[1];
+const isDirect =
+  !!scriptPath && import.meta.url === pathToFileURL(path.resolve(scriptPath)).href;

 async function generateDescription({
   articleText,
   frontmatterAttributes,
 }: {
   articleText: string;
   frontmatterAttributes: Record<
     string,
     string | number | boolean | Date | string[] | number[] | boolean[]
   >;
 }) {
-  const systemPrompt = `You are an expert at writing SEO-optimized page descriptions for technical documentation websites targeting senior software engineers.
+  const MAX_CHARS = 250;
+  const systemPrompt = `You are an expert at writing SEO-optimized page descriptions for technical documentation websites targeting senior software engineers.
 
-Generate a concise, professional description (maximum 250 characters) that:
+Generate a concise, professional description (maximum ${MAX_CHARS} characters) that:
 - Accurately summarizes the technical content
 - Uses natural language with standard punctuation (use regular hyphens, not em dashes)
 - Speaks directly to experienced developers and engineering leaders
 - Includes relevant technical keywords for SEO
 - Avoids AI-generated language patterns or marketing fluff
 - Uses a professional, authoritative tone that resonates with senior engineers
 
 The description should be suitable for use in HTML meta descriptions and social media previews.`;
 
   const userPrompt = `Generate a page description for this documentation page:
 
 Title: ${frontmatterAttributes?.title || "Untitled"}
 Summary: ${frontmatterAttributes?.summary || "No summary provided"}
 
 Content:
 ${articleText}
 
-Generate a description that captures the essence of this page in 250 characters or less.`;
+Generate a description that captures the essence of this page in ${MAX_CHARS} characters or less.`;
 
   try {
     const { text: description } = await generateText({
       model: openai("gpt-4o-mini"),
       system: systemPrompt,
       prompt: userPrompt,
       maxTokens: 100,
     });
 
-    const trimmedDescription = description.trim();
-    const characterCount = trimmedDescription.length;
+    const normalized = description.replace(/\s+/g, " ").trim();
+    const characterCount = Array.from(normalized).length;
 
     // If the description is too long, try again with a more specific prompt
-    if (characterCount > 250) {
-      const retryPrompt = `The previous description was too long (${characterCount} characters). Generate a shorter description (maximum 250 characters) for this page:
+    if (characterCount > MAX_CHARS) {
+      const retryPrompt = `The previous description was too long (${characterCount} characters). Generate a shorter description (maximum ${MAX_CHARS} characters) for this page:
 
 Title: ${frontmatterAttributes?.title || "Untitled"}
 Content: ${articleText.substring(0, 500)}...
 
-Make it concise and under 250 characters.`;
+Make it concise and under ${MAX_CHARS} characters.`;
 
       const { text: retryDescription } = await generateText({
         model: openai("gpt-4o-mini"),
         system: systemPrompt,
         prompt: retryPrompt,
         maxTokens: 80,
       });
 
-      const finalDescription = retryDescription.trim();
-      return {
-        description: finalDescription,
-        characterCount: finalDescription.length,
-      };
+      let final = retryDescription.replace(/\s+/g, " ").trim();
+      let finalCount = Array.from(final).length;
+      if (finalCount > MAX_CHARS) {
+        final = Array.from(final).slice(0, MAX_CHARS).join("");
+        finalCount = MAX_CHARS;
+      }
+      return { description: final, characterCount: finalCount };
     }
 
-    return { description: trimmedDescription, characterCount };
+    return { description: normalized, characterCount };
   } catch (error) {
     throw new Error(
       `Failed to generate description: ${error instanceof Error ? error.message : "Unknown error"}`,
     );
   }
 }