eclipse-agentready 0.1.0__tar.gz

eclipse_agentready-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cyan Eclipse Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eclipse_agentready-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: eclipse-agentready
+Version: 0.1.0
+Summary: AgentReady (T6 CLI edition) — audit a public storefront for AI shopping-agent readiness from CI: UCP profile, live MCP endpoint, llms.txt, robots AI policy, Product structured data, sitemap, platform, HTTPS/canonical.
+Author: Cyan Eclipse Technologies LLC
+License: MIT
+Project-URL: Homepage, https://cetech.ai
+Project-URL: Repository, https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/agent-ready-mcp
+Project-URL: Vendor, https://cetech.ai
+Keywords: agent-readiness,storefront,e-commerce,ci,audit,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# eclipse-agentready
+
+**What this is:** `eclipse-agentready` audits **storefronts** — public
+e-commerce sites — for AI shopping-agent readiness: can an agent
+(ChatGPT, Claude, Perplexity, Gemini…) discover the store, read its
+catalog in machine-readable form, and get correct price/stock data?
+
+**What this is not:** it does **not** audit repositories, and it does
+**not** grade MCP servers. (The unrelated PyPI project named
+`agentready` scores *code repositories* for AI-assisted development —
+a different tool for a different job. This one is the CLI edition of
+Cyan Eclipse Technologies' **AgentReady** storefront auditor, also
+available as an MCP server.)
+
+## Use — a CI step for merchants and storefront DevOps
+
+```console
+$ pip install eclipse-agentready
+$ eclipse-agentready audit https://shop.example --fail-under 60
+$ eclipse-agentready audit https://shop.example --format json --out report.json
+$ eclipse-agentready list-checks
+```
+
+Exit codes: `0` = audit completed and (if `--fail-under N` given) the
+score is at least N · `1` = score below N · `2` = the audit itself
+could not run.
+
+## The 8 checks (weights sum to 100)
+
+| Check | Weight |
+|---|---|
+| Live MCP endpoint answers JSON-RPC | 20 |
+| Product structured data (JSON-LD with price + availability) | 20 |
+| UCP profile published (/.well-known/ucp) | 15 |
+| HTTPS + canonical sanity | 12 |
+| robots.txt allows AI crawlers | 10 |
+| Sitemap present with product URLs | 10 |
+| llms.txt present | 8 |
+| Platform identified | 5 |
+
+Scoring: pass = full weight, warn = half, fail = 0, n/a = excluded.
+Grade: A ≥ 90 · B ≥ 75 · C ≥ 60 · D ≥ 40 · F < 40. Every check reports
+observed evidence only, plus a concrete fix hint when it does not fully
+pass. The CLI and the MCP server run the *identical* check catalog and
+scoring path — same evidence in, same grade out.
+
+## Honest scope
+
+- **Public-surface audit only.** All checks read public endpoints with
+  no credentials, a declared user agent, 10s timeouts, and redirect
+  following.
+- **No authenticated checkout execution** — this tool never logs in,
+  never buys, and cannot verify a full agent purchase. A store can
+  score well here and still fail at the checkout step (and vice versa).
+- **No private data** is collected or stored; audit output is the
+  caller's. Evidence is a point-in-time observation; storefronts change.
+- A grade is not an endorsement and not a Bazaar listing claim.
+
+The merchant's path to agent-commerce readiness starts with a grade
+you can watch: run it in CI on every deploy. A hosted monitoring tier
+(scheduled re-audits, score-change alerts) is on the product roadmap
+and is **not yet launched**.
+
+Powered by Cyan Eclipse Technologies LLC (cetech.ai) — a Veteran-Owned
+Small Business. MIT licensed. Not affiliated with Shopify, WooCommerce,
+Automattic, or any audited store; platform names describe detection
+results only.

eclipse_agentready-0.1.0/PYPI_README.md

@@ -0,0 +1,67 @@
+# eclipse-agentready
+
+**What this is:** `eclipse-agentready` audits **storefronts** — public
+e-commerce sites — for AI shopping-agent readiness: can an agent
+(ChatGPT, Claude, Perplexity, Gemini…) discover the store, read its
+catalog in machine-readable form, and get correct price/stock data?
+
+**What this is not:** it does **not** audit repositories, and it does
+**not** grade MCP servers. (The unrelated PyPI project named
+`agentready` scores *code repositories* for AI-assisted development —
+a different tool for a different job. This one is the CLI edition of
+Cyan Eclipse Technologies' **AgentReady** storefront auditor, also
+available as an MCP server.)
+
+## Use — a CI step for merchants and storefront DevOps
+
+```console
+$ pip install eclipse-agentready
+$ eclipse-agentready audit https://shop.example --fail-under 60
+$ eclipse-agentready audit https://shop.example --format json --out report.json
+$ eclipse-agentready list-checks
+```
+
+Exit codes: `0` = audit completed and (if `--fail-under N` given) the
+score is at least N · `1` = score below N · `2` = the audit itself
+could not run.
+
+## The 8 checks (weights sum to 100)
+
+| Check | Weight |
+|---|---|
+| Live MCP endpoint answers JSON-RPC | 20 |
+| Product structured data (JSON-LD with price + availability) | 20 |
+| UCP profile published (/.well-known/ucp) | 15 |
+| HTTPS + canonical sanity | 12 |
+| robots.txt allows AI crawlers | 10 |
+| Sitemap present with product URLs | 10 |
+| llms.txt present | 8 |
+| Platform identified | 5 |
+
+Scoring: pass = full weight, warn = half, fail = 0, n/a = excluded.
+Grade: A ≥ 90 · B ≥ 75 · C ≥ 60 · D ≥ 40 · F < 40. Every check reports
+observed evidence only, plus a concrete fix hint when it does not fully
+pass. The CLI and the MCP server run the *identical* check catalog and
+scoring path — same evidence in, same grade out.
+
+## Honest scope
+
+- **Public-surface audit only.** All checks read public endpoints with
+  no credentials, a declared user agent, 10s timeouts, and redirect
+  following.
+- **No authenticated checkout execution** — this tool never logs in,
+  never buys, and cannot verify a full agent purchase. A store can
+  score well here and still fail at the checkout step (and vice versa).
+- **No private data** is collected or stored; audit output is the
+  caller's. Evidence is a point-in-time observation; storefronts change.
+- A grade is not an endorsement and not a Bazaar listing claim.
+
+The merchant's path to agent-commerce readiness starts with a grade
+you can watch: run it in CI on every deploy. A hosted monitoring tier
+(scheduled re-audits, score-change alerts) is on the product roadmap
+and is **not yet launched**.
+
+Powered by Cyan Eclipse Technologies LLC (cetech.ai) — a Veteran-Owned
+Small Business. MIT licensed. Not affiliated with Shopify, WooCommerce,
+Automattic, or any audited store; platform names describe detection
+results only.

