Upload 6 files

README.md

@@ -0,0 +1,29 @@
+---
+title: Link Audit Tool
+emoji: 🔗
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.12.0
+app_file: app.py
+pinned: false
+---
+
+# 🔗 Bulk Link Audit Tool
+
+SEO link audit tool that crawls pages, extracts body-content links, checks status, detects broken links, follow flags, duplicates, and orphan pages.
+
+## Features
+- **Batch processing** with auto-save to Supabase after each batch
+- **Proper pause/resume** — pause mid-audit, come back later, resume from where you left off
+- **Interactive HTML report** with accordion cells, filters, and issue highlighting
+- **Orphan page detection** after full crawl
+- **Follow flag detection** — internal nofollow ⚠, external dofollow ⚠
+- **Duplicate link detection** with body locations
+
+## Setup
+Add these secrets in your Space settings:
+- `SUPABASE_URL` — your Supabase project URL
+- `SUPABASE_KEY` — your Supabase anon key
+
+Then run the SQL schema from `db.py` in your Supabase SQL editor.

app.py

@@ -0,0 +1,633 @@
+"""
+Link Audit Tool — Gradio UI for Hugging Face Spaces
+Proper pause/resume via threading + Supabase persistence.
+"""
+
+import gradio as gr
+import pandas as pd
+import time
+import json
+import os
+import threading
+import tempfile
+from datetime import datetime
+from audit_engine import audit_page, DEFAULT_BODY_SELECTORS, DEFAULT_SUGGESTION_MAP
+from report_generator import generate_report
+from db import (
+    get_client, create_run, get_all_runs, get_all_page_results,
+    get_completed_urls, get_pending_urls, get_completed_count,
+    save_batch_results, update_run_status, delete_run,
+)
+
+# ─── Supabase Connection ───
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY", "")
+sb = None
+if SUPABASE_URL and SUPABASE_KEY:
+    try:
+        sb = get_client(SUPABASE_URL, SUPABASE_KEY)
+        sb.table("audit_runs").select("id").limit(1).execute()
+    except Exception as e:
+        print(f"Supabase connection failed: {e}")
+        sb = None
+
+# ─── Audit State (thread-safe) ───
+class AuditState:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.paused = False
+        self.running = False
+        self.run_id = None
+
+    def request_pause(self):
+        with self.lock:
+            self.paused = True
+
+    def resume(self):
+        with self.lock:
+            self.paused = False
+
+    def is_paused(self):
+        with self.lock:
+            return self.paused
+
+    def set_running(self, val, run_id=None):
+        with self.lock:
+            self.running = val
+            if run_id:
+                self.run_id = run_id
+
+    def is_running(self):
+        with self.lock:
+            return self.running
+
+audit_state = AuditState()
+
+
+# ═══════════════════════════════════════════════════
+#  CORE AUDIT FUNCTION (runs as generator for streaming)
+# ═══════════════════════════════════════════════════
+
+def run_audit(file, pasted_urls, domain, batch_size, timeout, delay, workers):
+    """Main audit generator — yields progress updates."""
+    if sb is None:
+        yield "❌ Supabase not connected. Set SUPABASE_URL and SUPABASE_KEY in Space secrets.", "", gr.update(), gr.update()
+        return
+
+    # Parse URLs
+    urls = []
+    if file is not None:
+        try:
+            if file.name.endswith('.csv'):
+                df = pd.read_csv(file.name)
+            else:
+                df = pd.read_excel(file.name)
+            url_col = None
+            for col in df.columns:
+                sample = str(df[col].iloc[0]).strip().lower()
+                if sample.startswith('http') or domain in sample:
+                    url_col = col
+                    break
+            if url_col is None:
+                url_col = df.columns[0]
+            urls = [u for u in df[url_col].dropna().astype(str).str.strip().tolist() if u.startswith('http')]
+        except Exception as e:
+            yield f"❌ File error: {e}", "", gr.update(), gr.update()
+            return
+    elif pasted_urls and pasted_urls.strip():
+        urls = [u.strip() for u in pasted_urls.strip().split('\n') if u.strip().startswith('http')]
+
+    if not urls:
+        yield "⚠ No valid URLs found. Upload a file or paste URLs.", "", gr.update(), gr.update()
+        return
+
+    # Deduplicate preserving order
+    seen = set()
+    unique_urls = []
+    for u in urls:
+        if u not in seen:
+            seen.add(u)
+            unique_urls.append(u)
+    urls = unique_urls
+
+    run_name = f"{domain} Audit — {datetime.now().strftime('%b %d %H:%M')} — {len(urls)} pages"
+    run_id = create_run(sb, run_name, domain, len(urls), urls)
+
+    audit_state.set_running(True, run_id)
+    audit_state.resume()  # Reset pause flag
+
+    total = len(urls)
+    start_time = time.time()
+    batch_num = 0
+    log_lines = []
+
+    yield f"🚀 Started: {run_name}\n📦 {total} URLs · Batch size: {batch_size}", "", gr.update(interactive=True), gr.update(interactive=False)
+
+    try:
+        for batch_start in range(0, total, batch_size):
+            # Check for pause
+            if audit_state.is_paused():
+                completed = get_completed_count(sb, run_id)
+                update_run_status(sb, run_id, "paused", completed)
+                log_lines.append(f"⏸️ PAUSED at {completed}/{total} — resume from Past Runs")
+                audit_state.set_running(False)
+                yield "\n".join(log_lines[-40:]), "", gr.update(interactive=False), gr.update(interactive=False)
+                return
+
+            batch_end = min(batch_start + batch_size, total)
+            batch_urls = urls[batch_start:batch_end]
+            batch_num += 1
+            batch_results = []
+
+            for j, url in enumerate(batch_urls):
+                # Check pause between each URL
+                if audit_state.is_paused():
+                    # Save partial batch
+                    if batch_results:
+                        save_batch_results(sb, run_id, batch_results)
+                    completed = get_completed_count(sb, run_id)
+                    update_run_status(sb, run_id, "paused", completed)
+                    log_lines.append(f"⏸️ PAUSED at {completed}/{total}")
+                    audit_state.set_running(False)
+                    yield "\n".join(log_lines[-40:]), "", gr.update(interactive=False), gr.update(interactive=False)
+                    return
+
+                global_idx = batch_start + j + 1
+                elapsed = time.time() - start_time
+                avg = elapsed / global_idx
+                eta = avg * (total - global_idx)
+                eta_str = f"{int(eta//60)}m {int(eta%60)}s" if eta > 60 else f"{eta:.0f}s"
+
+                result = audit_page(
+                    url, domain, DEFAULT_BODY_SELECTORS,
+                    suggestion_map=DEFAULT_SUGGESTION_MAP,
+                    timeout=timeout, concurrent_workers=workers,
+                )
+                batch_results.append(result)
+
+                short = url.replace('https://www.', '').replace('https://', '')[:70]
+                if result['error']:
+                    log_lines.append(f"❌ [{global_idx}/{total}] {short} — {result['error'][:50]}")
+                else:
+                    b = result['broken_int_count'] + result['broken_ext_count']
+                    fc = result['follow_flag_count']
+                    d = result['duplicate_count']
+                    flags = []
+                    if b: flags.append(f"🔴 {b} broken")
+                    if fc: flags.append(f"🟡 {fc} flags")
+                    if d: flags.append(f"🟣 {d} dups")
+                    flag_str = " · ".join(flags) if flags else "✅"
+                    log_lines.append(f"[{global_idx}/{total}] {short} — Int:{result['int_count']} Ext:{result['ext_count']} · {flag_str}")
+
+                progress_text = f"📊 Progress: {global_idx}/{total} ({global_idx*100//total}%) · Batch {batch_num} · ETA: {eta_str}"
+                yield "\n".join(log_lines[-40:]), progress_text, gr.update(interactive=True), gr.update(interactive=False)
+
+                if j < len(batch_urls) - 1:
+                    time.sleep(delay)
+
+            # Save batch to Supabase
+            if batch_results:
+                try:
+                    save_batch_results(sb, run_id, batch_results)
+                    completed = get_completed_count(sb, run_id)
+                    update_run_status(sb, run_id, "running", completed)
+                    log_lines.append(f"💾 Batch {batch_num} saved — {completed}/{total} done")
+                except Exception as e:
+                    log_lines.append(f"⚠ Batch save error: {str(e)[:60]}")
+
+                yield "\n".join(log_lines[-40:]), f"📊 Progress: {min(batch_end, total)}/{total} · Saved batch {batch_num}", gr.update(interactive=True), gr.update(interactive=False)
+                del batch_results
+
+        # ── ALL DONE — Orphan analysis ──
+        log_lines.append("🔍 Running orphan page analysis...")
+        yield "\n".join(log_lines[-40:]), f"📊 Orphan analysis...", gr.update(interactive=False), gr.update(interactive=False)
+
+        all_pages = get_all_page_results(sb, run_id)
+        all_results = [p['result'] for p in all_pages]
+
+        all_internal_targets = set()
+        all_page_urls = set()
+        for r in all_results:
+            all_page_urls.add(r['url'].rstrip('/').split('?')[0])
+            for link in r.get('internal_links', []):
+                all_internal_targets.add(link['url'].rstrip('/').split('?')[0])
+        orphan_pages = sorted([p for p in all_page_urls if p not in all_internal_targets])
+
+        summary = {
+            'total_pages': len(all_results),
+            'total_int': sum(r.get('int_count', 0) for r in all_results),
+            'total_ext': sum(r.get('ext_count', 0) for r in all_results),
+            'total_broken': sum(r.get('broken_int_count', 0) + r.get('broken_ext_count', 0) for r in all_results),
+            'total_redirects': sum(r.get('redirect_int_count', 0) + r.get('redirect_ext_count', 0) for r in all_results),
+            'total_flags': sum(r.get('follow_flag_count', 0) for r in all_results),
+            'total_dups': sum(r.get('duplicate_count', 0) for r in all_results),
+            'total_sug': sum(len(r.get('suggestions', [])) for r in all_results),
+            'orphan_count': len(orphan_pages),
+            'orphan_urls': orphan_pages[:100],
+        }
+        update_run_status(sb, run_id, "completed", len(all_results), summary)
+
+        total_time = time.time() - start_time
+        log_lines.append(f"✅ COMPLETE! {len(all_results)} pages in {total_time:.0f}s · {len(orphan_pages)} orphans")
+        log_lines.append(f"📊 Broken: {summary['total_broken']} · Redirects: {summary['total_redirects']} · Flags: {summary['total_flags']} · Dups: {summary['total_dups']}")
+        log_lines.append("→ Go to Past Runs tab to generate report")
+
+        audit_state.set_running(False)
+        yield "\n".join(log_lines[-40:]), f"✅ Complete — {len(all_results)} pages", gr.update(interactive=False), gr.update(interactive=False)
+
+    except Exception as e:
+        log_lines.append(f"❌ Error: {str(e)}")
+        audit_state.set_running(False)
+        if run_id:
+            completed = get_completed_count(sb, run_id)
+            update_run_status(sb, run_id, "paused", completed)
+        yield "\n".join(log_lines[-40:]), f"❌ Error — saved progress to Supabase", gr.update(interactive=False), gr.update(interactive=False)
+
+
+def pause_audit():
+    """Signal the audit loop to pause."""
+    if audit_state.is_running():
+        audit_state.request_pause()
+        return "⏸️ Pause requested — will stop after current page completes..."
+    return "No audit running."
+
+
+# ═══════════════════════════════════════════════════
+#  RESUME FUNCTION
+# ═══════════════════════════════════════════════════
+
+def resume_audit(run_id, domain, batch_size, timeout, delay, workers):
+    """Resume a paused/interrupted run."""
+    if sb is None:
+        yield "❌ Supabase not connected.", "", gr.update(), gr.update()
+        return
+
+    if not run_id:
+        yield "⚠ No run selected.", "", gr.update(), gr.update()
+        return
+
+    all_urls_for_run = get_pending_urls(sb, run_id)
+    done_urls = get_completed_urls(sb, run_id)
+    remaining = [u for u in all_urls_for_run if u not in done_urls]
+
+    if not remaining:
+        update_run_status(sb, run_id, "completed", len(done_urls))
+        yield "✅ All pages already audited!", "", gr.update(), gr.update()
+        return
+
+    audit_state.set_running(True, run_id)
+    audit_state.resume()
+    update_run_status(sb, run_id, "running")
+
+    total = len(all_urls_for_run)
+    start_time = time.time()
+    batch_num = 0
+    log_lines = [f"▶️ Resuming — {len(remaining)} pages remaining ({len(done_urls)} already done)"]
+
+    yield "\n".join(log_lines), f"📊 Resuming: {len(done_urls)}/{total}", gr.update(interactive=True), gr.update(interactive=False)
+
+    try:
+        for batch_start in range(0, len(remaining), batch_size):
+            if audit_state.is_paused():
+                completed = get_completed_count(sb, run_id)
+                update_run_status(sb, run_id, "paused", completed)
+                log_lines.append(f"⏸️ PAUSED at {completed}/{total}")
+                audit_state.set_running(False)
+                yield "\n".join(log_lines[-40:]), "", gr.update(interactive=False), gr.update(interactive=False)
+                return
+
+            batch_end = min(batch_start + batch_size, len(remaining))
+            batch_urls = remaining[batch_start:batch_end]
+            batch_num += 1
+            batch_results = []
+
+            for j, url in enumerate(batch_urls):
+                if audit_state.is_paused():
+                    if batch_results:
+                        save_batch_results(sb, run_id, batch_results)
+                    completed = get_completed_count(sb, run_id)
+                    update_run_status(sb, run_id, "paused", completed)
+                    log_lines.append(f"⏸️ PAUSED at {completed}/{total}")
+                    audit_state.set_running(False)
+                    yield "\n".join(log_lines[-40:]), "", gr.update(interactive=False), gr.update(interactive=False)
+                    return
+
+                global_idx = len(done_urls) + batch_start + j + 1
+                elapsed = time.time() - start_time
+                processed = batch_start + j + 1
+                avg = elapsed / processed
+                eta = avg * (len(remaining) - processed)
+                eta_str = f"{int(eta//60)}m {int(eta%60)}s" if eta > 60 else f"{eta:.0f}s"
+
+                result = audit_page(
+                    url, domain, DEFAULT_BODY_SELECTORS,
+                    suggestion_map=DEFAULT_SUGGESTION_MAP,
+                    timeout=timeout, concurrent_workers=workers,
+                )
+                batch_results.append(result)
+
+                short = url.replace('https://www.', '').replace('https://', '')[:70]
+                if result['error']:
+                    log_lines.append(f"❌ [{global_idx}/{total}] {short}")
+                else:
+                    b = result['broken_int_count'] + result['broken_ext_count']
+                    flag_str = f"🔴 {b} broken" if b else "✅"
+                    log_lines.append(f"[{global_idx}/{total}] {short} · {flag_str}")
+
+                yield "\n".join(log_lines[-40:]), f"📊 Progress: {global_idx}/{total} ({global_idx*100//total}%) · ETA: {eta_str}", gr.update(interactive=True), gr.update(interactive=False)
+                if j < len(batch_urls) - 1:
+                    time.sleep(delay)
+
+            if batch_results:
+                save_batch_results(sb, run_id, batch_results)
+                completed = get_completed_count(sb, run_id)
+                update_run_status(sb, run_id, "running", completed)
+                log_lines.append(f"💾 Batch {batch_num} saved — {completed}/{total}")
+                del batch_results
+
+        # Orphan analysis
+        log_lines.append("🔍 Orphan analysis...")
+        yield "\n".join(log_lines[-40:]), "📊 Orphan analysis...", gr.update(interactive=False), gr.update(interactive=False)
+
+        all_pages = get_all_page_results(sb, run_id)
+        all_results = [p['result'] for p in all_pages]
+
+        all_targets = set()
+        all_pg = set()
+        for r in all_results:
+            all_pg.add(r['url'].rstrip('/').split('?')[0])
+            for link in r.get('internal_links', []):
+                all_targets.add(link['url'].rstrip('/').split('?')[0])
+        orphans = sorted([p for p in all_pg if p not in all_targets])
+
+        final_summary = {
+            'total_pages': len(all_results),
+            'total_int': sum(r.get('int_count', 0) for r in all_results),
+            'total_ext': sum(r.get('ext_count', 0) for r in all_results),
+            'total_broken': sum(r.get('broken_int_count', 0) + r.get('broken_ext_count', 0) for r in all_results),
+            'total_redirects': sum(r.get('redirect_int_count', 0) + r.get('redirect_ext_count', 0) for r in all_results),
+            'total_flags': sum(r.get('follow_flag_count', 0) for r in all_results),
+            'total_dups': sum(r.get('duplicate_count', 0) for r in all_results),
+            'total_sug': sum(len(r.get('suggestions', [])) for r in all_results),
+            'orphan_count': len(orphans),
+            'orphan_urls': orphans[:100],
+        }
+        update_run_status(sb, run_id, "completed", len(all_results), final_summary)
+
+        total_time = time.time() - start_time
+        log_lines.append(f"✅ COMPLETE! {len(all_results)} pages in {total_time:.0f}s · {len(orphans)} orphans")
+        audit_state.set_running(False)
+        yield "\n".join(log_lines[-40:]), f"✅ Complete — {len(all_results)} pages", gr.update(interactive=False), gr.update(interactive=False)
+
+    except Exception as e:
+        log_lines.append(f"❌ Error: {str(e)}")
+        audit_state.set_running(False)
+        completed = get_completed_count(sb, run_id)
+        update_run_status(sb, run_id, "paused", completed)
+        yield "\n".join(log_lines[-40:]), "❌ Error", gr.update(interactive=False), gr.update(interactive=False)
+
+
+# ═══════════════════════════════════════════════════
+#  PAST RUNS HELPERS
+# ═══════════════════════════════════════════════════
+
+def load_past_runs():
+    if sb is None:
+        return "<p>❌ Supabase not connected</p>", gr.update(choices=[], value=None)
+
+    runs = get_all_runs(sb)
+    if not runs:
+        return "<p>No saved runs yet.</p>", gr.update(choices=[], value=None)
+
+    # Build choices for dropdown
+    choices = []
+    for r in runs:
+        status = r.get('status', 'unknown')
+        completed = r.get('completed_urls', 0)
+        total = r.get('total_urls', 0)
+        label = f"{r.get('name', 'Untitled')} [{status.upper()}] ({completed}/{total})"
+        choices.append((label, r['id']))
+
+    # Build HTML table
+    html = '<div style="max-height:400px;overflow-y:auto;">'
+    html += '<table style="width:100%;border-collapse:collapse;font-size:13px;">'
+    html += '<tr style="background:#f1f5f9;"><th style="padding:10px;text-align:left;">Run Name</th><th style="padding:10px;text-align:center;">Status</th><th style="padding:10px;text-align:center;">Pages</th><th style="padding:10px;text-align:center;">Broken</th><th style="padding:10px;text-align:center;">Flags</th><th style="padding:10px;text-align:center;">Dups</th><th style="padding:10px;text-align:center;">Orphans</th></tr>'
+
+    for r in runs:
+        summary = r.get('summary', {}) or {}
+        status = r.get('status', 'unknown')
+        s_color = {'completed': '#059669', 'paused': '#d97706', 'running': '#2563eb'}.get(status, '#888')
+        created = r.get('created_at', '')[:16].replace('T', ' ')
+
+        html += f'''<tr style="border-bottom:1px solid #e2e8f0;">
+            <td style="padding:10px;"><b>{r.get('name','Untitled')}</b><br><span style="font-size:11px;color:#94a3b8;">{created}</span></td>
+            <td style="padding:10px;text-align:center;"><span style="background:{s_color}15;color:{s_color};padding:3px 10px;border-radius:12px;font-size:11px;font-weight:700;">{status.upper()}</span></td>
+            <td style="padding:10px;text-align:center;font-weight:700;">{r.get('completed_urls',0)}/{r.get('total_urls',0)}</td>
+            <td style="padding:10px;text-align:center;color:#dc2626;font-weight:700;">{summary.get('total_broken','—')}</td>
+            <td style="padding:10px;text-align:center;color:#dc2626;font-weight:700;">{summary.get('total_flags','—')}</td>
+            <td style="padding:10px;text-align:center;color:#db2777;font-weight:700;">{summary.get('total_dups','—')}</td>
+            <td style="padding:10px;text-align:center;color:#dc2626;font-weight:700;">{summary.get('orphan_count','—')}</td>
+        </tr>'''
+
+    html += '</table></div>'
+    return html, gr.update(choices=choices, value=choices[0][1] if choices else None)
+
+
+def generate_report_for_run(run_id, domain):
+    if sb is None or not run_id:
+        return None, "❌ No run selected or Supabase not connected."
+
+    try:
+        run = None
+        runs = get_all_runs(sb)
+        for r in runs:
+            if r['id'] == run_id:
+                run = r
+                break
+
+        pages = get_all_page_results(sb, run_id)
+        if not pages:
+            return None, "⚠ No page data found for this run."
+
+        results = [p['result'] for p in pages]
+        summary = (run.get('summary', {}) or {}) if run else {}
+        orphan_urls = summary.get('orphan_urls', [])
+        report_domain = run.get('domain', domain) if run else domain
+
+        report_html = generate_report(results, orphan_urls, report_domain)
+
+        # Save to temp file
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.html', prefix='Link_Audit_')
+        tmp.write(report_html.encode('utf-8'))
+        tmp.close()
+
+        return tmp.name, f"✅ Report generated — {len(results)} pages"
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+
+def generate_csv_for_run(run_id):
+    if sb is None or not run_id:
+        return None, "❌ No run selected."
+
+    try:
+        pages = get_all_page_results(sb, run_id)
+        if not pages:
+            return None, "⚠ No data."
+
+        rows = []
+        for p in pages:
+            r = p['result']
+            rows.append({
+                'URL': r.get('url', ''),
+                'Internal': r.get('int_count', 0),
+                'External': r.get('ext_count', 0),
+                'Broken': r.get('broken_int_count', 0) + r.get('broken_ext_count', 0),
+                'Redirects': r.get('redirect_int_count', 0) + r.get('redirect_ext_count', 0),
+                'Flags': r.get('follow_flag_count', 0),
+                'Duplicates': r.get('duplicate_count', 0),
+                'Error': r.get('error', ''),
+            })
+
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.csv', prefix='Audit_CSV_')
+        pd.DataFrame(rows).to_csv(tmp.name, index=False)
+        tmp.close()
+        return tmp.name, f"✅ CSV exported — {len(rows)} rows"
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+
+def delete_selected_run(run_id):
+    if sb is None or not run_id:
+        return "❌ No run selected."
+    try:
+        delete_run(sb, run_id)
+        return "🗑️ Run deleted."
+    except Exception as e:
+        return f"❌ {str(e)}"
+
+
+# ═══════════════════════════════════════════════════
+#  GRADIO UI
+# ═══════════════════════════════════════════════════
+
+css = """
+.main-header { background: linear-gradient(135deg, #1e3a5f, #2563eb); padding: 24px 28px; border-radius: 12px; color: white; margin-bottom: 16px; }
+.main-header h1 { margin: 0 0 4px 0; font-size: 24px; }
+.main-header p { margin: 0; opacity: 0.8; font-size: 13px; }
+.status-bar { background: #f1f5f9; border: 1px solid #e2e8f0; border-radius: 8px; padding: 10px 16px; font-family: monospace; font-size: 13px; font-weight: 600; }
+.log-area textarea { font-family: 'JetBrains Mono', monospace !important; font-size: 12px !important; line-height: 1.6 !important; }
+"""
+
+with gr.Blocks(css=css, title="🔗 Link Audit Tool", theme=gr.themes.Soft()) as app:
+
+    # Header
+    gr.HTML("""
+    <div class="main-header">
+        <p style="font-size:10px;font-weight:700;letter-spacing:1.5px;text-transform:uppercase;color:#93c5fd;margin-bottom:8px;">SEO Link Audit Tool</p>
+        <h1>🔗 Bulk Link Audit</h1>
+        <p>Upload URLs → batch crawl with auto-save → pause/resume anytime → generate interactive report</p>
+    </div>
+    """)
+
+    # Connection status
+    conn_status = "✅ Supabase Connected" if sb else "❌ Supabase Not Connected — add SUPABASE_URL and SUPABASE_KEY to Space secrets"
+    gr.HTML(f'<div class="status-bar">🗄️ {conn_status}</div>')
+
+    with gr.Tabs():
+
+        # ═══ TAB 1: NEW AUDIT ═══
+        with gr.Tab("🔍 New Audit"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    file_input = gr.File(label="Upload Excel / CSV", file_types=[".xlsx", ".csv", ".xls"])
+                    pasted_urls = gr.Textbox(label="Or paste URLs (one per line)", lines=5, placeholder="https://www.example.com/blog/page1\nhttps://www.example.com/blog/page2")
+
+                with gr.Column(scale=1):
+                    domain = gr.Textbox(label="Your Domain", value="edstellar.com")
+                    batch_size = gr.Slider(5, 50, value=25, step=5, label="Batch Size")
+                    timeout = gr.Slider(5, 60, value=15, step=5, label="Timeout (s)")
+                    delay = gr.Slider(0, 5, value=1.0, step=0.5, label="Delay between pages (s)")
+                    workers = gr.Slider(1, 10, value=5, step=1, label="Parallel link checks")
+
+            with gr.Row():
+                run_btn = gr.Button("🚀 Run Audit", variant="primary", scale=2)
+                pause_btn = gr.Button("⏸️ Pause", variant="stop", scale=1, interactive=False)
+
+            progress_text = gr.Textbox(label="Status", interactive=False, elem_classes=["status-bar"])
+            log_output = gr.Textbox(label="Audit Log", lines=20, interactive=False, elem_classes=["log-area"])
+
+            # Wire up run button (generator for streaming)
+            run_btn.click(
+                fn=run_audit,
+                inputs=[file_input, pasted_urls, domain, batch_size, timeout, delay, workers],
+                outputs=[log_output, progress_text, pause_btn, run_btn],
+            )
+
+            # Wire up pause button
+            pause_btn.click(fn=pause_audit, outputs=[progress_text])
+
+        # ═══ TAB 2: PAST RUNS ═══
+        with gr.Tab("📁 Past Runs"):
+            refresh_btn = gr.Button("🔄 Refresh Runs", variant="secondary")
+            runs_html = gr.HTML(value="<p>Click Refresh to load runs.</p>")
+            run_dropdown = gr.Dropdown(label="Select a Run", choices=[], interactive=True)
+
+            with gr.Row():
+                report_btn = gr.Button("📊 Generate HTML Report", variant="primary")
+                csv_btn = gr.Button("📋 Export CSV", variant="secondary")
+                resume_btn = gr.Button("▶️ Resume Audit", variant="primary")
+                delete_btn = gr.Button("🗑️ Delete Run", variant="stop")
+
+            action_status = gr.Textbox(label="Action Status", interactive=False)
+            report_file = gr.File(label="Download Report", interactive=False)
+            csv_file = gr.File(label="Download CSV", interactive=False)
+
+            # Resume log & progress (shared with new audit display format)
+            resume_progress = gr.Textbox(label="Resume Status", interactive=False, elem_classes=["status-bar"])
+            resume_log = gr.Textbox(label="Resume Log", lines=15, interactive=False, elem_classes=["log-area"])
+            resume_pause_btn = gr.Button("⏸️ Pause Resume", variant="stop", interactive=False)
+
+            # Refresh
+            refresh_btn.click(fn=load_past_runs, outputs=[runs_html, run_dropdown])
+
+            # Generate report
+            def gen_report_wrapper(run_id, domain_val):
+                filepath, msg = generate_report_for_run(run_id, domain_val)
+                return filepath, msg
+
+            report_btn.click(
+                fn=gen_report_wrapper,
+                inputs=[run_dropdown, domain],
+                outputs=[report_file, action_status],
+            )
+
+            # CSV
+            def csv_wrapper(run_id):
+                filepath, msg = generate_csv_for_run(run_id)
+                return filepath, msg
+
+            csv_btn.click(fn=csv_wrapper, inputs=[run_dropdown], outputs=[csv_file, action_status])
+
+            # Delete
+            def delete_wrapper(run_id):
+                msg = delete_selected_run(run_id)
+                html, dropdown = load_past_runs()
+                return msg, html, dropdown
+
+            delete_btn.click(fn=delete_wrapper, inputs=[run_dropdown], outputs=[action_status, runs_html, run_dropdown])
+
+            # Resume
+            resume_btn.click(
+                fn=resume_audit,
+                inputs=[run_dropdown, domain, batch_size, timeout, delay, workers],
+                outputs=[resume_log, resume_progress, resume_pause_btn, resume_btn],
+            )
+            resume_pause_btn.click(fn=pause_audit, outputs=[resume_progress])
+
+    # Auto-load runs on startup
+    app.load(fn=load_past_runs, outputs=[runs_html, run_dropdown])
+
+
+if __name__ == "__main__":
+    app.queue().launch(server_name="0.0.0.0", server_port=7860)

audit_engine.py

@@ -0,0 +1,312 @@
+"""
+Core Link Audit Engine
+Crawls pages, extracts body-content links, checks status, detects issues.
+"""
+
+import requests
+from bs4 import BeautifulSoup, Comment
+from urllib.parse import urljoin, urlparse
+from collections import defaultdict
+import concurrent.futures
+
+HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+}
+
+DEFAULT_BODY_SELECTORS = [
+    "div.blog-rich-text",
+    "div.w-richtext",
+    "article .rich-text",
+    "article",
+    "div.blog-content",
+    "div.post-content",
+    "main",
+]
+
+DEFAULT_SUGGESTION_MAP = {
+    "artificial intelligence": ("/category/artificial-intelligence-training", "artificial intelligence training programs"),
+    "machine learning": ("/category/artificial-intelligence-training", "machine learning training"),
+    "leadership": ("/type/leadership-training", "leadership training programs"),
+    "soft skills": ("/type/behavioral-training", "behavioral training programs"),
+    "remote employee": ("/blog/how-to-train-remote-employees", "remote employee training"),
+    "training management": ("/training-management-software", "training management software"),
+    "instructor-led": ("/instructor-led-training-services", "instructor-led training"),
+    "corporate training": ("/corporate-training-courses", "corporate training programs"),
+    "skill matrix": ("/skill-matrix", "skills matrix"),
+    "stellar ai": ("/stellar-ai", "AI-powered training"),
+    "book a demo": ("/book-a-demo", "book a demo"),
+    "compliance": ("/type/compliance-training", "compliance training"),
+    "cybersecurity": ("/category/cybersecurity-training", "cybersecurity training"),
+    "data analytics": ("/category/data-analytics-training", "data analytics training"),
+    "project management": ("/category/project-management-training", "project management training"),
+    "coaching": ("/coaching-solutions", "coaching solutions"),
+    "hr training": ("/category/human-resource-training", "HR training programs"),
+    "employee engagement": ("/blog/how-to-train-remote-employees", "employee training best practices"),
+    "onboarding": ("/category/human-resource-training", "onboarding training"),
+    "digital transformation": ("/type/it-technical-training", "IT & technical training"),
+}
+
+
+def is_internal(href, domain):
+    if not href:
+        return False
+    parsed = urlparse(href)
+    if not parsed.netloc:
+        return True
+    return domain.lower() in parsed.netloc.lower()
+
+
+def normalize_url(href, base_url):
+    if not href:
+        return None
+    href = href.strip()
+    if href.startswith(('#', 'mailto:', 'tel:', 'javascript:')):
+        return None
+    return urljoin(base_url, href)
+
+
+def get_follow_status(tag):
+    rel = tag.get('rel', [])
+    if isinstance(rel, str):
+        rel = rel.split()
+    return 'Nofollow' if 'nofollow' in [r.lower() for r in rel] else 'Dofollow'
+
+
+def find_body_content(soup, selectors):
+    for sel in selectors:
+        el = soup.select_one(sel)
+        if el:
+            return el
+    return soup.find('body')
+
+
+def get_link_location(link_tag, body_el):
+    body_text = body_el.get_text()
+    total_len = len(body_text)
+    if total_len == 0:
+        return "Unknown"
+
+    preceding_text = ""
+    for el in body_el.descendants:
+        if el == link_tag:
+            break
+        if isinstance(el, str) and not isinstance(el, Comment):
+            preceding_text += el
+
+    pos = len(preceding_text)
+    ratio = pos / total_len if total_len > 0 else 0
+
+    heading = ""
+    for parent in link_tag.parents:
+        for sib in parent.previous_siblings:
+            if hasattr(sib, 'name') and sib.name in ['h1', 'h2', 'h3', 'h4']:
+                heading = sib.get_text(strip=True)[:60]
+                break
+        if heading:
+            break
+
+    if ratio < 0.1:
+        section = "Intro"
+    elif ratio > 0.85:
+        section = "Conclusion"
+    else:
+        section = f"Mid-article (~{int(ratio*100)}%)"
+
+    if heading:
+        return f'{section} · near "{heading}"'
+    return section
+
+
+def check_url_status(url, timeout=15):
+    try:
+        r = requests.head(url, headers=HEADERS, timeout=timeout, allow_redirects=False)
+        status = r.status_code
+        redirect_url = ""
+
+        if status in (301, 302, 303, 307, 308):
+            redirect_url = r.headers.get('Location', '')
+            if redirect_url and not redirect_url.startswith('http'):
+                redirect_url = urljoin(url, redirect_url)
+
+        if status == 405:
+            r = requests.get(url, headers=HEADERS, timeout=timeout, allow_redirects=False, stream=True)
+            status = r.status_code
+            if status in (301, 302, 303, 307, 308):
+                redirect_url = r.headers.get('Location', '')
+            r.close()
+
+        if status in (301, 302, 303, 307, 308):
+            link_status = "Redirect"
+        elif 200 <= status < 300:
+            link_status = "Active"
+        else:
+            link_status = "Broken"
+
+        return url, status, link_status, redirect_url
+
+    except requests.exceptions.Timeout:
+        return url, "Timeout", "Broken", ""
+    except requests.exceptions.ConnectionError:
+        return url, "ConnError", "Broken", ""
+    except Exception:
+        return url, "Error", "Broken", ""
+
+
+def generate_suggestions(body_text, existing_internal_urls, page_url, suggestion_map=None):
+    if suggestion_map is None:
+        suggestion_map = DEFAULT_SUGGESTION_MAP
+
+    suggestions = []
+    text_lower = body_text.lower()
+    existing_paths = set(urlparse(u).path.rstrip('/') for u in existing_internal_urls)
+
+    for keyword, (path, anchor) in suggestion_map.items():
+        clean_path = path.rstrip('/')
+        if clean_path in existing_paths:
+            continue
+        if clean_path == urlparse(page_url).path.rstrip('/'):
+            continue
+        count = text_lower.count(keyword.lower())
+        if count > 0:
+            pos = text_lower.find(keyword.lower())
+            ratio = pos / len(text_lower) if len(text_lower) > 0 else 0
+            if ratio < 0.15:
+                loc = "Intro"
+            elif ratio > 0.85:
+                loc = "Conclusion"
+            else:
+                loc = f"Mid-article (~{int(ratio*100)}%)"
+
+            priority = "High" if count >= 3 else "Med"
+            suggestions.append({
+                'section': loc,
+                'target': path,
+                'anchor': anchor,
+                'priority': priority,
+                'keyword': keyword,
+                'count': count
+            })
+
+    suggestions.sort(key=lambda x: (0 if x['priority'] == 'High' else 1, -x['count']))
+    return suggestions[:10]
+
+
+def audit_page(page_url, domain, body_selectors=None, suggestion_map=None,
+               timeout=15, concurrent_workers=5):
+    if body_selectors is None:
+        body_selectors = DEFAULT_BODY_SELECTORS
+
+    result = {
+        'url': page_url, 'error': None,
+        'internal_links': [], 'external_links': [],
+        'broken_internal': [], 'broken_external': [],
+        'redirect_internal': [], 'redirect_external': [],
+        'follow_flags': [], 'duplicates': [], 'suggestions': [],
+        'int_count': 0, 'ext_count': 0,
+        'int_df': 0, 'int_nf': 0, 'ext_df': 0, 'ext_nf': 0,
+        'broken_int_count': 0, 'broken_ext_count': 0,
+        'redirect_int_count': 0, 'redirect_ext_count': 0,
+        'follow_flag_count': 0, 'duplicate_count': 0,
+    }
+
+    try:
+        resp = requests.get(page_url, headers=HEADERS, timeout=timeout)
+        resp.raise_for_status()
+    except Exception as e:
+        result['error'] = str(e)
+        return result
+
+    soup = BeautifulSoup(resp.text, 'lxml')
+    body_el = find_body_content(soup, body_selectors)
+    if not body_el:
+        result['error'] = "Could not find body content element"
+        return result
+
+    body_text = body_el.get_text(' ', strip=True)
+    all_links = body_el.find_all('a', href=True)
+    url_locations = defaultdict(list)
+
+    raw_links = []
+    for tag in all_links:
+        href = normalize_url(tag['href'], page_url)
+        if not href:
+            continue
+        anchor = tag.get_text(strip=True) or "[no text]"
+        follow = get_follow_status(tag)
+        location = get_link_location(tag, body_el)
+        internal = is_internal(href, domain)
+        link_type = 'internal' if internal else 'external'
+
+        link_data = {
+            'url': href, 'anchor': anchor[:100], 'follow': follow,
+            'location': location, 'type': link_type,
+            'status_code': None, 'link_status': None,
+            'redirect_url': '', 'flags': [],
+        }
+        raw_links.append(link_data)
+        clean_url = href.rstrip('/').split('?')[0].split('#')[0]
+        url_locations[clean_url].append(location)
+
+    # Check status in parallel
+    unique_urls = list(set(l['url'] for l in raw_links))
+    status_map = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=concurrent_workers) as executor:
+        futures = {executor.submit(check_url_status, u, timeout): u for u in unique_urls}
+        for future in concurrent.futures.as_completed(futures):
+            url, status, link_status, redirect_url = future.result()
+            status_map[url] = (status, link_status, redirect_url)
+
+    for link in raw_links:
+        if link['url'] in status_map:
+            status, link_status, redirect_url = status_map[link['url']]
+            link['status_code'] = status
+            link['link_status'] = link_status
+            link['redirect_url'] = redirect_url
+
+        if link['type'] == 'internal' and link['follow'] == 'Nofollow':
+            link['flags'].append('Internal link is Nofollow — should be Dofollow')
+        if link['type'] == 'external' and link['follow'] == 'Dofollow':
+            link['flags'].append('External link is Dofollow — should be Nofollow')
+
+    # Detect duplicates
+    duplicates = []
+    for clean_url, locations in url_locations.items():
+        if len(locations) > 1:
+            duplicates.append({'url': clean_url, 'count': len(locations), 'locations': locations})
+            for link in raw_links:
+                link_clean = link['url'].rstrip('/').split('?')[0].split('#')[0]
+                if link_clean == clean_url:
+                    link['flags'].append(f'Duplicate: appears {len(locations)}x in body')
+
+    for link in raw_links:
+        if link['type'] == 'internal':
+            result['internal_links'].append(link)
+            if link['follow'] == 'Dofollow': result['int_df'] += 1
+            else: result['int_nf'] += 1
+            if link['link_status'] == 'Broken': result['broken_internal'].append(link)
+            if link['link_status'] == 'Redirect': result['redirect_internal'].append(link)
+        else:
+            result['external_links'].append(link)
+            if link['follow'] == 'Dofollow': result['ext_df'] += 1
+            else: result['ext_nf'] += 1
+            if link['link_status'] == 'Broken': result['broken_external'].append(link)
+            if link['link_status'] == 'Redirect': result['redirect_external'].append(link)
+
+        if link['flags']:
+            result['follow_flags'].append(link)
+
+    result['int_count'] = len(result['internal_links'])
+    result['ext_count'] = len(result['external_links'])
+    result['broken_int_count'] = len(result['broken_internal'])
+    result['broken_ext_count'] = len(result['broken_external'])
+    result['redirect_int_count'] = len(result['redirect_internal'])
+    result['redirect_ext_count'] = len(result['redirect_external'])
+    result['follow_flag_count'] = len(result['follow_flags'])
+    result['duplicates'] = duplicates
+    result['duplicate_count'] = len(duplicates)
+
+    existing_int_urls = [l['url'] for l in result['internal_links']]
+    result['suggestions'] = generate_suggestions(body_text, existing_int_urls, page_url, suggestion_map)
+
+    return result

