update

backend/src/agents/orchestrator.ts

@@ -125,18 +125,30 @@ export class Orchestrator {
 
       // Step 4: Quality Check
       onProgress("quality", "running", "Running quality validation...");
-      const validationResult = await this.archestra.callTool("validate_readme", { readme });
-      const validation = safeJsonParse(extractToolText(validationResult));
+      let validation: any = { score: 70, categories: {}, suggestions: ["Quality scoring was unavailable — default score applied."] };
+      try {
+        const validationResult = await this.archestra.callTool("validate_readme", { readme });
+        const validationText = extractToolText(validationResult);
+        validation = safeJsonParse(validationText);
+      } catch (scoreError: any) {
+        console.warn("Quality scoring failed (non-fatal):", scoreError.message);
+        onProgress("quality", "running", "Scoring unavailable — proceeding with generated README...");
+      }
 
       let finalReadme = readme;
       const score = validation.score || 0;
       if (score < 80) {
         onProgress("quality", "running", `Score ${score}/100 — enhancing...`);
-        const enhancedResult = await this.archestra.callTool("enhance_readme", {
-          readme,
-          suggestions: (validation.suggestions || []).join(", ")
-        });
-        finalReadme = extractToolText(enhancedResult);
+        try {
+          const enhancedResult = await this.archestra.callTool("enhance_readme", {
+            readme,
+            suggestions: (validation.suggestions || []).join(", ")
+          });
+          finalReadme = extractToolText(enhancedResult);
+        } catch (enhanceError: any) {
+          console.warn("Enhancement failed (non-fatal):", enhanceError.message);
+          // Keep the original readme
+        }
       }
 
       onProgress("quality", "complete", `Quality Score: ${score}/100`);
@@ -252,8 +264,13 @@ export class Orchestrator {
 
       if (onProgress) onProgress("quality", "running", "Re-validating improved README...");
 
-      const validationResult = await this.archestra.callTool("validate_readme", { readme: enhanced });
-      const validation = safeJsonParse(extractToolText(validationResult));
+      let validation: any = { score: 75, categories: {}, suggestions: ["Re-scoring was unavailable — default score applied."] };
+      try {
+        const validationResult = await this.archestra.callTool("validate_readme", { readme: enhanced });
+        validation = safeJsonParse(extractToolText(validationResult));
+      } catch (scoreError: any) {
+        console.warn("Re-validation scoring failed (non-fatal):", scoreError.message);
+      }
 
       if (onProgress) onProgress("quality", "complete", `New Score: ${validation.score}/100`);
 

backend/src/utils/json.ts

@@ -1,43 +1,127 @@
 export function safeJsonParse(text: string): any {
+  // Pre-clean: strip markdown code fences the LLM may have wrapped around JSON
+  let cleaned = text.trim();
+  const fenceMatch = cleaned.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/);
+  if (fenceMatch) cleaned = fenceMatch[1].trim();
+
   try {
-    // Attempt standard parse
-    return JSON.parse(text);
-  } catch (e) {
-    // Attempt to extract JSON from markdown code blocks
+    return JSON.parse(cleaned);
+  } catch (firstError) {
+    // ── Strategy 1: extract JSON from code blocks inside larger text ──
     const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/) || text.match(/```\s*([\s\S]*?)\s*```/);
     if (jsonMatch && jsonMatch[1]) {
       try {
         return JSON.parse(jsonMatch[1].trim());
-      } catch (innerError) {
-        throw new Error(`Failed to parse extracted JSON: ${innerError}`);
-      }
+      } catch { /* fall through */ }
     }
-    
-    // If no code blocks, try to find the first '{' or '[' and last '}' or ']'
-    const firstBrace = text.indexOf('{');
-    const lastBrace = text.lastIndexOf('}');
-    const firstBracket = text.indexOf('[');
-    const lastBracket = text.lastIndexOf(']');
+
+    // ── Strategy 2: find the outermost { … } or [ … ] ──
+    const firstBrace = cleaned.indexOf('{');
+    const lastBrace = cleaned.lastIndexOf('}');
+    const firstBracket = cleaned.indexOf('[');
+    const lastBracket = cleaned.lastIndexOf(']');
 
     let start = -1;
     let end = -1;
-
     if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
-        start = firstBrace;
-        end = lastBrace;
+      start = firstBrace;
+      end = lastBrace;
     } else if (firstBracket !== -1) {
-        start = firstBracket;
-        end = lastBracket;
+      start = firstBracket;
+      end = lastBracket;
     }
 
     if (start !== -1 && end !== -1 && end > start) {
-        try {
-            return JSON.parse(text.substring(start, end + 1));
-        } catch (innerError) {
-            // Fall through to original error
-        }
+      try {
+        return JSON.parse(cleaned.substring(start, end + 1));
+      } catch { /* fall through */ }
+    }
+
+    // ── Strategy 3: repair truncated JSON (e.g. unterminated strings) ──
+    // This happens when Gemini hits maxOutputTokens mid-response
+    if (start !== -1) {
+      let partial = cleaned.substring(start, end !== -1 && end > start ? end + 1 : undefined);
+      try {
+        return repairAndParseJSON(partial);
+      } catch { /* fall through */ }
     }
 
