agentic-browsing-auditor 1.0.0__py3-none-any.whl

agentic_auditor/__init__.py

@@ -0,0 +1,10 @@
+from .auditor import run_lighthouse, build_report, normalize_url, AuditError
+from .app import app
+
+__all__ = [
+    "run_lighthouse",
+    "build_report",
+    "normalize_url",
+    "AuditError",
+    "app",
+]

agentic_auditor/app.py

@@ -0,0 +1,34 @@
+import os
+from flask import Flask, jsonify, render_template, request
+from .auditor import normalize_url, run_lighthouse, build_report, AuditError
+
+# Resolve template and static folders relative to this file
+base_dir = os.path.dirname(os.path.abspath(__file__))
+app = Flask(
+    __name__,
+    template_folder=os.path.join(base_dir, "templates"),
+    static_folder=os.path.join(base_dir, "static")
+)
+
+
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+
+@app.route("/api/audit", methods=["POST"])
+def audit():
+    payload = request.get_json(silent=True) or {}
+    try:
+        url = normalize_url(payload.get("url", ""))
+        raw_report = run_lighthouse(url)
+        report = build_report(raw_report)
+        return jsonify({"ok": True, "report": report})
+    except AuditError as exc:
+        return jsonify({"ok": False, "error": str(exc)}), 400
+    except Exception as exc:  # safety net
+        return jsonify({"ok": False, "error": f"Unexpected error: {exc}"}), 500
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)

agentic_auditor/auditor.py