db.py

@@ -0,0 +1,161 @@
+"""
+Supabase Database Helper
+Saves/loads audit results in batches.
+
+═══════════════════════════════════════════════════════════════
+  RUN THIS SQL IN SUPABASE SQL EDITOR (one-time setup):
+═══════════════════════════════════════════════════════════════
+
+CREATE TABLE audit_runs (
+    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    name TEXT NOT NULL,
+    domain TEXT NOT NULL,
+    total_urls INTEGER DEFAULT 0,
+    completed_urls INTEGER DEFAULT 0,
+    status TEXT DEFAULT 'running' CHECK (status IN ('running', 'paused', 'completed', 'error')),
+    created_at TIMESTAMPTZ DEFAULT now(),
+    updated_at TIMESTAMPTZ DEFAULT now(),
+    summary JSONB DEFAULT '{}'::jsonb,
+    pending_urls JSONB DEFAULT '[]'::jsonb
+);
+
+CREATE TABLE audit_pages (
+    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    run_id UUID REFERENCES audit_runs(id) ON DELETE CASCADE,
+    url TEXT NOT NULL,
+    result JSONB NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE INDEX idx_audit_pages_run_id ON audit_pages(run_id);
+CREATE INDEX idx_audit_pages_url ON audit_pages(url);
+CREATE INDEX idx_audit_runs_status ON audit_runs(status);
+
+ALTER TABLE audit_runs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE audit_pages ENABLE ROW LEVEL SECURITY;
+CREATE POLICY "Allow all on audit_runs" ON audit_runs FOR ALL USING (true);
+CREATE POLICY "Allow all on audit_pages" ON audit_pages FOR ALL USING (true);
+
+═══════════════════════════════════════════════════════════════
+"""
+
+import json
+from datetime import datetime
+from supabase import create_client, Client
+
+
+def get_client(url: str, key: str) -> Client:
+    return create_client(url, key)
+
+
+# ─── Run Management ───
+
+def create_run(client: Client, name: str, domain: str, total_urls: int, all_urls: list) -> str:
+    data = {
+        "name": name,
+        "domain": domain,
+        "total_urls": total_urls,
+        "completed_urls": 0,
+        "status": "running",
+        "pending_urls": json.dumps(all_urls),
+    }
+    response = client.table("audit_runs").insert(data).execute()
+    return response.data[0]["id"]
+
+
+def get_run(client: Client, run_id: str):
+    response = client.table("audit_runs").select("*").eq("id", run_id).single().execute()
+    return response.data
+
+
+def get_all_runs(client: Client):
+    response = client.table("audit_runs").select("*").order("created_at", desc=True).execute()
+    return response.data
+
+
+def update_run_status(client: Client, run_id: str, status: str, completed: int = None, summary: dict = None):
+    data = {"status": status, "updated_at": datetime.utcnow().isoformat()}
+    if completed is not None:
+        data["completed_urls"] = completed
+    if summary is not None:
+        data["summary"] = json.loads(json.dumps(summary, default=str))
+    client.table("audit_runs").update(data).eq("id", run_id).execute()
+
+
+def delete_run(client: Client, run_id: str):
+    client.table("audit_pages").delete().eq("run_id", run_id).execute()
+    client.table("audit_runs").delete().eq("id", run_id).execute()
+
+
+# ─── Page Results ───
+
+def save_batch_results(client: Client, run_id: str, batch_results: list):
+    rows = []
+    for r in batch_results:
+        clean = json.loads(json.dumps(r, default=str))
+        rows.append({"run_id": run_id, "url": r['url'], "result": clean})
+
+    for i in range(0, len(rows), 50):
+        chunk = rows[i:i+50]
+        client.table("audit_pages").insert(chunk).execute()
+
+
+def get_completed_urls(client: Client, run_id: str) -> set:
+    urls = set()
+    offset = 0
+    page_size = 1000
+    while True:
+        response = (
+            client.table("audit_pages")
+            .select("url")
+            .eq("run_id", run_id)
+            .range(offset, offset + page_size - 1)
+            .execute()
+        )
+        if not response.data:
+            break
+        urls.update(p["url"] for p in response.data)
+        if len(response.data) < page_size:
+            break
+        offset += page_size
+    return urls
+
+
+def get_completed_count(client: Client, run_id: str) -> int:
+    response = (
+        client.table("audit_pages")
+        .select("id", count="exact")
+        .eq("run_id", run_id)
+        .execute()
+    )
+    return response.count or 0
+
+
+def get_all_page_results(client: Client, run_id: str) -> list:
+    all_pages = []
+    offset = 0
+    page_size = 500
+    while True:
+        response = (
+            client.table("audit_pages")
+            .select("url, result")
+            .eq("run_id", run_id)
+            .order("created_at", desc=False)
+            .range(offset, offset + page_size - 1)
+            .execute()
+        )
+        if not response.data:
+            break
+        all_pages.extend(response.data)
+        if len(response.data) < page_size:
+            break
+        offset += page_size
+    return all_pages
+
+
+def get_pending_urls(client: Client, run_id: str) -> list:
+    run = get_run(client, run_id)
+    pending = run.get("pending_urls")
+    if isinstance(pending, str):
+        return json.loads(pending)
+    return pending or []