-    throw e;
+    throw firstError;
   }
 }
+
+/**
+ * Attempt to repair truncated JSON that was cut off mid-generation.
+ * Handles: unterminated strings, missing closing braces/brackets, trailing commas.
+ */
+function repairAndParseJSON(raw: string): any {
+  let s = raw;
+
+  // Remove trailing incomplete key-value pairs (e.g. `, "key": "unterminated...`)
+  // Step 1: close any unterminated strings by counting quotes
+  let inString = false;
+  let escaped = false;
+  let lastGoodIndex = 0;
+
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch === '"') {
+      inString = !inString;
+      if (!inString) lastGoodIndex = i; // end of a complete string
+    }
+    if (!inString) lastGoodIndex = i;
+  }
+
+  // If we ended inside a string, truncate to last good position and close the string
+  if (inString) {
+    s = s.substring(0, lastGoodIndex + 1);
+    // If the last good char was the opening quote of a value, remove the dangling key
+    // Otherwise close the string we were inside
+  }
+
+  // Remove trailing commas before we add closing braces
+  s = s.replace(/,\s*$/, '');
+
+  // Count open vs close braces and brackets
+  let braces = 0;
+  let brackets = 0;
+  inString = false;
+  escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch === '"') { inString = !inString; continue; }
+    if (inString) continue;
+    if (ch === '{') braces++;
+    else if (ch === '}') braces--;
+    else if (ch === '[') brackets++;
+    else if (ch === ']') brackets--;
+  }
+
+  // Remove trailing incomplete entries (trailing commas, partial keys)
+  s = s.replace(/,\s*"[^"]*"?\s*:?\s*"?[^"]*$/, '');
+  s = s.replace(/,\s*$/, '');
+
+  // Re-count after cleanup
+  braces = 0; brackets = 0; inString = false; escaped = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch === '"') { inString = !inString; continue; }
+    if (inString) continue;
+    if (ch === '{') braces++;
+    else if (ch === '}') braces--;
+    else if (ch === '[') brackets++;
+    else if (ch === ']') brackets--;
+  }
+
+  // Close any remaining open brackets/braces
+  while (brackets > 0) { s += ']'; brackets--; }
+  while (braces > 0) { s += '}'; braces--; }
+
+  return JSON.parse(s);
+}

mcp-servers/doc-generator/src/index.mts