eclipse_agentready-0.1.0/README.md

@@ -0,0 +1,103 @@
+# AgentReady MCP — v0.1.0
+
+**Powered by Cyan Eclipse Technologies** — https://cetech.ai
+
+An MCP server that audits any public storefront for **AI-agent readiness**:
+can a shopping agent (ChatGPT, Claude, Perplexity, Gemini…) discover the
+store, read its catalog in machine-readable form, and get correct price and
+stock data?
+
+Why it exists (from CETech's Oct 2026 e-commerce MCP research,
+`~/workspace/research_notes/ecommerce-mcp-opportunities-20m-20261025-0106/report.md`):
+
+- Only ~36% of US storefronts can complete an agent purchase end-to-end
+  (InMobi, 3M merchants, Oct 2026).
+- ~95% of merchants already see agent traffic, but only ~20% have
+  machine-readable catalogs (PayPal-cited data).
+- 77% of retailers are not prepared for AI shopping; <1% are fully
+  optimized (Channable, Oct 2026).
+- Comparable readiness/MCP/analytics products charge $69–$999/mo
+  (SignalixIQ, verified pricing Oct 2026).
+
+## Install & run
+
+Stdlib-only Python 3 — no dependencies, no build step.
+
+```bash
+python3 server.py          # MCP over stdio (newline-delimited JSON-RPC 2.0)
+python3 smoke_test.py      # protocol + live-target smoke test (writes results/)
+```
+
+MCP client config (Claude Desktop / Muse / any stdio client):
+
+```json
+{
+  "mcpServers": {
+    "agent-ready": {
+      "command": "python3",
+      "args": ["/path/to/agent-ready-mcp/server.py"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Purpose |
+|---|---|
+| `audit_storefront(url)` | Full readiness audit of a storefront URL: 0–100 score, letter grade, per-check evidence, top-5 fixes. |
+| `list_checks()` | The check catalog with weights and scoring rules. |
+
+## The 8 checks (weights sum to 100)
+
+| Check | Weight | What passes |
+|---|---|---|
+| Live MCP endpoint | 20 | `/api/ucp/mcp`, `/api/mcp`, or `/mcp` answers a JSON-RPC initialize ping (WooCommerce: `/wp-json/mcp` also probed) |
+| Product structured data | 20 | A product page carries JSON-LD `Product` with `offers.price` **and** `offers.availability` |
+| UCP profile | 15 | Valid JSON profile at `/.well-known/ucp` |
+| HTTPS + canonical | 12 | HTTPS final URL + same-host `rel=canonical` |
+| robots.txt AI policy | 10 | GPTBot / ClaudeBot / PerplexityBot / ChatGPT-User / Google-Extended not blocked |
+| Sitemap | 10 | `sitemap.xml` served (index files sampled) with product URLs |
+| llms.txt | 8 | Non-empty `/llms.txt` |
+| Platform detection | 5 | Shopify / WooCommerce / Wix / BigCommerce / Squarespace / Adobe Commerce fingerprint from strong markers |
+
+Scoring: pass = full weight, warn = half, fail = 0, n/a = excluded.
+Grade: A ≥ 90 · B ≥ 75 · C ≥ 60 · D ≥ 40 · F < 40.
+Every check reports **observed evidence only** (HTTP status, response
+content) plus a concrete `fix_hint` when it doesn't fully pass.
+
+## Honest scope
+
+- **Public-surface audit only.** All checks read public endpoints with no
+  credentials, a declared user agent, 10s timeouts, and redirect following.
+- **No authenticated checkout execution** — this version never logs in,
+  never buys, and cannot verify a full agent purchase. A store can score
+  well here and still fail at the checkout step (and vice versa).
+- **No private data** is collected or stored; audit output is the caller's.
+- Evidence is a point-in-time observation; storefronts change.
+
+## Smoke-test results (2026-10-24, live)
+
+| Target | Platform | Score | Grade |
+|---|---|---|---|
+| gymshark.com | Shopify | 52 | D |
+| woocommerce.com | WooCommerce | 55 | D |
+| thewhitereport.com (non-commerce control) | custom | 32 | F |
+
+Full per-check JSON in `results/`. Even flagship stores fail the UCP and
+MCP-endpoint checks today — that gap is the product opportunity.
+
+## Status / roadmap
+
+v0.1.0 — in development / dogfood. Local-audit v0.1 closure (EB-11,
+2026-10-26): normative check catalog in `docs/check-catalog.md`,
+evidence report format in `docs/evidence-report-format.md`,
+sample-storefront test corpus in `corpus/sample-storefronts.json`;
+`python3 validate_closure.py` re-verifies all three against the code
+and recorded reports (31/31). Planned: hosted monitoring tier
+(re-audit on a schedule, score-change alerts), fix-playbook deep links per
+platform, authenticated checkout verification (with merchant credentials),
+and a Bazaar listing via Eclipse Bazaar once the test bench certifies it.
+
+*Not affiliated with Shopify, WooCommerce, Automattic, or the audited
+stores. Platform names are used to describe detection results only.*

eclipse_agentready-0.1.0/VERSION

@@ -0,0 +1 @@
+0.1.0

eclipse_agentready-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eclipse-agentready"
+dynamic = ["version"]
+description = "AgentReady (T6 CLI edition) — audit a public storefront for AI shopping-agent readiness from CI: UCP profile, live MCP endpoint, llms.txt, robots AI policy, Product structured data, sitemap, platform, HTTPS/canonical."
+readme = "PYPI_README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Cyan Eclipse Technologies LLC" },
+]
+keywords = ["agent-readiness", "storefront", "e-commerce", "ci", "audit", "mcp"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.urls]
+Homepage = "https://cetech.ai"
+Repository = "https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/agent-ready-mcp"
+Vendor = "https://cetech.ai"
+
+[project.scripts]
+eclipse-agentready = "eclipse_agentready.cli:main"
+
+# Version source of truth: VERSION, kept in lockstep with the engine's
+# __version__ by tests/test_cli.py (drift = failing test).
+[tool.setuptools.dynamic]
+version = { file = "VERSION" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

eclipse_agentready-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eclipse_agentready-0.1.0/src/eclipse_agentready/__init__.py

@@ -0,0 +1,8 @@
+# AgentReady · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""eclipse-agentready — the T6 CLI edition of AgentReady: the same
+certified storefront-audit engine as the AgentReady MCP server, in
+command-line form for CI pipelines. Audits *storefronts* for
+shopping-agent readiness — not repositories, not MCP servers."""
+from .engine import CHECKS, __version__, grade_for, run_audit, score_results
+
+__all__ = ["CHECKS", "__version__", "grade_for", "run_audit", "score_results"]

eclipse_agentready-0.1.0/src/eclipse_agentready/cli.py

@@ -0,0 +1,110 @@
+# AgentReady · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""`eclipse-agentready` — AgentReady as a CI artifact (slate T6).
+
+  eclipse-agentready audit <url> [--fail-under N] [--format json|text]
+                                 [--out PATH]
+  eclipse-agentready list-checks [--format json|text]
+  eclipse-agentready version
+
+Exit codes: audit — 0 when the audit completed and (no --fail-under
+given, or score >= N); 1 when score < --fail-under; 2 when the audit
+itself could not run (unreachable / unparseable target). The grade is
+a point-in-time public-surface observation, printed with its limits.
+"""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .engine import CHECKS, ToolError, __version__, run_audit
+
+SCOPE_FOOTER = (
+    "Scope: Public-surface audit only (no credentials, no checkout "
+    "execution). No authenticated checkout execution — this tool never "
+    "logs in, never buys, and cannot verify a full agent purchase. "
+    "Evidence is a point-in-time observation; storefronts change. "
+    "A grade is not an endorsement and not a Bazaar listing claim."
+)
+
+
+def _render_report(rep):
+    lines = [f"{rep['url']} — score {rep['score']}/100, grade {rep['grade']}"
+             f" (platform: {rep['platform']})"]
+    for c in rep["checks"]:
+        pts = "n/a" if c["points"] is None else f"{c['points']:g}/{c['weight']}"
+        lines.append(f"  [{c['status']:<4}] {c['id']:<26} {pts:<7} {c['evidence']}")
+    if rep["top_fixes"]:
+        lines.append("Top fixes:")
+        for f in rep["top_fixes"]:
+            lines.append(f"  - {f['check']}: {f['fix']}")
+    lines.append(SCOPE_FOOTER)
+    return "\n".join(lines)
+
+
+def _checks_payload():
+    return {"checks": [{"id": c["id"], "name": c["name"],
+                        "weight": c["weight"],
+                        "description": c["description"]} for c in CHECKS],
+            "total_weight": sum(c["weight"] for c in CHECKS),
+            "scoring": "pass = full weight, warn = half, fail = 0, "
+                       "na = excluded. Grade: A>=90 B>=75 C>=60 D>=40 F<40."}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="eclipse-agentready",
+        description="Audit a public storefront for AI shopping-agent "
+                    "readiness (UCP profile, live MCP endpoint, llms.txt, "
+                    "robots.txt AI policy, Product structured data, "
+                    "sitemap, platform, HTTPS/canonical). Storefronts "
+                    "only — this is not a repository or MCP-server grader.")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("audit", help="audit one storefront URL")
+    p.add_argument("url")
+    p.add_argument("--fail-under", type=int, default=None, metavar="N",
+                   help="exit 1 when the score is below N (CI gate)")
+    p.add_argument("--format", choices=("json", "text"), default="text")
+    p.add_argument("--out", default=None, metavar="PATH",
+                   help="also write the JSON report to this path")
+
+    p = sub.add_parser("list-checks", help="the check catalog + weights")
+    p.add_argument("--format", choices=("json", "text"), default="text")
+
+    sub.add_parser("version", help="print the package version")
+
+    args = ap.parse_args(argv)
+
+    if args.cmd == "version":
+        print(__version__)
+        return 0
+    if args.cmd == "list-checks":
+        payload = _checks_payload()
+        if args.format == "json":
+            print(json.dumps(payload, indent=1))
+        else:
+            for c in payload["checks"]:
+                print(f"  {c['id']:<26} {c['weight']:>3}  {c['name']}")
+            print(f"Total weight: {payload['total_weight']}. "
+                  f"{payload['scoring']}")
+        return 0
+    if args.cmd == "audit":
+        try:
+            rep = run_audit(args.url)
+        except ToolError as e:
+            print(f"audit failed: {e}", file=sys.stderr)
+            return 2
+        if args.out:
+            Path(args.out).write_text(json.dumps(rep, indent=1) + "\n")
+        if args.format == "json":
+            print(json.dumps(rep, indent=1))
+        else:
+            print(_render_report(rep))
+        if args.fail_under is not None and rep["score"] < args.fail_under:
+            return 1
+        return 0
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

eclipse_agentready-0.1.0/src/eclipse_agentready/engine.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python3
+# AgentReady MCP
+# Copyright © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+
+"""AgentReady MCP — v0.1.0 reference implementation.
+
+Powered by Cyan Eclipse Technologies (cetech.ai).
+
+What it does: audits a public storefront for AI-agent readiness — can a
+shopping agent (ChatGPT, Claude, Perplexity, Gemini…) discover this store,
+read its catalog in machine-readable form, and get correct price/stock
+data? Research context: only ~36% of US storefronts can complete an agent
+purchase end-to-end (InMobi, Oct 2026); 95% of merchants already see agent
+traffic but only ~20% have machine-readable catalogs (PayPal-cited data).
+
+SCOPE (honest): public-surface audit only. Every check reads public
+endpoints with no credentials — UCP profile, MCP endpoints, llms.txt,
+robots.txt, structured data, sitemap. It does NOT execute an authenticated
+checkout, does NOT log in anywhere, and collects no private data.
+
+Transport: MCP over stdio (newline-delimited JSON-RPC 2.0), stdlib only.
+The audit engine is also importable (audit_storefront()) for batch use.
+"""
+import json
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+__version__ = "0.1.0"
+
+UA = f"AgentReadyMCP/{__version__} (+https://cetech.ai) public readiness audit"
+TIMEOUT = 10
+MAX_BODY = 1_500_000
+
+AI_BOTS = ["GPTBot", "ClaudeBot", "PerplexityBot", "ChatGPT-User", "Google-Extended"]
+
+
+class ToolError(Exception):
+    pass
+
+
+# --------------------------------------------------------------------- http
+def fetch(url, method="GET", data=None, headers=None, timeout=TIMEOUT):
+    """Returns dict(status, final_url, headers, body_text, error).
+    Never raises for HTTP errors; network errors land in `error`."""
+    req = urllib.request.Request(url, data=data, method=method)
+    req.add_header("User-Agent", UA)
+    req.add_header("Accept", "*/*")
+    for k, v in (headers or {}).items():
+        req.add_header(k, v)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            chunks, total = [], 0
+            try:
+                while total < MAX_BODY:  # slow pages: keep partial body, don't fail
+                    chunk = resp.read(65536)
+                    if not chunk:
+                        break
+                    chunks.append(chunk)
+                    total += len(chunk)
+            except Exception:
+                pass
+            return {"status": resp.status, "final_url": resp.geturl(),
+                    "headers": dict(resp.headers.items()),
+                    "body": b"".join(chunks).decode("utf-8", errors="replace"), "error": None}
+    except urllib.error.HTTPError as e:
+        try:
+            raw = e.read(MAX_BODY)
+            body = raw.decode("utf-8", errors="replace")
+        except Exception:
+            body = ""
+        return {"status": e.code, "final_url": e.geturl() if hasattr(e, "geturl") else url,
+                "headers": dict(e.headers.items()) if e.headers else {},
+                "body": body, "error": None}
+    except Exception as e:
+        return {"status": None, "final_url": url, "headers": {}, "body": "",
+                "error": f"{type(e).__name__}: {e}"}
+
+
+def norm_url(raw):
+    u = str(raw or "").strip()
+    if not u:
+        raise ToolError("url is required")
+    if not re.match(r"^https?://", u, re.I):
+        u = "https://" + u
+    p = urllib.parse.urlparse(u)
+    if not p.netloc:
+        raise ToolError(f"could not parse host from url: {raw}")
+    return urllib.parse.urlunparse((p.scheme, p.netloc, p.path or "/", "", p.query, ""))
+
+
+def origin_of(url):
+    p = urllib.parse.urlparse(url)
+    return f"{p.scheme}://{p.netloc}"
+
+
+# ------------------------------------------------------------------- checks
+# Each check returns (status, evidence, fix_hint); status in pass/warn/fail/na.
+CHECKS = [
+    {"id": "ucp_profile", "weight": 15,
+     "name": "UCP profile published (/.well-known/ucp)",
+     "description": "A Universal Commerce Protocol profile tells agents which commerce services (catalog, checkout) the store exposes and where. Pass = valid JSON profile served at /.well-known/ucp."},
+    {"id": "mcp_endpoint", "weight": 20,
+     "name": "Live MCP endpoint answers JSON-RPC",
+     "description": "An MCP server endpoint (Shopify /api/mcp or /api/ucp/mcp, or generic /mcp) that answers an initialize ping. Pass = JSON-RPC result with server info; warn = endpoint exists but is gated/errors; fail = no MCP endpoint found."},
+    {"id": "llms_txt", "weight": 8,
+     "name": "llms.txt present",
+     "description": "An llms.txt file gives LLM crawlers a curated map of the store. Pass = HTTP 200 with non-empty content at /llms.txt."},
+    {"id": "robots_ai_policy", "weight": 10,
+     "name": "robots.txt allows AI crawlers",
+     "description": "If GPTBot / ClaudeBot / PerplexityBot are disallowed in robots.txt, those agents cannot legally crawl the catalog. Pass = major AI bots allowed; warn = partially blocked or no robots.txt; fail = all major AI bots blocked."},
+    {"id": "product_structured_data", "weight": 20,
+     "name": "Product structured data (JSON-LD with price + availability)",
+     "description": "Agents read JSON-LD Product markup to extract price and stock without guessing from page text. Pass = a product page carries Product JSON-LD with offers.price and offers.availability; warn = Product markup present but incomplete; fail = none found."},
+    {"id": "sitemap", "weight": 10,
+     "name": "Sitemap present with product URLs",
+     "description": "A sitemap.xml lets agent crawlers enumerate the catalog. Pass = sitemap served and product URLs present; warn = sitemap served but no recognizable product URLs; fail = no sitemap."},
+    {"id": "platform_detection", "weight": 5,
+     "name": "Platform identified",
+     "description": "Platform fingerprint (Shopify / WooCommerce / Wix / BigCommerce / Squarespace / Adobe Commerce / custom) from response headers and HTML markers. Informs which native agent features the store can switch on. Pass = identified."},
+    {"id": "https_canonical", "weight": 12,
+     "name": "HTTPS + canonical sanity",
+     "description": "Agents and crawlers need one canonical HTTPS URL per page. Pass = site served over HTTPS and homepage declares a rel=canonical on the same host; warn = HTTPS ok but canonical missing/mismatched; fail = not served over HTTPS."},
+]
+CHECK_BY_ID = {c["id"]: c for c in CHECKS}
+
+
+def check_ucp(origin):
+    r = fetch(origin + "/.well-known/ucp")
+    if r["status"] == 200:
+        try:
+            doc = json.loads(r["body"])
+            keys = sorted(doc.keys())[:8]
+            has_ucp = "ucp" in doc or "services" in doc or "capabilities" in doc
+            if has_ucp:
+                return "pass", f"GET /.well-known/ucp -> 200, JSON profile keys: {keys}", None
+            return "warn", f"GET /.well-known/ucp -> 200 JSON but no ucp/services/capabilities keys (keys: {keys})", \
+                "Publish a UCP profile describing your catalog/checkout services at /.well-known/ucp."
+        except Exception:
+            return "warn", "GET /.well-known/ucp -> 200 but body is not valid JSON", \
+                "Serve a valid JSON UCP profile at /.well-known/ucp."
+    return "fail", f"GET /.well-known/ucp -> {r['status'] or r['error']}", \
+        "Publish a UCP profile at /.well-known/ucp (Shopify exposes one via its UCP catalog support; other platforms can hand-serve the JSON document)."
+
+
+def _mcp_ping(url):
+    payload = json.dumps({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                          "params": {"protocolVersion": "2025-03-26", "capabilities": {},
+                                     "clientInfo": {"name": "agent-ready-mcp", "version": "0.1.0"}}}).encode()
+    r = fetch(url, method="POST", data=payload,
+              headers={"Content-Type": "application/json", "Accept": "application/json, text/event-stream"})
+    body = r["body"] or ""
+    doc = None
+    try:
+        doc = json.loads(body)
+    except Exception:
+        for line in body.splitlines():  # SSE framing
+            if line.startswith("data:"):
+                try:
+                    doc = json.loads(line[5:].strip())
+                    break
+                except Exception:
+                    pass
+    return r, doc
+
+
+def check_mcp(origin, platform):
+    candidates = ["/api/ucp/mcp", "/api/mcp", "/mcp"]
+    if platform == "woocommerce":
+        candidates = ["/wp-json/mcp", "/mcp"] + candidates
+    seen = []
+    for path in candidates:
+        r, doc = _mcp_ping(origin + path)
+        st = r["status"]
+        if doc and isinstance(doc, dict) and "result" in doc:
+            info = (doc["result"] or {}).get("serverInfo", {})
+            seen.append(f"{path} -> JSON-RPC result (server: {info.get('name', 'unknown')} {info.get('version', '')})".strip())
+            return "pass", "; ".join(seen), None
+        if doc and isinstance(doc, dict) and "error" in doc:
+            seen.append(f"{path} -> HTTP {st}, JSON-RPC error response (endpoint exists)")
+            return "warn", "; ".join(seen), \
+                "An MCP endpoint exists but returned a protocol error to a standard initialize ping — test it with a real agent client and fix the handshake."
+        if st in (401, 403, 405, 406):
+            seen.append(f"{path} -> HTTP {st} (endpoint likely exists, gated)")
+            return "warn", "; ".join(seen), \
+                "An endpoint answers at an MCP path but refuses anonymous pings — confirm public catalog tools are reachable without auth, or document the auth flow for agents."
+        seen.append(f"{path} -> {st or r['error']}")
+    return "fail", "; ".join(seen), \
+        "Expose a public MCP endpoint for catalog search/product lookup (Shopify: enable the Storefront/UCP Catalog MCP; WooCommerce: enable the MCP abilities adapter; other stacks: a hosted catalog MCP)."
+
+
+def check_llms(origin):
+    r = fetch(origin + "/llms.txt")
+    if r["status"] == 200 and len(r["body"].strip()) > 20:
+        first = r["body"].strip().splitlines()[0][:80]
+        return "pass", f"GET /llms.txt -> 200, {len(r['body'])} bytes, starts: {first!r}", None
+    return "fail", f"GET /llms.txt -> {r['status'] or r['error']}", \
+        "Publish /llms.txt: a short markdown map of your store, top categories and policies for LLM crawlers."
+
+
+def _robots_policy(body):
+    """Parse robots.txt -> {bot: 'blocked'|'allowed'} for AI_BOTS (crude but factual)."""
+    groups, current = [], []
+    for line in body.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.lower().startswith("user-agent:"):
+            if current and any(k.lower().startswith("disallow") for k, _ in current[1:]):
+                groups.append(current)
+            current = [(line.split(":", 1)[0].lower(), line.split(":", 1)[1].strip())]
+        elif current:
+            k, _, v = line.partition(":")
+            current.append((k.strip().lower(), v.strip()))
+    if current:
+        groups.append(current)
+    policy = {}
+    for bot in AI_BOTS:
+        blocked = None
+        for g in groups:
+            agents = [v.lower() for k, v in g if k == "user-agent"]
+            rules = [(k, v) for k, v in g if k in ("allow", "disallow")]
+            if bot.lower() in agents or "*" in agents:
+                for k, v in rules:
+                    if k == "disallow" and v == "/":
+                        blocked = True
+                    if k == "allow" and v == "/":
+                        blocked = False
+        policy[bot] = "blocked" if blocked else "allowed"
+    return policy
+
+
+def check_robots(origin):
+    r = fetch(origin + "/robots.txt")
+    if r["status"] != 200 or not r["body"].strip():
+        return "warn", f"GET /robots.txt -> {r['status'] or r['error']} (no robots policy published)", \
+            "Publish a robots.txt that explicitly allows GPTBot, ClaudeBot and PerplexityBot on catalog paths."
+    policy = _robots_policy(r["body"])
+    blocked = [b for b, v in policy.items() if v == "blocked"]
+    ev = ", ".join(f"{b}: {v}" for b, v in policy.items())
+    if not blocked:
+        return "pass", f"robots.txt policy — {ev}", None
+    if len(blocked) >= 4:
+        return "fail", f"robots.txt policy — {ev}", \
+            "Your robots.txt blocks the major AI crawlers outright — those agents cannot see your catalog. Allow GPTBot, ClaudeBot and PerplexityBot at least on product/category paths."
+    return "warn", f"robots.txt policy — {ev}", \
+        f"Some AI crawlers are blocked ({', '.join(blocked)}). If that is not deliberate, allow them on catalog paths."
+
+
+def _jsonld_docs(html_text):
+    docs = []
+    for m in re.finditer(r'<script[^>]+type=["\']application/ld\+json["\'][^>]*>(.*?)</script>',
+                         html_text, re.I | re.S):
+        try:
+            docs.append(json.loads(m.group(1).strip()))
+        except Exception:
+            pass
+    return docs
+
+
+def _products_in(docs):
+    found = []
+
+    def walk(node):
+        if isinstance(node, dict):
+            t = node.get("@type")
+            if t == "Product" or (isinstance(t, list) and "Product" in t):
+                found.append(node)
+            for v in node.values():
+                walk(v)
+        elif isinstance(node, list):
+            for v in node:
+                walk(v)
+
+    for d in docs:
+        walk(d)
+    return found
+
+
+def _product_page_url(home_html, origin, sitemap_urls):
+    for m in re.finditer(r'href=["\']([^"\']+)["\']', home_html, re.I):
+        href = m.group(1)
+        if re.search(r"/products?/", href):
+            return urllib.parse.urljoin(origin + "/", href)
+    for u in sitemap_urls:
+        if re.search(r"/products?/", u):
+            return u
+    return None
+
+
+def check_structured_data(home, origin, sitemap_urls):
+    home_products = _products_in(_jsonld_docs(home["body"]))
+    purl = _product_page_url(home["body"], origin, sitemap_urls)
+    target, label = home, "homepage"
+    if purl:
+        pr = fetch(purl)
+        if pr["status"] == 200:
+            target, label = pr, f"product page {purl}"
+    prods = _products_in(_jsonld_docs(target["body"]))
+    if not prods and target is not home:
+        prods = home_products
+        label = "homepage (product page had none)"
+    if not prods:
+        return "fail", f"No JSON-LD Product found on homepage" + (f" or {purl}" if purl else " (no product link discovered)"), \
+            "Add JSON-LD Product markup (name, offers.price, offers.priceCurrency, offers.availability) to every product page — most platforms do this via their SEO/schema settings or a schema app."
+    p = prods[0]
+    offers = p.get("offers") or {}
+    if isinstance(offers, list):
+        offers = offers[0] if offers else {}
+    has_price = bool(offers.get("price") or offers.get("lowPrice"))
+    has_avail = bool(offers.get("availability"))
+    ev = (f"{label}: Product JSON-LD for {p.get('name', 'unnamed')!r}; "
+          f"price={'yes' if has_price else 'no'}, availability={'yes' if has_avail else 'no'}")
+    if has_price and has_avail:
+        return "pass", ev, None
+    return "warn", ev, \
+        "Your Product JSON-LD is missing price and/or availability in offers — agents then guess from page text and get it wrong. Emit both fields."
+
+
+def check_sitemap(origin):
+    r = fetch(origin + "/sitemap.xml")
+    if r["status"] != 200 or "<loc>" not in r["body"]:
+        return "fail", f"GET /sitemap.xml -> {r['status'] or r['error']}, no <loc> entries", \
+            "Publish a sitemap.xml (your platform generates one) and reference it in robots.txt.", []
+    urls = re.findall(r"<loc>([^<]+)</loc>", r["body"])
+    followed = ""
+    if "<sitemapindex" in r["body"]:  # index file: sample children for product URLs
+        children = urls[:]
+        urls = []
+        for child in children[:3]:
+            cr = fetch(child)
+            if cr["status"] == 200:
+                urls += re.findall(r"<loc>([^<]+)</loc>", cr["body"])
+        followed = f" (index of {len(children)} children, sampled {min(3, len(children))})"
+    prod = [u for u in urls if re.search(r"/products?/", u)]
+    ev = f"sitemap.xml -> 200{followed}, {len(urls)} URLs sampled, {len(prod)} product-pattern URLs"
+    if prod:
+        return "pass", ev, None, urls
+    return "warn", ev, \
+        "Your sitemap sample has no recognizable product URLs — make sure product pages are included so agent crawlers can enumerate the catalog.", urls
+
+
+def detect_platform(home):
+    """Strong markers only — a comparison page merely *mentioning* a rival
+    platform must not fingerprint the store (learned on woocommerce.com)."""
+    html_l = home["body"][:400_000].lower()
+    hdr_names = [k.lower() for k in home["headers"].keys()]
+    hdr_blob = " ".join(f"{k.lower()}:{v.lower()}" for k, v in home["headers"].items())
+    if "cdn.shopify.com" in html_l or "myshopify.com" in html_l or \
+            any(h.startswith("x-shopify") for h in hdr_names):
+        return "shopify", "cdn.shopify.com / x-shopify header marker"
+    if "plugins/woocommerce" in html_l or "/woocommerce/assets" in html_l or "wc-blocks" in html_l:
+        return "woocommerce", "WooCommerce plugin asset marker in HTML"
+    if "wixstatic.com" in html_l or any(h.startswith("x-wix") for h in hdr_names):
+        return "wix", "wixstatic.com / x-wix header marker"
+    if "mybigcommerce.com" in html_l or "cdn11.bigcommerce.com" in html_l:
+        return "bigcommerce", "BigCommerce CDN marker"
+    if "static1.squarespace.com" in html_l or "universal-js.squarespace.com" in html_l:
+        return "squarespace", "Squarespace CDN marker"
+    if "magento" in hdr_blob or "/mage/" in html_l:
+        return "adobe-commerce", "Magento marker in headers/assets"
+    if "wp-content" in html_l:
+        return "wordpress", "wp-content marker (WordPress, WooCommerce not confirmed)"
+    return "unknown/custom", "no known platform markers in homepage HTML/headers"
+
+
+def grade_for(score):
+    return "A" if score >= 90 else "B" if score >= 75 else "C" if score >= 60 else "D" if score >= 40 else "F"
+
+
+# --------------------------------------------------------------------- audit
+def run_audit(raw_url):
+    url = norm_url(raw_url)
+    started = time.time()
+    home = fetch(url)
+    if home["status"] is None:
+        raise ToolError(f"could not fetch {url}: {home['error']}")
+    origin = origin_of(home["final_url"])
+    platform, plat_ev = detect_platform(home)
+
+    results = {}
+    sm = check_sitemap(origin)
+    results["sitemap"] = (sm[0], sm[1], sm[2])
+    sm_urls = sm[3]
+
+    results["ucp_profile"] = check_ucp(origin)
+    results["mcp_endpoint"] = check_mcp(origin, platform)
+    results["llms_txt"] = check_llms(origin)
+    results["robots_ai_policy"] = check_robots(origin)
+    results["product_structured_data"] = check_structured_data(home, origin, sm_urls)
+    results["platform_detection"] = ("pass" if platform != "unknown/custom" else "warn",
+                                     f"detected: {platform} ({plat_ev})",
+                                     None if platform != "unknown/custom" else
+                                     "No platform fingerprint found — if you run a custom stack, make sure the UCP/MCP/structured-data checks above are covered by hand.")
+    # https + canonical
+    final = home["final_url"]
+    canon = re.search(r'<link[^>]+rel=["\']canonical["\'][^>]*href=["\']([^"\']+)', home["body"], re.I) or \
+        re.search(r'<link[^>]+href=["\']([^"\']+)["\'][^>]*rel=["\']canonical["\']', home["body"], re.I)
+    canon_url = canon.group(1) if canon else None
+    if not final.startswith("https://"):
+        results["https_canonical"] = ("fail", f"final URL is {final} (not HTTPS); canonical={canon_url}", \
+                                      "Serve the store over HTTPS and redirect all HTTP traffic to it.")
+    elif canon_url and urllib.parse.urlparse(canon_url).netloc == urllib.parse.urlparse(final).netloc:
+        results["https_canonical"] = ("pass", f"final URL {final}; canonical {canon_url} (same host)", None)
+    elif canon_url:
+        results["https_canonical"] = ("warn", f"final URL {final}; canonical {canon_url} (different host/scheme)", \
+                                      "Point rel=canonical at the same HTTPS host agents land on — cross-host canonicals confuse catalog indexing.")
+    else:
+        results["https_canonical"] = ("warn", f"final URL {final}; no rel=canonical on homepage", \
+                                      "Add rel=canonical tags so agents see one canonical URL per product instead of duplicates.")
+
+    checks_out, score, grade, top_fixes = score_results(results)
+    return {
+        "url": url, "final_url": home["final_url"], "platform": platform,
+        "score": score, "grade": grade,
+        "checks": checks_out,
+        "top_fixes": top_fixes,
+        "audited_in_s": round(time.time() - started, 1),
+        "scope": "Public-surface audit only (no credentials, no checkout execution).",
+        "auditor": f"AgentReady MCP {__version__} — Cyan Eclipse Technologies",
+    }
+
+
+def score_results(results):
+    """{check_id: (status, evidence, fix_hint)} -> (checks_out, score,
+    grade, top_fixes). The single scoring path: the MCP tool, the
+    eclipse-agentready CLI, and the recorded-evidence replays in the
+    test suite all score through here, so the surfaces can never
+    disagree on the same evidence (gate B2)."""
+    checks_out, earned, possible = [], 0.0, 0.0
+    for c in CHECKS:
+        st, ev, fx = results[c["id"]]
+        w = c["weight"]
+        if st == "na":
+            pts = None
+        else:
+            possible += w
+            pts = w if st == "pass" else (w * 0.5 if st == "warn" else 0)
+            earned += pts
+        checks_out.append({"id": c["id"], "name": c["name"], "status": st, "weight": w,
+                           "points": pts, "evidence": ev, "fix_hint": fx})
+    score = round(100 * earned / possible) if possible else 0
+    fixes = [c for c in checks_out if c["status"] in ("fail", "warn") and c["fix_hint"]]
+    fixes.sort(key=lambda c: -c["weight"])
+    return checks_out, score, grade_for(score), \
+        [{"check": f["id"], "fix": f["fix_hint"]} for f in fixes[:5]]
+
+
+# --------------------------------------------------------------------- tools
+def t_audit_storefront(args):
+    return run_audit(args.get("url", ""))
+
+
+def t_list_checks(args):
+    return {"checks": [{"id": c["id"], "name": c["name"], "weight": c["weight"],
+                        "description": c["description"]} for c in CHECKS],
+            "total_weight": sum(c["weight"] for c in CHECKS),
+            "scoring": "pass = full weight, warn = half, fail = 0, na = excluded. Grade: A>=90 B>=75 C>=60 D>=40 F<40."}
+
+
+TOOLS = {
+    "audit_storefront": (t_audit_storefront,
+                         "Audit a public storefront for AI-agent readiness: UCP profile, live MCP endpoint, llms.txt, robots.txt AI-crawler policy, Product structured data, sitemap, platform, HTTPS/canonical. Returns a 0-100 score, letter grade, per-check evidence and top fixes. Public endpoints only — no credentials.",
+                         {"url": {"type": "string"}}, ["url"]),
+    "list_checks": (t_list_checks,
+                    "List the readiness check catalog with weights and scoring rules.",
+                    {}, []),
+}
+
+
+def tool_list():
+    return [{"name": name,
+             "description": desc,
+             "inputSchema": {"type": "object", "properties": props, "required": req}}
+            for name, (_, desc, props, req) in TOOLS.items()]
+
+
+def handle(req: dict):
+    method, rid = req.get("method", ""), req.get("id")
+    if method == "initialize":
+        return {"jsonrpc": "2.0", "id": rid, "result": {
+            "protocolVersion": req.get("params", {}).get("protocolVersion", "2025-03-26"),
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": "agent-ready-mcp", "version": "0.1.0"}}}
+    if method == "ping":
+        return {"jsonrpc": "2.0", "id": rid, "result": {}}
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": rid, "result": {"tools": tool_list()}}
+    if method == "tools/call":
+        name = req["params"]["name"]
+        args = req["params"].get("arguments", {})
+        if name not in TOOLS:
+            return {"jsonrpc": "2.0", "id": rid, "error": {"code": -32602, "message": f"unknown tool {name}"}}
+        try:
+            out = TOOLS[name][0](args)
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "content": [{"type": "text", "text": json.dumps(out, indent=1)}]}}
+        except ToolError as e:
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "content": [{"type": "text", "text": json.dumps({"error": str(e)})}], "isError": True}}
+    if rid is not None:
+        return {"jsonrpc": "2.0", "id": rid, "error": {"code": -32601, "message": f"method not found: {method}"}}
+    return None  # notification
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            resp = handle(json.loads(line))
+        except Exception as e:  # never crash the transport
+            resp = {"jsonrpc": "2.0", "id": None, "error": {"code": -32603, "message": str(e)}}
+        if resp is not None:
+            sys.stdout.write(json.dumps(resp) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()
+
+# AgentReady MCP · © 2026 Cyan Eclipse Technologies LLC · cetech.ai

eclipse_agentready-0.1.0/src/eclipse_agentready.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: eclipse-agentready
+Version: 0.1.0
+Summary: AgentReady (T6 CLI edition) — audit a public storefront for AI shopping-agent readiness from CI: UCP profile, live MCP endpoint, llms.txt, robots AI policy, Product structured data, sitemap, platform, HTTPS/canonical.
+Author: Cyan Eclipse Technologies LLC
+License: MIT
+Project-URL: Homepage, https://cetech.ai
+Project-URL: Repository, https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/agent-ready-mcp
+Project-URL: Vendor, https://cetech.ai
+Keywords: agent-readiness,storefront,e-commerce,ci,audit,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# eclipse-agentready
+
+**What this is:** `eclipse-agentready` audits **storefronts** — public
+e-commerce sites — for AI shopping-agent readiness: can an agent
+(ChatGPT, Claude, Perplexity, Gemini…) discover the store, read its
+catalog in machine-readable form, and get correct price/stock data?
+
+**What this is not:** it does **not** audit repositories, and it does
+**not** grade MCP servers. (The unrelated PyPI project named
+`agentready` scores *code repositories* for AI-assisted development —
+a different tool for a different job. This one is the CLI edition of
+Cyan Eclipse Technologies' **AgentReady** storefront auditor, also
+available as an MCP server.)
+
+## Use — a CI step for merchants and storefront DevOps
+
+```console
+$ pip install eclipse-agentready
+$ eclipse-agentready audit https://shop.example --fail-under 60
+$ eclipse-agentready audit https://shop.example --format json --out report.json
+$ eclipse-agentready list-checks
+```
+
+Exit codes: `0` = audit completed and (if `--fail-under N` given) the
+score is at least N · `1` = score below N · `2` = the audit itself
+could not run.
+
+## The 8 checks (weights sum to 100)
+
+| Check | Weight |
+|---|---|
+| Live MCP endpoint answers JSON-RPC | 20 |
+| Product structured data (JSON-LD with price + availability) | 20 |
+| UCP profile published (/.well-known/ucp) | 15 |
+| HTTPS + canonical sanity | 12 |
+| robots.txt allows AI crawlers | 10 |
+| Sitemap present with product URLs | 10 |
+| llms.txt present | 8 |
+| Platform identified | 5 |
+
+Scoring: pass = full weight, warn = half, fail = 0, n/a = excluded.
+Grade: A ≥ 90 · B ≥ 75 · C ≥ 60 · D ≥ 40 · F < 40. Every check reports
+observed evidence only, plus a concrete fix hint when it does not fully
+pass. The CLI and the MCP server run the *identical* check catalog and
+scoring path — same evidence in, same grade out.
+
+## Honest scope
+
+- **Public-surface audit only.** All checks read public endpoints with
+  no credentials, a declared user agent, 10s timeouts, and redirect
+  following.
+- **No authenticated checkout execution** — this tool never logs in,
+  never buys, and cannot verify a full agent purchase. A store can
+  score well here and still fail at the checkout step (and vice versa).
+- **No private data** is collected or stored; audit output is the
+  caller's. Evidence is a point-in-time observation; storefronts change.
+- A grade is not an endorsement and not a Bazaar listing claim.
+
+The merchant's path to agent-commerce readiness starts with a grade
+you can watch: run it in CI on every deploy. A hosted monitoring tier
+(scheduled re-audits, score-change alerts) is on the product roadmap
+and is **not yet launched**.
+
+Powered by Cyan Eclipse Technologies LLC (cetech.ai) — a Veteran-Owned
+Small Business. MIT licensed. Not affiliated with Shopify, WooCommerce,
+Automattic, or any audited store; platform names describe detection
+results only.

eclipse_agentready-0.1.0/src/eclipse_agentready.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+PYPI_README.md
+README.md
+VERSION
+pyproject.toml
+src/eclipse_agentready/__init__.py
+src/eclipse_agentready/cli.py
+src/eclipse_agentready/engine.py
+src/eclipse_agentready.egg-info/PKG-INFO
+src/eclipse_agentready.egg-info/SOURCES.txt
+src/eclipse_agentready.egg-info/dependency_links.txt
+src/eclipse_agentready.egg-info/entry_points.txt
+src/eclipse_agentready.egg-info/top_level.txt
+tests/test_cli.py

eclipse_agentready-0.1.0/src/eclipse_agentready.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eclipse_agentready-0.1.0/src/eclipse_agentready.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eclipse-agentready = eclipse_agentready.cli:main

eclipse_agentready-0.1.0/src/eclipse_agentready.egg-info/top_level.txt

@@ -0,0 +1 @@
+eclipse_agentready

eclipse_agentready-0.1.0/tests/test_cli.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+# AgentReady — T6 CLI edition tests (gate B1–B4, B-M1 known-answer).
+# Copyright © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""The CLI is the same engine in CI dress:
+  * list-checks serves the identical catalog as the MCP list_checks;
+  * recorded check-level evidence replays through the CLI's scoring
+    path to the identical score/grade/top_fixes — for the three
+    recorded storefront reports AND the cetech.ai known-answer fixture
+    (live-audited 2026-10-26; its known band is F — if the CLI ever
+    returns a pass band for cetech.ai's evidence, the CLI is broken,
+    not the site healed);
+  * a deterministic bare-storefront fixture over local HTTP exercises
+    the full audit path incl. --fail-under exit codes;
+  * name/scope law: VERSION == engine __version__; the PyPI readme
+    carries the B1 disambiguation; B4's forbidden framing appears in
+    no shipped surface.
+"""
+import json
+import sys
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from eclipse_agentready import CHECKS, __version__, score_results  # noqa: E402
+from eclipse_agentready import cli  # noqa: E402
+
+
+def replay(rep):
+    results = {c["id"]: (c["status"], c["evidence"], c["fix_hint"])
+               for c in rep["checks"]}
+    checks_out, score, grade, top_fixes = score_results(results)
+    assert score == rep["score"], (score, rep["score"])
+    assert grade == rep["grade"], (grade, rep["grade"])
+    assert top_fixes == rep["top_fixes"]
+    assert checks_out == rep["checks"]
+
+
+class KnownAnswer(unittest.TestCase):
+    def test_recorded_reports_replay_exactly(self):
+        for name in ("gymshark", "woocommerce", "thewhitereport"):
+            rep = json.loads((ROOT / "results" / f"{name}.json").read_text())
+            replay(rep)
+
+    def test_cetech_known_answer_band(self):
+        rep = json.loads((ROOT / "tests/fixtures"
+                          / "cetech-ai-live-2026-10-26.json").read_text())
+        replay(rep)
+        self.assertEqual(rep["grade"], "F")   # the known band
+        self.assertLess(rep["score"], 40)
+
+
+class _BareHandler(BaseHTTPRequestHandler):
+    def _reply(self):
+        if self.path == "/":
+            body = b"<html><head><title>bare</title></head><body>hi</body></html>"
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self.send_response(404)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+
+    do_GET = _reply
+    do_POST = _reply
+
+    def log_message(self, *a):
+        pass
+
+
+class BareFixtureAudit(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.httpd = ThreadingHTTPServer(("127.0.0.1", 0), _BareHandler)
+        cls.port = cls.httpd.server_address[1]
+        threading.Thread(target=cls.httpd.serve_forever, daemon=True).start()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.httpd.shutdown()
+
+    def test_bare_storefront_scores_f(self):
+        import io
+        from contextlib import redirect_stdout
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = cli.main(["audit", f"http://127.0.0.1:{self.port}",
+                           "--format", "json"])
+        self.assertEqual(rc, 0)  # no --fail-under: completion is success
+        rep = json.loads(buf.getvalue())
+        self.assertEqual(rep["grade"], "F")
+        self.assertEqual(rep["score"], 8)  # robots warn 5 + platform warn 2.5
+        self.assertEqual([c["id"] for c in rep["checks"]],
+                         [c["id"] for c in CHECKS])
+
+    def test_fail_under_exit_code(self):
+        import io
+        from contextlib import redirect_stdout
+        with redirect_stdout(io.StringIO()):
+            rc = cli.main(["audit", f"http://127.0.0.1:{self.port}",
+                           "--fail-under", "60"])
+        self.assertEqual(rc, 1)
+
+    def test_unreachable_target_exit_2(self):
+        rc = cli.main(["audit", "http://127.0.0.1:9/nowhere"])
+        self.assertEqual(rc, 2)
+
+
+class CatalogAndLaw(unittest.TestCase):
+    def test_list_checks_matches_engine(self):
+        payload = cli._checks_payload()
+        self.assertEqual([(c["id"], c["weight"]) for c in payload["checks"]],
+                         [(c["id"], c["weight"]) for c in CHECKS])
+        self.assertEqual(payload["total_weight"], 100)
+
+    def test_version_lockstep(self):
+        self.assertEqual((ROOT / "VERSION").read_text().strip(), __version__)
+        text = (ROOT / "pyproject.toml").read_text()
+        self.assertIn('name = "eclipse-agentready"', text)
+        self.assertIn('version = { file = "VERSION" }', text)
+
+    def test_disambiguation_and_no_forbidden_framing(self):
+        readme = (ROOT / "PYPI_README.md").read_text()
+        flat = " ".join(readme.split())  # unwrap hard-wrapped lines
+        self.assertIn("does **not** grade MCP servers", flat)
+        self.assertIn("not** audit repositories", flat)
+        for surface in (readme, Path(cli.__file__).read_text()):
+            self.assertNotIn("registry submission", surface.lower())
+            self.assertNotIn("submit your server", surface.lower())
+
+    def test_scope_footer_travels(self):
+        self.assertIn("Public-surface audit only", cli.SCOPE_FOOTER)
+        self.assertIn("never logs in, never buys", cli.SCOPE_FOOTER)
+        self.assertIn("not an endorsement", cli.SCOPE_FOOTER)
+
+
+if __name__ == "__main__":
+    unittest.main()