report_generator.py

@@ -0,0 +1,268 @@
+"""
+HTML Report Generator
+Produces the interactive accordion-based light-theme audit report.
+"""
+
+import html as html_module
+from urllib.parse import urlparse
+from datetime import datetime
+
+
+def esc(text):
+    return html_module.escape(str(text)) if text else ""
+
+
+def short_url(url, domain="edstellar.com"):
+    parsed = urlparse(str(url))
+    if domain in parsed.netloc:
+        return parsed.path + (('?' + parsed.query) if parsed.query else '')
+    host = parsed.netloc.replace('www.', '')
+    path = parsed.path
+    if len(path) > 50:
+        path = path[:25] + '...' + path[-20:]
+    return f"{host}{path}"
+
+
+def badge(text, cls):
+    return f'<span class="badge {cls}">{esc(text)}</span>'
+
+
+def render_link_entry(link, domain="edstellar.com", show_flags=True):
+    has_issues = link['link_status'] in ('Broken',) or link.get('flags')
+    is_redirect = link['link_status'] == 'Redirect'
+    cls = 's-issue' if (has_issues or is_redirect) else 's-ok'
+
+    if link['link_status'] == 'Broken':
+        status_tag = f'<span class="tag-sm issue">{esc(link["status_code"])} BROKEN</span>'
+    elif link['link_status'] == 'Redirect':
+        status_tag = f'<span class="tag-sm issue">{esc(link["status_code"])} Redirect</span>'
+    else:
+        status_tag = f'<span class="tag-sm ok">{esc(link["status_code"])}</span>'
+
+    has_follow_flag = any('Dofollow' in f or 'Nofollow' in f for f in link.get('flags', []))
+    if has_follow_flag:
+        follow_tag = f'<span class="tag-sm issue">{link["follow"]} ⚠</span>'
+    else:
+        follow_tag = f'<span class="tag-sm ok">{link["follow"]} ✓</span>'
+
+    out = f'<div class="le {cls}">'
+    out += f'<div class="le-url">{esc(short_url(link["url"], domain))}</div>'
+    out += f'<div class="le-tags">{status_tag}{follow_tag}</div>'
+    out += f'<div class="le-anchor">Anchor: <b>{esc(link["anchor"])}</b></div>'
+
+    if link.get('redirect_url'):
+        out += f'<div class="le-redir">→ {esc(short_url(link["redirect_url"], domain))}</div>'
+
+    out += f'<div class="le-location">📍 {esc(link["location"])}</div>'
+
+    if show_flags:
+        for flag in link.get('flags', []):
+            out += f'<div class="le-issue">⚠ {esc(flag)}</div>'
+
+    out += '</div>'
+    return out
+
+
+def render_accordion(collapsed_html, details_html):
+    return f'''<td class="acc-cell" onclick="toggleAcc(this)">
+    <div class="acc-collapsed"><div class="acc-chevron">▶</div><div class="acc-summary">{collapsed_html}</div></div>
+    <div class="acc-details">{details_html}</div>
+  </td>'''
+
+
+def generate_report(results, orphan_pages, domain="edstellar.com"):
+    now = datetime.now().strftime("%b %d, %Y %H:%M")
+    total_pages = len(results)
+    total_int = sum(r['int_count'] for r in results)
+    total_ext = sum(r['ext_count'] for r in results)
+    total_broken = sum(r['broken_int_count'] + r['broken_ext_count'] for r in results)
+    total_redirects = sum(r['redirect_int_count'] + r['redirect_ext_count'] for r in results)
+    total_flags = sum(r['follow_flag_count'] for r in results)
+    total_dups = sum(r['duplicate_count'] for r in results)
+    total_sug = sum(len(r['suggestions']) for r in results)
+    total_orphan = len(orphan_pages)
+
+    rows_html = ""
+    for idx, r in enumerate(results, 1):
+        if r['error']:
+            rows_html += f'''<tr><td class="cell-url"><div class="row-num">#{idx}</div>{esc(short_url(r["url"], domain))}</td>
+            <td colspan="15" style="color:var(--red);vertical-align:middle;">❌ Error: {esc(r["error"])}</td></tr>'''
+            continue
+
+        is_orphan = r['url'].rstrip('/').split('?')[0] in orphan_pages
+
+        # Internal Links
+        int_badges = ""
+        if r['int_count'] == 0:
+            int_badges = badge('0 Links ⚠', 'issue')
+        else:
+            ok_count = r['int_count'] - r['broken_int_count'] - r['redirect_int_count']
+            if ok_count > 0: int_badges += badge(f'{ok_count} Active', 'ok')
+            if r['broken_int_count'] > 0: int_badges += badge(f'{r["broken_int_count"]} Broken', 'issue')
+            if r['redirect_int_count'] > 0: int_badges += badge(f'{r["redirect_int_count"]} Redirect', 'issue')
+        int_details = "".join(render_link_entry(l, domain) for l in r['internal_links'])
+        if not int_details:
+            int_details = '<div style="font-size:11px;color:var(--red);">No internal links found in body content.</div>'
+
+        # External Links
+        ext_badges = ""
+        if r['ext_count'] == 0:
+            ext_badges = badge('0 Links', 'neutral')
+        else:
+            if r['broken_ext_count'] > 0: ext_badges += badge(f'{r["broken_ext_count"]} Broken', 'issue')
+            if r['redirect_ext_count'] > 0: ext_badges += badge(f'{r["redirect_ext_count"]} Redirect', 'issue')
+            ext_df_count = sum(1 for l in r['external_links'] if l['follow'] == 'Dofollow')
+            if ext_df_count > 0: ext_badges += badge(f'{ext_df_count} Dofollow ⚠', 'issue')
+            ok_ext = r['ext_count'] - r['broken_ext_count'] - r['redirect_ext_count']
+            if ok_ext > 0 and not r['broken_ext_count'] and not r['redirect_ext_count'] and not ext_df_count:
+                ext_badges += badge(f'{ok_ext} Active', 'ok')
+        ext_details = "".join(render_link_entry(l, domain) for l in r['external_links'])
+        if not ext_details:
+            ext_details = '<div style="font-size:11px;color:var(--text-dim);">No external links in body content.</div>'
+
+        # Follow Flags
+        int_nf_flags = [l for l in r['internal_links'] if l['follow'] == 'Nofollow']
+        ext_df_flags_list = [l for l in r['external_links'] if l['follow'] == 'Dofollow']
+        flag_badges = ""
+        if int_nf_flags: flag_badges += badge(f'{len(int_nf_flags)} Int. Nofollow ⚠', 'issue')
+        if ext_df_flags_list: flag_badges += badge(f'{len(ext_df_flags_list)} Ext. Dofollow ⚠', 'issue')
+        if not flag_badges: flag_badges = badge('✓ No Flags', 'ok')
+        flag_details = "".join(render_link_entry(l, domain, show_flags=True) for l in int_nf_flags + ext_df_flags_list)
+        if not flag_details:
+            flag_details = '<div style="font-size:11px;color:var(--green);">All internal=Dofollow ✓ and external=Nofollow ✓</div>'
+
+        # Broken / Redirect
+        bi_badges = badge(f'{r["broken_int_count"]} Broken', 'issue') if r['broken_int_count'] > 0 else badge('✓ None', 'ok')
+        bi_details = "".join(render_link_entry(l, domain) for l in r['broken_internal']) or '<div style="font-size:11px;color:var(--green);">No broken internal links.</div>'
+
+        be_badges = badge(f'{r["broken_ext_count"]} Broken', 'issue') if r['broken_ext_count'] > 0 else badge('✓ None', 'ok')
+        be_details = "".join(render_link_entry(l, domain) for l in r['broken_external']) or '<div style="font-size:11px;color:var(--green);">No broken external links.</div>'
+
+        ri_badges = badge(f'{r["redirect_int_count"]} Redirects', 'issue') if r['redirect_int_count'] > 0 else badge('✓ None', 'ok')
+        ri_details = "".join(render_link_entry(l, domain) for l in r['redirect_internal']) or '<div style="font-size:11px;color:var(--green);">No internal redirects.</div>'
+
+        re_badges = badge(f'{r["redirect_ext_count"]} Redirects', 'issue') if r['redirect_ext_count'] > 0 else badge('✓ None', 'ok')
+        re_details = "".join(render_link_entry(l, domain) for l in r['redirect_external']) or '<div style="font-size:11px;color:var(--green);">No external redirects.</div>'
+
+        # Duplicates
+        dup_badges = badge(f'{r["duplicate_count"]} Duplicates', 'issue') if r['duplicate_count'] > 0 else badge('✓ None', 'ok')
+        dup_details = ""
+        for d in r['duplicates']:
+            locs = ", ".join(esc(l) for l in d['locations'])
+            dup_details += f'<div class="le s-issue"><div class="le-url">{esc(short_url(d["url"], domain))}</div>'
+            dup_details += f'<div class="le-issue">⚠ Appears {d["count"]}x in body content</div>'
+            dup_details += f'<div class="le-location">📍 Locations: {locs}</div></div>'
+        if not dup_details:
+            dup_details = '<div style="font-size:11px;color:var(--green);">No duplicate links in body content.</div>'
+
+        # Suggestions
+        sug_list = r['suggestions']
+        high_count = sum(1 for s in sug_list if s['priority'] == 'High')
+        sug_badges = ""
+        if sug_list:
+            sug_badges = badge(f'{len(sug_list)} Suggestions', 'sug')
+            if high_count: sug_badges += badge(f'{high_count} High', 'issue')
+        else:
+            sug_badges = badge('0', 'neutral')
+        sug_details = ""
+        for s in sug_list:
+            pri_cls = 'high' if s['priority'] == 'High' else 'med'
+            sug_details += f'''<div class="se"><div class="se-head"><span class="se-section">{esc(s["section"])}</span>
+            <span class="se-pri {pri_cls}">{s["priority"]}</span></div>
+            <div class="se-url">{esc(s["target"])}</div>
+            <div class="se-anchor">→ "{esc(s["anchor"])}"</div></div>'''
+        if not sug_details:
+            sug_details = '<div style="font-size:11px;color:var(--text-dim);">No keyword matches for suggestions.</div>'
+
+        # Notes
+        issues = []
+        if r['int_count'] < 3:
+            issues.append(f"Only {r['int_count']} internal links — very low for article length")
+        if r['broken_int_count'] + r['broken_ext_count'] > 0:
+            issues.append(f"{r['broken_int_count']+r['broken_ext_count']} broken link(s) need fixing")
+        if ext_df_flags_list:
+            issues.append(f"{len(ext_df_flags_list)} external links are Dofollow — add nofollow")
+        if int_nf_flags:
+            issues.append(f"{len(int_nf_flags)} internal links are Nofollow — should be Dofollow")
+        if r['redirect_int_count'] + r['redirect_ext_count'] > 0:
+            issues.append(f"{r['redirect_int_count']+r['redirect_ext_count']} redirect(s) — update href")
+        if r['duplicate_count'] > 0:
+            issues.append(f"{r['duplicate_count']} duplicate link(s) in body")
+        if is_orphan:
+            issues.append("ORPHAN PAGE — no incoming internal links from other pages")
+
+        note_badges = badge(f'{len(issues)} Issues', 'issue') if issues else badge('✓ Clean', 'ok')
+        note_details = "".join(f'<div class="ni critical">⚠ {esc(issue)}</div>' for issue in issues)
+        if not note_details:
+            note_details = '<div style="font-size:11px;color:var(--green);">No issues detected.</div>'
+
+        orphan_cell = '<span class="badge issue">Yes ⚠</span>' if is_orphan else '<span class="badge ok">No</span>'
+
+        rows_html += f'''<tr data-broken="{r['broken_int_count']+r['broken_ext_count']}" data-redirect="{r['redirect_int_count']+r['redirect_ext_count']}" data-internal="{r['int_count']}" data-follow-flag="{r['follow_flag_count']}" data-duplicates="{r['duplicate_count']}" data-orphan="{1 if is_orphan else 0}">
+  <td class="cell-url"><div class="row-num">#{idx}</div>{esc(short_url(r['url'], domain))}</td>
+  <td class="cell-count {'issue' if r['int_count']<3 else 'neutral'}">{r['int_count']}</td>
+  <td class="cell-count neutral">{r['ext_count']}</td>
+  {render_accordion(int_badges, int_details)}
+  {render_accordion(ext_badges, ext_details)}
+  <td class="cell-count"><span style="color:var(--green)">{r['int_df']}</span><span style="color:var(--text-dim)"> / </span><span style="color:{'var(--red)' if r['int_nf']>0 else 'var(--text-dim)'}">{r['int_nf']}</span></td>
+  <td class="cell-count"><span style="color:{'var(--red)' if r['ext_df']>0 else 'var(--text-dim)'}">{r['ext_df']}</span><span style="color:var(--text-dim)"> / </span><span style="color:var(--green)">{r['ext_nf']}</span></td>
+  {render_accordion(flag_badges, flag_details)}
+  {render_accordion(bi_badges, bi_details)}
+  {render_accordion(be_badges, be_details)}
+  {render_accordion(ri_badges, ri_details)}
+  {render_accordion(re_badges, re_details)}
+  {render_accordion(dup_badges, dup_details)}
+  <td class="cell-orphan">{orphan_cell}</td>
+  {render_accordion(sug_badges, sug_details)}
+  {render_accordion(note_badges, note_details)}
+</tr>'''
+
+    report = f'''<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Bulk Link Audit Report</title>
+<link href="https://fonts.googleapis.com/css2?family=DM+Sans:ital,opsz,wght@0,9..40,300;0,9..40,400;0,9..40,500;0,9..40,600;0,9..40,700;1,9..40,400&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+<style>
+:root {{--bg:#f4f6f9;--surface:#fff;--surface-2:#f8f9fb;--surface-3:#eef1f5;--border:#e2e6ed;--border-light:#d0d5de;--text:#1a1f2e;--text-muted:#5c6478;--text-dim:#8892a6;--accent:#2563eb;--accent-dim:rgba(37,99,235,0.06);--accent-light:rgba(37,99,235,0.10);--green:#059669;--green-dim:rgba(5,150,105,0.06);--green-light:rgba(5,150,105,0.10);--red:#dc2626;--red-dim:rgba(220,38,38,0.05);--red-light:rgba(220,38,38,0.08);--orange:#d97706;--orange-dim:rgba(217,119,6,0.06);--purple:#7c3aed;--purple-dim:rgba(124,58,237,0.06);--pink:#db2777;--pink-dim:rgba(219,39,119,0.06);--mono:'JetBrains Mono',monospace;--font:'DM Sans',sans-serif;--radius:8px;--radius-sm:5px;}}
+*{{margin:0;padding:0;box-sizing:border-box;}}body{{background:var(--bg);color:var(--text);font-family:var(--font);-webkit-font-smoothing:antialiased;line-height:1.55;}}
+.header{{padding:32px 36px 24px;border-bottom:1px solid var(--border);background:var(--surface);}}.header .tag-line{{font-size:10px;font-weight:700;letter-spacing:1.8px;text-transform:uppercase;color:var(--accent);margin-bottom:8px;}}.header h1{{font-size:21px;font-weight:700;margin-bottom:4px;}}.header .meta{{font-size:11.5px;color:var(--text-dim);}}.header .meta span{{color:var(--text-muted);}}
+.toolbar{{display:flex;align-items:center;gap:10px;padding:12px 36px;background:var(--surface);border-bottom:1px solid var(--border);flex-wrap:wrap;}}.toolbar-btn{{font-family:var(--font);font-size:11px;font-weight:600;color:var(--text-muted);background:var(--surface-2);border:1px solid var(--border);border-radius:var(--radius-sm);padding:6px 14px;cursor:pointer;transition:all .15s;}}.toolbar-btn:hover{{color:var(--text);background:var(--surface-3);}}.toolbar-btn.active{{color:var(--accent);border-color:var(--accent);background:var(--accent-dim);}}.toolbar-sep{{width:1px;height:20px;background:var(--border);}}.toolbar-label{{font-size:10px;font-weight:600;letter-spacing:.5px;text-transform:uppercase;color:var(--text-dim);margin-right:4px;}}
+.legend{{display:flex;flex-wrap:wrap;gap:18px;padding:10px 36px;background:var(--surface-2);border-bottom:1px solid var(--border);}}.legend-item{{display:flex;align-items:center;gap:6px;font-size:10.5px;color:var(--text-muted);}}.legend-dot{{width:8px;height:8px;border-radius:50%;}}.legend-dot.green{{background:var(--green);}}.legend-dot.red{{background:var(--red);}}.legend-dot.blue{{background:var(--accent);}}
+.summary-bar{{display:flex;border-bottom:1px solid var(--border);background:var(--surface);flex-wrap:wrap;}}.summary-stat{{flex:1;padding:14px 16px;border-right:1px solid var(--border);text-align:center;min-width:90px;}}.summary-stat:last-child{{border-right:none;}}.summary-stat .s-val{{font-size:22px;font-weight:700;line-height:1;margin-bottom:2px;}}.summary-stat .s-label{{font-size:9px;font-weight:600;letter-spacing:.5px;text-transform:uppercase;color:var(--text-dim);}}.s-val.blue{{color:var(--accent);}}.s-val.green{{color:var(--green);}}.s-val.red{{color:var(--red);}}.s-val.pink{{color:var(--pink);}}
+.table-wrap{{overflow-x:auto;background:var(--surface);}}table{{width:100%;border-collapse:collapse;min-width:2400px;}}
+thead th{{background:var(--surface-3);color:var(--text-muted);font-size:9px;font-weight:700;letter-spacing:.7px;text-transform:uppercase;padding:12px 12px;text-align:left;border-bottom:2px solid var(--border-light);position:sticky;top:0;z-index:10;white-space:nowrap;}}thead th.center{{text-align:center;}}thead th.c-blue{{border-bottom-color:var(--accent);color:var(--accent);}}thead th.c-red{{border-bottom-color:var(--red);color:var(--red);}}thead th.c-green{{border-bottom-color:var(--green);color:var(--green);}}thead th.c-pink{{border-bottom-color:var(--pink);color:var(--pink);}}thead th:first-child{{position:sticky;left:0;z-index:15;border-right:2px solid var(--border-light);background:var(--surface-3);}}
+tbody tr{{border-bottom:1px solid var(--border);transition:background .12s;}}tbody tr:hover{{background:var(--accent-dim);}}
+tbody td{{padding:10px 12px;vertical-align:top;font-size:12px;border-right:1px solid var(--border);}}tbody td:last-child{{border-right:none;}}
+td.cell-url{{font-family:var(--mono);font-size:11px;color:var(--accent);word-break:break-all;line-height:1.5;background:var(--surface);position:sticky;left:0;z-index:5;border-right:2px solid var(--border-light);min-width:260px;max-width:260px;}}td.cell-url .row-num{{font-size:9px;color:var(--text-dim);margin-bottom:4px;font-weight:600;}}
+td.cell-count{{text-align:center;font-family:var(--mono);font-size:15px;font-weight:700;vertical-align:middle;}}td.cell-count.ok{{color:var(--green);}}td.cell-count.issue{{color:var(--red);}}td.cell-count.neutral{{color:var(--text);}}
+.acc-cell{{cursor:pointer;user-select:none;}}.acc-collapsed{{display:flex;align-items:center;gap:8px;min-height:26px;}}.acc-chevron{{width:20px;height:20px;border-radius:4px;background:var(--surface-3);display:flex;align-items:center;justify-content:center;flex-shrink:0;transition:transform .2s,background .15s;font-size:10px;color:var(--text-dim);border:1px solid var(--border);}}.acc-cell.open .acc-chevron{{transform:rotate(90deg);background:var(--accent-dim);color:var(--accent);border-color:var(--accent);}}.acc-summary{{font-size:11px;color:var(--text-muted);display:flex;flex-wrap:wrap;gap:4px;align-items:center;}}
+.badge{{font-size:9px;font-weight:700;padding:2.5px 8px;border-radius:10px;letter-spacing:.2px;white-space:nowrap;border:1px solid transparent;}}.badge.ok{{background:var(--green-dim);color:var(--green);border-color:var(--green-light);}}.badge.issue{{background:var(--red-dim);color:var(--red);border-color:var(--red-light);}}.badge.sug{{background:var(--green-dim);color:var(--green);border-color:var(--green-light);}}.badge.neutral{{background:var(--surface-3);color:var(--text-dim);border-color:var(--border);}}
+.acc-details{{display:none;margin-top:10px;padding-top:10px;border-top:1px dashed var(--border);}}.acc-cell.open .acc-details{{display:block;}}
+.le{{padding:9px 11px;background:var(--surface-2);border-radius:var(--radius-sm);margin-bottom:6px;border:1px solid var(--border);border-left-width:3px;}}.le:last-child{{margin-bottom:0;}}.le.s-ok{{border-left-color:var(--green);}}.le.s-issue{{border-left-color:var(--red);background:var(--red-dim);}}
+.le .le-url{{font-family:var(--mono);font-size:10.5px;color:var(--accent);word-break:break-all;margin-bottom:4px;}}.le.s-issue .le-url{{color:var(--red);}}
+.le .le-tags{{display:flex;flex-wrap:wrap;gap:4px;margin-bottom:4px;}}.tag-sm{{font-size:8.5px;font-weight:700;padding:2px 6px;border-radius:8px;}}.tag-sm.ok{{background:var(--green-light);color:var(--green);}}.tag-sm.issue{{background:var(--red-light);color:var(--red);}}
+.le .le-anchor{{font-size:10.5px;color:var(--text-muted);}}.le .le-anchor b{{color:var(--text);font-weight:600;}}.le .le-redir{{font-family:var(--mono);font-size:10px;color:var(--orange);margin-top:3px;}}.le .le-location{{font-size:10px;color:var(--text-dim);margin-top:4px;}}.le .le-issue{{font-size:10px;color:var(--red);margin-top:5px;padding-top:5px;border-top:1px dashed var(--border);font-weight:500;}}.le .le-fix{{font-size:10px;color:var(--green);margin-top:3px;font-weight:500;}}
+.se{{padding:8px 11px;background:var(--surface-2);border-radius:var(--radius-sm);margin-bottom:5px;border:1px solid var(--border);border-left:3px solid var(--green);}}.se:last-child{{margin-bottom:0;}}.se .se-head{{display:flex;justify-content:space-between;align-items:center;margin-bottom:2px;}}.se .se-section{{font-size:9.5px;font-weight:600;letter-spacing:.3px;text-transform:uppercase;color:var(--text-dim);}}.se-pri{{font-size:8.5px;font-weight:700;letter-spacing:.5px;text-transform:uppercase;padding:2px 7px;border-radius:8px;}}.se-pri.high{{background:var(--red-light);color:var(--red);}}.se-pri.med{{background:rgba(217,119,6,.1);color:var(--orange);}}.se .se-url{{font-family:var(--mono);font-size:10px;color:var(--accent);word-break:break-all;margin-bottom:1px;}}.se .se-anchor{{font-size:10px;color:var(--green);font-weight:500;}}
+.ni{{font-size:11px;color:var(--text-muted);line-height:1.5;padding:5px 0;border-bottom:1px dashed var(--border);}}.ni:last-child{{border-bottom:none;}}.ni.critical{{color:var(--red);font-weight:500;}}
+td.cell-orphan{{text-align:center;vertical-align:middle;}}
+.footer{{padding:18px 36px;border-top:1px solid var(--border);font-size:11px;color:var(--text-dim);text-align:center;background:var(--surface);}}
+</style>
+</head>
+<body>
+<div class="header"><div class="tag-line">Bulk Link Audit Report</div><h1>Blog — Body Content Link Analysis</h1><div class="meta">Scope: Body content only · <span>{now}</span> · Pages: <span>{total_pages}</span> · Domain: <span>{esc(domain)}</span></div></div>
+<div class="toolbar"><span class="toolbar-label">Actions:</span><button class="toolbar-btn" onclick="expandAll()">⊞ Expand All</button><button class="toolbar-btn" onclick="collapseAll()">⊟ Collapse All</button><div class="toolbar-sep"></div><span class="toolbar-label">Filter:</span><button class="toolbar-btn filter-btn active" onclick="filterRows('all',this)">All ({total_pages})</button><button class="toolbar-btn filter-btn" onclick="filterRows('broken',this)">Broken ({total_broken})</button><button class="toolbar-btn filter-btn" onclick="filterRows('redirect',this)">Redirects ({total_redirects})</button><button class="toolbar-btn filter-btn" onclick="filterRows('low-links',this)">Low Links</button><button class="toolbar-btn filter-btn" onclick="filterRows('follow-flag',this)">Follow Flags ({total_flags})</button><button class="toolbar-btn filter-btn" onclick="filterRows('duplicates',this)">Duplicates ({total_dups})</button><button class="toolbar-btn filter-btn" onclick="filterRows('orphan',this)">Orphans ({total_orphan})</button></div>
+<div class="legend"><div class="legend-item"><div class="legend-dot green"></div> No Issues</div><div class="legend-item"><div class="legend-dot red"></div> Issue (Broken / Flag / Redirect / Duplicate)</div><div class="legend-item"><div class="legend-dot blue"></div> Info</div></div>
+<div class="summary-bar"><div class="summary-stat"><div class="s-val blue">{total_pages}</div><div class="s-label">Pages</div></div><div class="summary-stat"><div class="s-val blue">{total_int}</div><div class="s-label">Internal</div></div><div class="summary-stat"><div class="s-val blue">{total_ext}</div><div class="s-label">External</div></div><div class="summary-stat"><div class="s-val red">{total_broken}</div><div class="s-label">Broken</div></div><div class="summary-stat"><div class="s-val red">{total_redirects}</div><div class="s-label">Redirects</div></div><div class="summary-stat"><div class="s-val red">{total_flags}</div><div class="s-label">Follow Flags</div></div><div class="summary-stat"><div class="s-val pink">{total_dups}</div><div class="s-label">Duplicates</div></div><div class="summary-stat"><div class="s-val green">{total_sug}</div><div class="s-label">Suggestions</div></div><div class="summary-stat"><div class="s-val red">{total_orphan}</div><div class="s-label">Orphans</div></div></div>
+<div class="table-wrap"><table><thead><tr><th>URL</th><th class="center c-blue">Int.</th><th class="center c-blue">Ext.</th><th class="c-blue">Internal Links</th><th class="c-blue">External Links</th><th class="center">Int DF/NF</th><th class="center">Ext DF/NF</th><th class="c-red">Follow Flags</th><th class="c-red">Broken Int.</th><th class="c-red">Broken Ext.</th><th class="c-red">Redirect Int.</th><th class="c-red">Redirect Ext.</th><th class="c-pink">Duplicates</th><th class="center">Orphan</th><th class="c-green">Suggestions</th><th>Notes</th></tr></thead>
+<tbody>{rows_html}</tbody></table></div>
+<div class="footer">Bulk Link Audit · Body Content Scope · {now} · Click ▶ to expand</div>
+<script>
+function toggleAcc(c){{c.classList.toggle('open');}}
+function expandAll(){{document.querySelectorAll('.acc-cell').forEach(c=>c.classList.add('open'));}}
+function collapseAll(){{document.querySelectorAll('.acc-cell').forEach(c=>c.classList.remove('open'));}}
+function filterRows(t,b){{document.querySelectorAll('.filter-btn').forEach(x=>x.classList.remove('active'));b.classList.add('active');document.querySelectorAll('tbody tr').forEach(r=>{{let d=r.dataset,s=true;if(t==='broken')s=parseInt(d.broken||0)>0;else if(t==='redirect')s=parseInt(d.redirect||0)>0;else if(t==='low-links')s=parseInt(d.internal||0)<5;else if(t==='follow-flag')s=parseInt(d.followFlag||0)>0;else if(t==='duplicates')s=parseInt(d.duplicates||0)>0;else if(t==='orphan')s=parseInt(d.orphan||0)>0;r.style.display=s?'':'none';}});}}
+</script>
+</body></html>'''
+
+    return report

requirements.txt

@@ -0,0 +1,7 @@
+gradio==5.12.0
+requests==2.32.3
+beautifulsoup4==4.12.3
+lxml==5.3.0
+openpyxl==3.1.5
+pandas==2.2.3
+supabase==2.11.0