@@ -0,0 +1,241 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from urllib.parse import urlparse
+
+CATEGORY_ID = "agentic-browsing"
+LIGHTHOUSE_TIMEOUT_SECONDS = 180
+
+
+class AuditError(Exception):
+    """Raised for any expected failure while running/parsing Lighthouse."""
+
+
+def normalize_url(raw: str) -> str:
+    raw = (raw or "").strip()
+    if not raw:
+        raise AuditError("Please enter a domain or URL.")
+    if not re.match(r"^https?://", raw, re.IGNORECASE):
+        raw = "https://" + raw
+    parsed = urlparse(raw)
+    if not parsed.netloc:
+        raise AuditError("That doesn't look like a valid domain or URL.")
+    return raw
+
+
+def find_lighthouse_binary() -> list:
+    """
+    Prefer a locally/globally installed `lighthouse` binary. Fall back to
+    `npx lighthouse`, which will download it on first run if needed.
+    """
+    # Check project-local node_modules first
+    # Walk up from this file's location to check if node_modules is present
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    # In a installed package, node_modules might be located in parent directories
+    # like the workspace root or site-packages.
+    # Let's search from base_dir upwards for node_modules/.bin/lighthouse
+    curr = base_dir
+    while True:
+        local_bin = os.path.join(curr, "node_modules", ".bin")
+        local_lh = os.path.join(local_bin, "lighthouse.cmd" if os.name == "nt" else "lighthouse")
+        if os.path.isfile(local_lh):
+            return [local_lh]
+        parent = os.path.dirname(curr)
+        if parent == curr:
+            break
+        curr = parent
+
+    lighthouse_path = shutil.which("lighthouse")
+    if lighthouse_path:
+        return [lighthouse_path]
+    npx_path = shutil.which("npx")
+    if npx_path:
+        return [npx_path, "--yes", "lighthouse"]
+    raise AuditError(
+        "Neither `lighthouse` nor `npx` was found on this machine. "
+        "Install Node.js, then run: npm install -g lighthouse"
+    )
+
+
+def resolve_chrome_path():
+    """
+    Resolve CHROME_PATH and validate it actually points at a file, so we
+    can fail loudly instead of silently falling back to whatever Chrome
+    chrome-launcher happens to find (usually stable Chrome).
+    """
+    chrome_path = os.environ.get("CHROME_PATH")
+    if not chrome_path:
+        return None
+    if not os.path.isfile(chrome_path):
+        raise AuditError(
+            f"CHROME_PATH is set to '{chrome_path}' but no file exists there. "
+            "Double-check the path (right-click your Chrome Canary shortcut "
+            "-> Properties -> Target on Windows)."
+        )
+    return chrome_path
+
+
+def run_lighthouse(url: str) -> dict:
+    binary_cmd = find_lighthouse_binary()
+    chrome_path = resolve_chrome_path()
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        output_path = os.path.join(tmp_dir, "report.json")
+
+        chrome_flags = "--headless=new --no-sandbox --disable-gpu"
+
+        cmd = binary_cmd + [
+            url,
+            f"--only-categories={CATEGORY_ID}",
+            "--output=json",
+            f"--output-path={output_path}",
+            f"--chrome-flags={chrome_flags}",
+            "--quiet",
+            "--max-wait-for-load=45000",
+        ]
+
+        # chrome-launcher (used internally by Lighthouse) primarily reads
+        # the CHROME_PATH *environment variable*, not a CLI flag - so we
+        # pass it explicitly into the subprocess's environment, and also
+        # append --chrome-path for the (newer) Lighthouse versions that
+        # support it directly. Belt and suspenders.
+        run_env = os.environ.copy()
+        if chrome_path:
+            run_env["CHROME_PATH"] = chrome_path
+            cmd.append(f"--chrome-path={chrome_path}")
+            print(f"[agentic-audit] Using Chrome at: {chrome_path}")
+        else:
+            print(
+                "[agentic-audit] WARNING: CHROME_PATH is not set. "
+                "Lighthouse will auto-discover a Chrome install, which is "
+                "likely your regular stable Chrome (won't support the "
+                "agentic-browsing category)."
+            )
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=LIGHTHOUSE_TIMEOUT_SECONDS,
+                env=run_env,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise AuditError(
+                f"Lighthouse timed out after {LIGHTHOUSE_TIMEOUT_SECONDS}s "
+                "auditing this page."
+            ) from exc
+        except FileNotFoundError as exc:
+            raise AuditError(f"Couldn't launch Lighthouse: {exc}") from exc
+
+        if result.returncode != 0 or not os.path.exists(output_path):
+            stderr_tail = (result.stderr or "").strip()[-2000:]
+            raise AuditError(
+                "Lighthouse failed to produce a report. This usually means "
+                "Chrome couldn't be launched, the site couldn't be reached, "
+                "or your Chrome version doesn't support the Agentic Browsing "
+                f"category yet (needs Chrome 150+, or 130-149 with the "
+                f"webmcp-testing flag).\n\nDetails: {stderr_tail}"
+            )
+
+        with open(output_path, "r", encoding="utf-8") as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError as exc:
+                raise AuditError("Lighthouse returned an unreadable report.") from exc
+
+
+def classify_audit(audit: dict) -> str:
+    """
+    Map a Lighthouse audit result to one of:
+    'fail', 'warning', 'pass', 'not_applicable', 'informative'
+    """
+    display_mode = audit.get("scoreDisplayMode")
+    score = audit.get("score")
+
+    if display_mode == "notApplicable":
+        return "not_applicable"
+    if display_mode == "informative":
+        return "informative"
+    if display_mode in ("manual", "error"):
+        return "warning"
+    if display_mode == "numeric":
+        # e.g. Cumulative Layout Shift - use score thresholds like Lighthouse does
+        if score is None:
+            return "informative"
+        if score >= 0.9:
+            return "pass"
+        if score >= 0.5:
+            return "warning"
+        return "fail"
+    # binary
+    if score == 1:
+        return "pass"
+    if score == 0:
+        return "fail"
+    return "warning"
+
+
+def build_report(raw: dict) -> dict:
+    categories = raw.get("categories", {})
+    category = categories.get(CATEGORY_ID)
+    if category is None:
+        raise AuditError(
+            "This Lighthouse report has no 'agentic-browsing' category. "
+            "Your Chrome/Lighthouse version likely doesn't support it yet."
+        )
+
+    audits_by_id = raw.get("audits", {})
+    groups_meta = raw.get("categoryGroups") or raw.get("groups") or {}
+
+    grouped: dict = {}
+    ungrouped = []
+
+    pass_count = 0
+    fail_or_warn_count = 0
+
+    for ref in category.get("auditRefs", []):
+        audit_id = ref.get("id")
+        audit = audits_by_id.get(audit_id, {})
+        status = classify_audit(audit)
+
+        entry = {
+            "id": audit_id,
+            "title": audit.get("title", audit_id),
+            "description": audit.get("description", ""),
+            "status": status,
+            "display_value": audit.get("displayValue"),
+            "score": audit.get("score"),
+        }
+
+        if status in ("pass",):
+            pass_count += 1
+        elif status in ("fail", "warning"):
+            fail_or_warn_count += 1
+
+        group_id = ref.get("group")
+        if group_id:
+            group_title = (groups_meta.get(group_id) or {}).get("title", group_id)
+            grouped.setdefault(group_id, {"title": group_title, "audits": []})
+            grouped[group_id]["audits"].append(entry)
+        else:
+            ungrouped.append(entry)
+
+    total_scored = pass_count + fail_or_warn_count
+    ratio_label = f"{pass_count}/{total_scored}" if total_scored else "N/A"
+
+    return {
+        "final_url": raw.get("finalUrl") or raw.get("requestedUrl"),
+        "fetch_time": raw.get("fetchTime"),
+        "lighthouse_version": raw.get("lighthouseVersion"),
+        "category_title": category.get("title", "Agentic Browsing"),
+        "category_description": category.get("description", ""),
+        "pass_ratio_label": ratio_label,
+        "pass_count": pass_count,
+        "scored_count": total_scored,
+        "ungrouped_audits": ungrouped,
+        "groups": list(grouped.values()),
+    }