@@ -17,7 +17,7 @@ const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
 const GEMINI_MODEL = "gemini-2.5-flash";
 const GEMINI_URL = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent?key=${GEMINI_API_KEY}`;
 
-async function callGemini(messages: any[], maxTokens: number = 4000) {
+async function callGemini(messages: any[], maxTokens: number = 8192) {
   if (!GEMINI_API_KEY) throw new Error("GEMINI_API_KEY not set");
 
   // Convert OpenAI-style messages to Gemini format
@@ -124,7 +124,7 @@ function createServer() {
       // Style-specific system prompts and token limits
       const stylePrompts: Record<string, { prompt: string; tokens: number }> = {
         minimal: {
-          tokens: 1500,
+          tokens: 4096,
           prompt: `You are a concise technical writer. Generate a MINIMAL README.md — short, clean, and actionable.
 
 Include ONLY these sections:
@@ -141,7 +141,7 @@ Rules:
 - Maximum ~150 lines total`
         },
         standard: {
-          tokens: 3000,
+          tokens: 8192,
           prompt: `You are a world-class technical writer who creates beautiful, comprehensive README.md files. You write READMEs that developers LOVE — clear, professional, and visually appealing.
 
 Include these sections:
@@ -164,7 +164,7 @@ Rules:
 - Be thorough but concise`
         },
         detailed: {
-          tokens: 4000,
+          tokens: 16384,
           prompt: `You are a world-class technical writer who creates beautiful, comprehensive README.md files for open-source projects. You write READMEs that developers LOVE — clear, professional, and visually appealing.
 
 Your README MUST include ALL of the following sections (skip only if truly irrelevant):

mcp-servers/readme-improver/src/index.mts

@@ -17,7 +17,7 @@ const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
 const GEMINI_MODEL = "gemini-2.5-flash";
 const GEMINI_URL = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent?key=${GEMINI_API_KEY}`;
 
-async function callGemini(messages: any[], maxTokens = 4000): Promise<string> {
+async function callGemini(messages: any[], maxTokens = 8192): Promise<string> {
     if (!GEMINI_API_KEY) throw new Error("GEMINI_API_KEY not set");
 
     const systemInstruction = messages.find((m: any) => m.role === 'system')?.content || '';
@@ -139,7 +139,7 @@ ${readme.substring(0, 15000)}`;
             const improved = await callGemini([
                 { role: "system", content: "You are an expert technical writer who improves open-source documentation. Return ONLY the improved README in raw Markdown. Never wrap in code blocks." },
                 { role: "user", content: prompt }
-            ], 4000);
+            ], 8192);
             return {
                 content: [{ type: "text", text: improved }],
             };

mcp-servers/readme-scorer/src/index.mts

@@ -17,7 +17,7 @@ const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
 const GEMINI_MODEL = "gemini-2.5-flash";
 const GEMINI_URL = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent?key=${GEMINI_API_KEY}`;
 
-async function callGemini(messages: any[], maxTokens = 1000): Promise<string> {
+async function callGemini(messages: any[], maxTokens = 2048, responseFormat?: string): Promise<string> {
     if (!GEMINI_API_KEY) throw new Error("GEMINI_API_KEY not set");
 
     const systemInstruction = messages.find((m: any) => m.role === 'system')?.content || '';
@@ -34,16 +34,20 @@ async function callGemini(messages: any[], maxTokens = 1000): Promise<string> {
         try {
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(), 90_000);
+            const generationConfig: any = {
+                temperature: 0.3,
+                maxOutputTokens: maxTokens,
+            };
+            if (responseFormat) {
+                generationConfig.responseMimeType = responseFormat;
+            }
             const response = await fetch(GEMINI_URL, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({
                     ...(systemInstruction ? { systemInstruction: { parts: [{ text: systemInstruction }] } } : {}),
                     contents,
-                    generationConfig: {
-                        temperature: 0.3,
-                        maxOutputTokens: maxTokens,
-                    },
+                    generationConfig,
                 }),
                 signal: controller.signal,
             });
@@ -143,7 +147,7 @@ ${readme.substring(0, 12000)}`;
             const validation = await callGemini([
                 { role: "system", content: "You are a documentation QA specialist who scores README files. Return ONLY valid JSON, no markdown wrapping, no backticks." },
                 { role: "user", content: prompt }
-            ]);
+            ], 2048, "application/json");
             return {
                 content: [{ type: "text", text: validation }],
             };