ALwrity AI Blog Writer - Added Google Grounding UI Implementation

frontend/src/hooks/useClaimFixer.ts

@@ -0,0 +1,94 @@
+import { useCallback } from 'react';
+import { BlogOutlineSection } from '../services/blogWriterApi';
+
+export const useClaimFixer = (
+  outline: BlogOutlineSection[],
+  sections: Record<string, string>,
+  onSectionsUpdate: (sections: Record<string, string>) => void
+) => {
+  // Sentence-level claim mapping and patching helpers
+  const normalized = useCallback((s: string) => s.toLowerCase().replace(/\s+/g, ' ').trim(), []);
+
+  const fuzzyScore = useCallback((a: string, b: string) => {
+    // Dice's coefficient over word bigrams for robustness (no deps)
+    const bigrams = (s: string) => {
+      const t = s.split(/\W+/).filter(Boolean);
+      const grams: string[] = [];
+      for (let i = 0; i < t.length - 1; i++) grams.push(`${t[i]} ${t[i+1]}`);
+      return grams;
+    };
+    const A = new Set(bigrams(a));
+    const B = new Set(bigrams(b));
+    if (!A.size || !B.size) return 0;
+    let overlap = 0;
+    A.forEach(g => { if (B.has(g)) overlap++; });
+    return (2 * overlap) / (A.size + B.size);
+  }, []);
+
+  const findSentenceForClaim = useCallback((md: string, claimText: string) => {
+    const text = md || '';
+    // Split by sentence enders; keep delimiters
+    const sentences = text.split(/(?<=[.!?])\s+/);
+    const normalizedClaim = claimText.trim().toLowerCase();
+    // Direct includes first
+    let bestIndex = sentences.findIndex(s => s.toLowerCase().includes(normalizedClaim));
+    if (bestIndex >= 0) return { sentence: sentences[bestIndex], index: bestIndex, sentences };
+    // Fallback: overlap ratio by words
+    const claimWords = normalizedClaim.split(/\W+/).filter(Boolean);
+    let bestScore = 0; bestIndex = -1;
+    sentences.forEach((s, i) => {
+      const sw = s.toLowerCase().split(/\W+/).filter(Boolean);
+      const overlap = claimWords.filter(w => sw.includes(w)).length;
+      const score = overlap / Math.max(claimWords.length, 1);
+      if (score > bestScore) { bestScore = score; bestIndex = i; }
+    });
+    // Second fallback: Dice coefficient on normalized strings
+    if (bestIndex < 0) {
+      let diceBest = 0; let diceIdx = -1;
+      sentences.forEach((s, i) => {
+        const sc = fuzzyScore(normalized(s), normalized(claimText));
+        if (sc > diceBest) { diceBest = sc; diceIdx = i; }
+      });
+      if (diceIdx >= 0) return { sentence: sentences[diceIdx], index: diceIdx, sentences };
+    }
+    if (bestIndex >= 0) return { sentence: sentences[bestIndex], index: bestIndex, sentences };
+    return { sentence: '', index: -1, sentences };
+  }, [normalized, fuzzyScore]);
+
+  const buildFullMarkdown = useCallback(() => {
+    if (!outline.length) return '';
+    return outline.map(s => `## ${s.heading}\n\n${sections[s.id] || ''}`).join('\n\n');
+  }, [outline, sections]);
+
+  const buildUpdatedMarkdownForClaim = useCallback((claimText: string, supportingUrl?: string) => {
+    const md = buildFullMarkdown();
+    const { sentence, index, sentences } = findSentenceForClaim(md, claimText);
+    if (!sentence || index < 0) return { original: '', updated: '', updatedMarkdown: md };
+    const alreadyHasLink = /\[[^\]]+\]\(([^)]+)\)/.test(sentence);
+    const fix = supportingUrl && !alreadyHasLink ? `${sentence} [source](${supportingUrl})` : sentence;
+    const updatedSentences = [...sentences];
+    updatedSentences[index] = fix;
+    const updatedMarkdown = updatedSentences.join(' ');
+    return { original: sentence, updated: fix, updatedMarkdown };
+  }, [buildFullMarkdown, findSentenceForClaim]);
+
+  const applyClaimFix = useCallback((claimText: string, supportingUrl?: string) => {
+    // Naive fix: append citation footnote to the first occurrence of claim text
+    const { updatedMarkdown } = buildUpdatedMarkdownForClaim(claimText, supportingUrl);
+    const updated = updatedMarkdown;
+    // Re-split content back to per-section, by headings
+    const parts = updated.split(/^## /gm).filter(Boolean);
+    const newSections: Record<string, string> = {};
+    outline.forEach((s, idx) => {
+      const body = parts[idx] ? parts[idx].replace(new RegExp(`^${s.heading}\n\n?`), '') : (sections[s.id] || '');
+      newSections[s.id] = body;
+    });
+    onSectionsUpdate(newSections);
+  }, [buildUpdatedMarkdownForClaim, outline, sections, onSectionsUpdate]);
+
+  return {
+    buildFullMarkdown,
+    buildUpdatedMarkdownForClaim,
+    applyClaimFix
+  };
+};