agentic_auditor/cli.py

@@ -0,0 +1,229 @@
+import csv
+import os
+import sys
+import click
+
+# Reconfigure stdout/stderr to use UTF-8 to prevent UnicodeEncodeError on Windows console
+if sys.platform.startswith("win"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+from rich.console import Console
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
+from .auditor import run_lighthouse, build_report, normalize_url, AuditError
+
+console = Console()
+
+
+@click.group()
+@click.version_option(package_name="agentic-browsing-auditor")
+def main():
+    """Agentic Browsing Auditor CLI tool built by Amal Alexander.
+
+    Audits website performance for LLM agents (llms.txt, WebMCP, accessibility).
+    LinkedIn: https://www.linkedin.com/in/amal-alexander-305780131/
+    """
+    pass
+
+
+@main.command()
+@click.argument("url")
+def audit(url):
+    """Audit a single URL and display the results in the terminal."""
+    try:
+        clean_url = normalize_url(url)
+    except AuditError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        sys.exit(1)
+
+    console.print(f"[bold blue]◐[/bold blue] Auditing [cyan]{clean_url}[/cyan] ...")
+    console.print("[dim]Launching headless Chrome and running Lighthouse... (takes 20-60s)[/dim]")
+
+    try:
+        raw_report = run_lighthouse(clean_url)
+        report = build_report(raw_report)
+    except AuditError as exc:
+        console.print(f"\n[red]Audit failed:[/red]\n{exc}")
+        sys.exit(1)
+    except Exception as exc:
+        console.print(f"\n[red]Unexpected error:[/red]\n{exc}")
+        sys.exit(1)
+
+    console.print("\n[bold green]✓ Audit Completed Successfully![/bold green]")
+    console.print(f"[bold]Final URL:[/bold] {report['final_url']}")
+    console.print(f"[bold]Lighthouse Version:[/bold] {report['lighthouse_version']}")
+    console.print(f"[bold]Fetch Time:[/bold] {report['fetch_time']}")
+    console.print(f"[bold]Pass Ratio:[/bold] [bold green]{report['pass_ratio_label']}[/bold green]\n")
+
+    # Render summary table
+    table = Table(title="[bold blue]Agentic Browsing Audits Summary[/bold blue]")
+    table.add_column("Status", justify="center", width=8)
+    table.add_column("Audit ID", style="cyan")
+    table.add_column("Title", style="white")
+    table.add_column("Result / Value", justify="right")
+
+    status_colors = {
+        "pass": "[bold green]PASS[/bold green]",
+        "fail": "[bold red]FAIL[/bold red]",
+        "warning": "[bold yellow]WARN[/bold yellow]",
+        "not_applicable": "[dim]N/A[/dim]",
+        "informative": "[dim]INFO[/dim]",
+    }
+
+    # Gather all audits (grouped and ungrouped)
+    all_audits = []
+    for group in report.get("groups", []):
+        all_audits.extend(group.get("audits", []))
+    all_audits.extend(report.get("ungrouped_audits", []))
+
+    for item in all_audits:
+        status_lbl = status_colors.get(item["status"], item["status"].upper())
+        val = item["display_value"] or (f"Score: {item['score']}" if item["score"] is not None else "-")
+        table.add_row(status_lbl, item["id"], item["title"], str(val))
+
+    console.print(table)
+
+
+@main.command()
+@click.argument("input_file", type=click.Path(exists=True))
+@click.option(
+    "-o",
+    "--output",
+    "output_file",
+    default="audit_results.csv",
+    help="CSV file path to save results.",
+    show_default=True,
+)
+def bulk(input_file, output_file):
+    """Audit multiple URLs listed in a text file (one URL per line) and export to CSV."""
+    urls = []
+    with open(input_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#"):
+                urls.append(line)
+
+    if not urls:
+        console.print("[yellow]No URLs found in the input file.[/yellow]")
+        return
+
+    console.print(f"[bold blue]◐[/bold blue] Found [cyan]{len(urls)}[/cyan] URLs to audit.")
+    console.print(f"[dim]Results will be saved to: {output_file}[/dim]\n")
+
+    results = []
+
+    # Setup CSV header
+    headers = [
+        "URL",
+        "Final URL",
+        "Lighthouse Version",
+        "Fetch Time",
+        "Pass Ratio",
+        "Pass Count",
+        "Scored Count",
+        "Passed Audits",
+        "Failed Audits",
+        "Warnings",
+        "Not Applicable",
+    ]
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("[blue]Bulk Audits[/blue]", total=len(urls))
+
+        for idx, raw_url in enumerate(urls):
+            progress.update(task, description=f"[cyan]Auditing ({idx + 1}/{len(urls)})[/cyan] {raw_url}")
+            url_result = {
+                "URL": raw_url,
+                "Final URL": "",
+                "Lighthouse Version": "",
+                "Fetch Time": "",
+                "Pass Ratio": "Error",
+                "Pass Count": 0,
+                "Scored Count": 0,
+                "Passed Audits": "",
+                "Failed Audits": "",
+                "Warnings": "",
+                "Not Applicable": "",
+            }
+
+            try:
+                clean_url = normalize_url(raw_url)
+                raw_report = run_lighthouse(clean_url)
+                report = build_report(raw_report)
+
+                url_result["Final URL"] = report["final_url"] or clean_url
+                url_result["Lighthouse Version"] = report["lighthouse_version"]
+                url_result["Fetch Time"] = report["fetch_time"]
+                url_result["Pass Ratio"] = report["pass_ratio_label"]
+                url_result["Pass Count"] = report["pass_count"]
+                url_result["Scored Count"] = report["scored_count"]
+
+                # Gather audits by category
+                all_audits = []
+                for group in report.get("groups", []):
+                    all_audits.extend(group.get("audits", []))
+                all_audits.extend(report.get("ungrouped_audits", []))
+
+                passed = []
+                failed = []
+                warns = []
+                nas = []
+
+                for item in all_audits:
+                    title = item["title"]
+                    if item["status"] == "pass":
+                        passed.append(title)
+                    elif item["status"] == "fail":
+                        failed.append(title)
+                    elif item["status"] == "warning":
+                        warns.append(title)
+                    elif item["status"] in ("not_applicable", "informative"):
+                        nas.append(title)
+
+                url_result["Passed Audits"] = "; ".join(passed)
+                url_result["Failed Audits"] = "; ".join(failed)
+                url_result["Warnings"] = "; ".join(warns)
+                url_result["Not Applicable"] = "; ".join(nas)
+
+                progress.console.print(f"[green]✓[/green] Completed: {raw_url} [green]({report['pass_ratio_label']})[/green]")
+            except Exception as e:
+                progress.console.print(f"[red]✗[/red] Failed: {raw_url} - [red]{str(e)}[/red]")
+                url_result["Passed Audits"] = f"Error: {str(e)}"
+
+            results.append(url_result)
+            progress.advance(task)
+
+    # Write to CSV
+    with open(output_file, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=headers)
+        writer.writeheader()
+        writer.writerows(results)
+
+    console.print(f"\n[bold green]✓ Bulk audits finished![/bold green] Saved report to [cyan]{output_file}[/cyan].")
+
+
+@main.command()
+@click.option("--host", default="127.0.0.1", help="Host address to bind to.", show_default=True)
+@click.option("-p", "--port", default=5000, help="Port to run Flask app.", show_default=True)
+@click.option("--debug", is_flag=True, help="Enable Flask debug mode.")
+def serve(host, port, debug):
+    """Launch the local web dashboard interface."""
+    from .app import app
+
+    console.print("[bold blue]◐[/bold blue] Launching Agentic Browsing Auditor web dashboard...")
+    app.run(host=host, port=port, debug=debug)
+
+
+if __name__ == "__main__":
+    main()

agentic_auditor/static/script.js

@@ -0,0 +1,162 @@
+const form = document.getElementById("audit-form");
+const urlInput = document.getElementById("url-input");
+const submitBtn = document.getElementById("submit-btn");
+const statusArea = document.getElementById("status-area");
+const reportArea = document.getElementById("report-area");
+
+const ICONS = {
+  fail: "▲",
+  warning: "■",
+  pass: "✓",
+  not_applicable: "○",
+  informative: "ℹ",
+};
+
+function setStatus(kind, message) {
+  statusArea.hidden = false;
+  statusArea.className = `status-area ${kind}`;
+  statusArea.textContent = message;
+}
+
+function clearStatus() {
+  statusArea.hidden = true;
+  statusArea.textContent = "";
+}
+
+function escapeHtml(str) {
+  const div = document.createElement("div");
+  div.textContent = str ?? "";
+  return div.innerHTML;
+}
+
+function auditRowHtml(audit) {
+  const icon = ICONS[audit.status] || "•";
+  const value = audit.display_value ? `<span class="audit-value">${escapeHtml(audit.display_value)}</span>` : "";
+  return `
+    <details class="audit-row">
+      <summary>
+        <span class="icon status-${audit.status}">${icon}</span>
+        <span class="audit-title">${escapeHtml(audit.title)}</span>
+        ${value}
+        <span class="chevron">▾</span>
+      </summary>
+      <div class="audit-detail">${escapeHtml(stripMarkdownLinks(audit.description))}</div>
+    </details>
+  `;
+}
+
+// Lighthouse descriptions often contain markdown links like [text](url) and
+// `code` spans; render them minimally without pulling in a markdown lib.
+function stripMarkdownLinks(text) {
+  if (!text) return "";
+  return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/`([^`]+)`/g, "$1");
+}
+
+function collapsibleSectionHtml(id, label, audits) {
+  if (!audits.length) return "";
+  const rows = audits.map(auditRowHtml).join("");
+  return `
+    <button type="button" class="section-toggle" data-target="${id}">
+      <span>${label} (${audits.length})</span>
+      <span class="link" data-label="${label}">Show</span>
+    </button>
+    <div class="collapsible" id="${id}">${rows}</div>
+  `;
+}
+
+function partitionAudits(audits) {
+  const failWarn = audits.filter((a) => a.status === "fail" || a.status === "warning");
+  const passed = audits.filter((a) => a.status === "pass");
+  const notApplicable = audits.filter((a) => a.status === "not_applicable" || a.status === "informative");
+  return { failWarn, passed, notApplicable };
+}
+
+function groupBlockHtml(group, idx) {
+  const { failWarn, passed, notApplicable } = partitionAudits(group.audits);
+  const heading = group.title ? `<div class="group-heading">${escapeHtml(group.title)}</div>` : "";
+  const failWarnRows = failWarn.map(auditRowHtml).join("");
+  const passedId = `passed-${idx}`;
+  const naId = `na-${idx}`;
+  return `
+    ${heading}
+    ${failWarnRows}
+    ${collapsibleSectionHtml(passedId, "Passed audits", passed)}
+    ${collapsibleSectionHtml(naId, "Not applicable", notApplicable)}
+  `;
+}
+
+function ratioStatusClass(passCount, scoredCount) {
+  if (scoredCount === 0) return "status-warning";
+  const ratio = passCount / scoredCount;
+  if (ratio === 1) return "status-pass";
+  if (ratio === 0) return "status-fail";
+  return "status-fail"; // Lighthouse shows the red triangle for any failing check
+}
+
+function renderReport(report) {
+  const statusClass = ratioStatusClass(report.pass_count, report.scored_count);
+  const ungroupedRows = report.ungrouped_audits.map(auditRowHtml).join("");
+
+  const groupsHtml = report.groups
+    .map((group, idx) => groupBlockHtml(group, idx))
+    .join("");
+
+  reportArea.innerHTML = `
+    <div class="report-card">
+      <div class="report-header">
+        <div class="ratio-badge ${statusClass}">
+          ${ICONS.fail} ${escapeHtml(report.pass_ratio_label)}
+        </div>
+        <h2>${escapeHtml(report.category_title)}</h2>
+        <p>${escapeHtml(stripMarkdownLinks(report.category_description))}</p>
+      </div>
+      <div class="audited-url">Audited: ${escapeHtml(report.final_url || "")}</div>
+      ${ungroupedRows}
+      ${groupsHtml}
+      <div class="footer-meta">
+        Generated with Lighthouse ${escapeHtml(report.lighthouse_version || "")} · ${escapeHtml(report.fetch_time || "")}
+      </div>
+    </div>
+  `;
+  reportArea.hidden = false;
+
+  reportArea.querySelectorAll(".section-toggle").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const target = document.getElementById(btn.dataset.target);
+      const isOpen = target.classList.toggle("open");
+      const linkEl = btn.querySelector(".link");
+      linkEl.textContent = isOpen ? "Hide" : "Show";
+    });
+  });
+}
+
+form.addEventListener("submit", async (e) => {
+  e.preventDefault();
+  reportArea.hidden = true;
+  reportArea.innerHTML = "";
+  submitBtn.disabled = true;
+  submitBtn.textContent = "Analyzing…";
+  setStatus("loading", "Launching Chrome and running the Agentic Browsing audit — this can take 20-60 seconds…");
+
+  try {
+    const res = await fetch("/api/audit", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url: urlInput.value }),
+    });
+    const data = await res.json();
+
+    if (!res.ok || !data.ok) {
+      setStatus("error", data.error || "Something went wrong running the audit.");
+      return;
+    }
+
+    clearStatus();
+    renderReport(data.report);
+  } catch (err) {
+    setStatus("error", `Couldn't reach the backend: ${err.message}`);
+  } finally {
+    submitBtn.disabled = false;
+    submitBtn.textContent = "Analyze";
+  }
+});

agentic_auditor/static/style.css

@@ -0,0 +1,295 @@
+:root {
+  --ink: #202124;
+  --muted: #5f6368;
+  --line: #e8eaed;
+  --red: #d32f2f;
+  --red-bg: #fdecea;
+  --orange: #f9a825;
+  --orange-bg: #fff8e1;
+  --green: #1e8e3e;
+  --green-bg: #e6f4ea;
+  --gray: #9aa0a6;
+  --blue: #1a73e8;
+  --card-bg: #ffffff;
+  --page-bg: #f6f7f8;
+  --radius: 10px;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  background: var(--page-bg);
+  color: var(--ink);
+  font-family: "Roboto", "Segoe UI", Helvetica, Arial, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+
+.topbar {
+  background: var(--card-bg);
+  border-bottom: 1px solid var(--line);
+  padding: 28px 24px 22px;
+  text-align: center;
+}
+
+.topbar-inner {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+}
+
+.logo-mark {
+  font-size: 22px;
+  color: var(--blue);
+}
+
+.topbar h1 {
+  font-size: 22px;
+  font-weight: 600;
+  margin: 0;
+}
+
+.subhead {
+  max-width: 620px;
+  margin: 10px auto 0;
+  color: var(--muted);
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+main {
+  max-width: 700px;
+  margin: 28px auto 80px;
+  padding: 0 20px;
+}
+
+.search-card {
+  background: var(--card-bg);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 20px;
+}
+
+.search-card label {
+  display: block;
+  font-size: 12px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--muted);
+  margin-bottom: 8px;
+}
+
+.input-row {
+  display: flex;
+  gap: 10px;
+}
+
+#url-input {
+  flex: 1;
+  padding: 11px 14px;
+  border: 1px solid #dadce0;
+  border-radius: 8px;
+  font-size: 15px;
+  color: var(--ink);
+}
+
+#url-input:focus {
+  outline: 2px solid var(--blue);
+  outline-offset: -1px;
+  border-color: var(--blue);
+}
+
+#submit-btn {
+  padding: 11px 20px;
+  border: none;
+  border-radius: 8px;
+  background: var(--blue);
+  color: white;
+  font-size: 15px;
+  font-weight: 500;
+  cursor: pointer;
+}
+
+#submit-btn:hover { background: #1765cc; }
+#submit-btn:disabled { background: #9aa0a6; cursor: default; }
+
+.hint {
+  margin: 12px 0 0;
+  font-size: 12.5px;
+  color: var(--muted);
+}
+
+.status-area {
+  margin-top: 22px;
+  padding: 16px 18px;
+  border-radius: var(--radius);
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.status-area.loading {
+  background: #e8f0fe;
+  color: #174ea6;
+}
+
+.status-area.error {
+  background: var(--red-bg);
+  color: var(--red);
+  white-space: pre-wrap;
+}
+
+.report-area {
+  margin-top: 24px;
+}
+
+.report-card {
+  background: var(--card-bg);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+
+.report-header {
+  padding: 32px 24px 24px;
+  text-align: center;
+  border-bottom: 1px solid var(--line);
+}
+
+.ratio-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 18px;
+  border-radius: 999px;
+  font-weight: 700;
+  font-size: 16px;
+  margin-bottom: 18px;
+}
+
+.ratio-badge.status-fail { background: var(--red-bg); color: var(--red); }
+.ratio-badge.status-warning { background: var(--orange-bg); color: var(--orange); }
+.ratio-badge.status-pass { background: var(--green-bg); color: var(--green); }
+
+.report-header h2 {
+  font-size: 24px;
+  margin: 0 0 10px;
+}
+
+.report-header p {
+  color: var(--muted);
+  font-size: 14px;
+  line-height: 1.6;
+  max-width: 480px;
+  margin: 0 auto;
+}
+
+.report-header a { color: var(--blue); text-decoration: none; }
+.report-header a:hover { text-decoration: underline; }
+
+.audited-url {
+  font-size: 12.5px;
+  color: var(--muted);
+  padding: 10px 24px;
+  border-bottom: 1px solid var(--line);
+  word-break: break-all;
+}
+
+.group-heading {
+  padding: 16px 24px 8px;
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  color: var(--muted);
+  border-top: 1px solid var(--line);
+}
+
+.audit-row {
+  border-top: 1px solid var(--line);
+}
+
+.audit-row summary {
+  list-style: none;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 24px;
+  font-size: 14.5px;
+}
+
+.audit-row summary::-webkit-details-marker { display: none; }
+
+.audit-row summary .chevron {
+  margin-left: auto;
+  color: var(--muted);
+  transition: transform 0.15s ease;
+  font-size: 12px;
+}
+
+.audit-row[open] summary .chevron { transform: rotate(180deg); }
+
+.icon {
+  flex: none;
+  width: 16px;
+  height: 16px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.icon.status-fail { color: var(--red); }
+.icon.status-warning { color: var(--orange); }
+.icon.status-pass { color: var(--green); }
+.icon.status-not_applicable, .icon.status-informative { color: var(--gray); }
+
+.audit-title { flex: 1; }
+
+.audit-value {
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.audit-detail {
+  padding: 0 24px 18px 52px;
+  font-size: 13.5px;
+  color: var(--muted);
+  line-height: 1.6;
+}
+
+.section-toggle {
+  width: 100%;
+  text-align: left;
+  padding: 14px 24px;
+  border: none;
+  background: none;
+  border-top: 1px solid var(--line);
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+  color: var(--muted);
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+}
+
+.section-toggle span.link { color: var(--blue); text-transform: none; font-weight: 500; letter-spacing: 0; }
+
+.collapsible { display: none; }
+.collapsible.open { display: block; }
+
+.footer-meta {
+  padding: 16px 24px;
+  font-size: 12px;
+  color: var(--muted);
+  border-top: 1px solid var(--line);
+  text-align: center;
+}
+
+@media (max-width: 520px) {
+  .input-row { flex-direction: column; }
+  #submit-btn { width: 100%; }
+}

agentic_auditor/templates/index.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Agentic Browsing Auditor</title>
+<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}" />
+</head>
+<body>
+  <header class="topbar">
+    <div class="topbar-inner">
+      <span class="logo-mark">◐</span>
+      <h1>Agentic Browsing Auditor</h1>
+    </div>
+    <p class="subhead">
+      Run Google Lighthouse's experimental Agentic Browsing category against any page —
+      llms.txt, WebMCP, agent-centric accessibility, and layout stability.
+    </p>
+  </header>
+
+  <main>
+    <section class="search-card">
+      <form id="audit-form">
+        <label for="url-input">Domain or page URL</label>
+        <div class="input-row">
+          <input
+            id="url-input"
+            type="text"
+            placeholder="example.com or https://example.com/pricing"
+            autocomplete="off"
+            required
+          />
+          <button type="submit" id="submit-btn">Analyze</button>
+        </div>
+      </form>
+      <p class="hint">
+        Requires Lighthouse + a compatible Chrome build on the server running this tool.
+        See the README if you hit setup errors.
+      </p>
+    </section>
+
+    <section id="status-area" class="status-area" hidden></section>
+
+    <section id="report-area" class="report-area" hidden></section>
+  </main>
+
+  <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

agentic_browsing_auditor-1.0.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: agentic-browsing-auditor
+Version: 1.0.0
+Summary: Lighthouse Agentic Browsing Audit CLI and local Web Dashboard
+Author-email: Amal Alexander <amalalex95@gmail.com>
+Project-URL: Homepage, https://github.com/amal-alexander/agentic-browsing-auditor
+Project-URL: LinkedIn, https://www.linkedin.com/in/amal-alexander-305780131/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Flask>=3.0.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=13.0.0
+
+# Agentic Browsing Auditor
+
+[![PyPI Version](https://img.shields.io/pypi/v/agentic-browsing-auditor.svg)](https://pypi.org/project/agentic-browsing-auditor/)
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-Amal%20Alexander-blue)](https://www.linkedin.com/in/amal-alexander-305780131/)
+
+A Python-based CLI tool and local dashboard to audit website performance for LLM agents using Google Lighthouse's experimental **Agentic Browsing** category (evaluates `llms.txt`, `WebMCP`, agent-centric accessibility, and layout stability).
+
+Developed by **Amal Alexander** ([LinkedIn](https://www.linkedin.com/in/amal-alexander-305780131/)).
+
+---
+
+## Why you need Chrome + Node
+
+The Agentic Browsing category:
+- Shipped in **Lighthouse 13.3** (May 2026) as part of the default config.
+- Requires **Chrome 150+** (or Chrome Canary).
+- Requires a local node environment to shell out to `lighthouse`.
+
+---
+
+## Setup & Installation
+
+You can install the auditor package directly from PyPI:
+
+```bash
+pip install agentic-browsing-auditor
+```
+
+### Pre-requisites
+
+1. **Install Node.js** (18+): https://nodejs.org
+2. **Install Lighthouse** globally:
+   ```bash
+   npm install -g lighthouse
+   ```
+3. **Get a compatible Chrome build.** Easiest path: install [Chrome Canary](https://www.google.com/chrome/canary/).
+4. **Point the tool at that Chrome binary** via the `CHROME_PATH` environment variable:
+   - **Windows (PowerShell)**:
+     ```powershell
+     $env:CHROME_PATH = "C:\Users\<YourUsername>\AppData\Local\Google\Chrome SxS\Application\chrome.exe"
+     ```
+   - **macOS**:
+     ```bash
+     export CHROME_PATH="/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+     ```
+   - **Linux**:
+     ```bash
+     export CHROME_PATH="/usr/bin/google-chrome-canary"
+     ```
+
+---
+
+## Usage
+
+Once installed, you can access the auditor using the global CLI command `agentic-auditor`.
+
+### 1. Audit a Single URL
+Analyze a website and print a beautiful table of results directly inside the terminal:
+```bash
+agentic-auditor audit example.com
+```
+
+### 2. Bulk Audit URLs (with CSV export)
+Audit multiple URLs listed in a text file (one URL per line) and export the results to a CSV file.
+```bash
+agentic-auditor bulk urls.txt --output results.csv
+```
+
+### 3. Launch the Local Web Dashboard
+Serve the interactive visual Lighthouse-style dashboard locally:
+```bash
+agentic-auditor serve
+```
+Then visit http://localhost:5000 in your browser.
+
+---
+
+## Author & Contact
+
+Built and maintained by **Amal Alexander**.
+- **Email**: [amalalex95@gmail.com](mailto:amalalex95@gmail.com)
+- **LinkedIn**: [amal-alexander-305780131](https://www.linkedin.com/in/amal-alexander-305780131/)

agentic_browsing_auditor-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+agentic_auditor/__init__.py,sha256=DWJsWudxNT3mGIyIApfaLOanNrmkYuKv6-iCYfukdzw,205
+agentic_auditor/app.py,sha256=vwLWnmqxtjlDMZd4TgwkbGn7BUhAkizbteUvUIEHUJw,1072
+agentic_auditor/auditor.py,sha256=VqwzKPjFFkwkDzDLSzXxb41ylKi5jRbz6aKaD449fN0,8458
+agentic_auditor/cli.py,sha256=cuMqeYBeVr7q4OdXk6VrPYsuMtsJOzFh3kHBEWwCpUU,8312
+agentic_auditor/static/script.js,sha256=iiZlZSfDeCLZuATbbmd7Y73z3Pva4SYtI5vea5LikAo,5625
+agentic_auditor/static/style.css,sha256=yiexmQNFIl4eOStKPcRQWccUXvwWheCpm1em1pzX0MU,5742
+agentic_auditor/templates/index.html,sha256=g7C6ESb_NYc7rj78in4K96cHH1tWTSOqd7KLciRE4U8,1560
+agentic_browsing_auditor-1.0.0.dist-info/METADATA,sha256=gzNJufVBJhAoTHRIXMDk4HFlG1HzMrb7CvcQsvaGWqw,3415
+agentic_browsing_auditor-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentic_browsing_auditor-1.0.0.dist-info/entry_points.txt,sha256=PuRWpAsxdbFKaKQjCOxUzj_q3MZFR1O-0lplzrnVUqk,61
+agentic_browsing_auditor-1.0.0.dist-info/top_level.txt,sha256=fyWUSygSE-Rp_hNElkUUy0OLOXUHBceUmTRO7M9iGeU,16
+agentic_browsing_auditor-1.0.0.dist-info/RECORD,,

agentic_browsing_auditor-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentic_browsing_auditor-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentic-auditor = agentic_auditor.cli:main

agentic_browsing_auditor-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentic_auditor