eclipse-bazaar 0.1.0__py3-none-any.whl

eclipse_bazaar/__init__.py

@@ -0,0 +1,15 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""eclipse-bazaar — one distribution, three surfaces (gate A5):
+
+  * the Eclipse Bazaar MCP server (console script: eclipse-bazaar)
+  * the `bazaar` CLI (search / product / categories / check)
+  * the Python SDK (from eclipse_bazaar import Bazaar)
+
+Catalog data ships as a stamped bundled snapshot; verdict summaries
+ship as a hash-pinned verdict snapshot (gate A1). Powered by Cyan
+Eclipse Technologies (cetech.ai).
+"""
+from ._version import __version__
+from .client import Bazaar
+
+__all__ = ["__version__", "Bazaar"]

eclipse_bazaar/_version.py

@@ -0,0 +1,2 @@
+# GENERATED by tools/sync_version.py from server.json — do not edit.
+__version__ = "0.1.0"

eclipse_bazaar/catalog.py

@@ -0,0 +1,166 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""Data access for the eclipse-bazaar distribution.
+
+Resolution order (first hit wins):
+  catalog   $BAZAAR_CATALOG -> repo-root catalog.json (repo mode only,
+            kept canonical by sync_verdicts.py) -> bundled
+            data/catalog.json
+  corpus    see eclipse_bazaar.check (bulk file, sha256-verified)
+  scorecard bundled verdict snapshot first (stamped + hash-pinned by
+            tools/make_verdict_snapshot.py); repo mode falls back to the
+            live Test Bench card when the snapshot lacks the ref.
+
+Gate A1: packaged mode never reaches for ../test-bench/results/ — the
+snapshot is the only verdict source an installed wheel needs.
+
+Repo mode is a proven state, not a path-existence guess (PY-D1): it
+holds only inside the bazaar-mcp checkout itself (its own markers —
+.git and server.json at the repo root) or when BAZAAR_REPO_MODE=1 is
+set explicitly. An installed wheel is snapshot-only by construction:
+files planted at the computed install-tree levels are never served.
+"""
+import json
+import os
+import urllib.request
+from pathlib import Path
+
+PKG_DIR = Path(__file__).resolve().parent
+DATA_DIR = PKG_DIR / "data"
+REPO_ROOT = PKG_DIR.parents[1]   # dev layout: bazaar-mcp/ (site-packages when installed)
+CETECH_DIR = PKG_DIR.parents[2]  # dev layout: cyan-eclipse/ (meaningless when installed)
+
+REFRESH_URLS = [
+    "https://raw.githubusercontent.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/bazaar-mcp/main/catalog.json",
+]
+
+_LAST_SOURCE = "bundled snapshot"
+_SNAPSHOT = None
+
+
+def _repo_mode() -> bool:
+    """True only in the bazaar-mcp checkout itself (proven by its own
+    markers) or under an explicit BAZAAR_REPO_MODE=1 opt-in. This gates
+    both repo-mode fallbacks below; an installed wheel never satisfies
+    it by accident of the install layout (PY-D1)."""
+    if os.environ.get("BAZAAR_REPO_MODE") == "1":
+        return True
+    return (REPO_ROOT / ".git").exists() and \
+        (REPO_ROOT / "server.json").exists()
+
+
+def catalog_path() -> Path:
+    env = os.environ.get("BAZAAR_CATALOG")
+    if env:
+        return Path(env)
+    repo_cat = REPO_ROOT / "catalog.json"
+    if _repo_mode() and repo_cat.exists():
+        return repo_cat
+    return DATA_DIR / "catalog.json"
+
+
+def fetch_catalog(url: str, timeout: int = 15) -> dict:
+    req = urllib.request.Request(url, headers={"Accept": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def catalog_dict(refresh: bool = False) -> dict:
+    """The catalog as a dict. refresh=True tries the public HTTPS JSON
+    source first (one bulk document — never per-product queries) and
+    falls back to the local snapshot on any failure."""
+    global _LAST_SOURCE
+    if refresh:
+        for url in REFRESH_URLS:
+            try:
+                cat = fetch_catalog(url)
+                if isinstance(cat, dict) and "products" in cat:
+                    _LAST_SOURCE = f"refreshed from {url}"
+                    return cat
+            except Exception:
+                continue
+    path = catalog_path()
+    cat = json.loads(path.read_text())
+    _LAST_SOURCE = ("repo catalog.json" if path == REPO_ROOT / "catalog.json"
+                    else "bundled snapshot")
+    return cat
+
+
+def freshness(cat: dict) -> dict:
+    return {"catalog_built": cat.get("built"),
+            "sources": cat.get("sources", []),
+            "served_from": _LAST_SOURCE,
+            "note": "Statuses and verdicts are as of the catalog build date; "
+                    "scorecard summaries come from the stamped verdict "
+                    "snapshot bundled with this package (hash-pinned to the "
+                    "Test Bench cards), or the referenced card in repo mode."}
+
+
+# ------------------------------------------------------------ scorecards
+def _check_rows(sc: dict):
+    """Normalise the three Test Bench card shapes to (name, verdict):
+    list-of-dicts (original), dict-of-results (later cards), and
+    checks-absent (scoped re-bench cards -> no rows)."""
+    checks = sc.get("checks")
+    if isinstance(checks, list):
+        for ch in checks:
+            if isinstance(ch, dict):
+                yield ch.get("name"), ch.get("verdict", "other")
+    elif isinstance(checks, dict):
+        for name, res in checks.items():
+            if isinstance(res, dict):
+                if "verdict" in res:
+                    yield name, res["verdict"]
+                elif "pass" in res:
+                    yield name, "pass" if res["pass"] else "fail"
+                else:
+                    yield name, "other"
+            else:
+                yield name, "other"
+
+
+def summarize_card(sc: dict) -> dict:
+    """Scorecard file -> the summary the server returns. Pure function —
+    tools/make_verdict_snapshot.py builds the snapshot with this exact
+    code, which is what makes packaged/repo parity testable. (The
+    pre-packaging server crashed on dict-shaped and checks-absent cards;
+    the summary for list-shaped cards is unchanged.)"""
+    counts = {"pass": 0, "fail": 0, "na": 0, "other": 0}
+    na_names, fail_names = [], []
+    total = 0
+    for name, v in _check_rows(sc):
+        total += 1
+        counts[v if v in counts else "other"] += 1
+        if v == "na":
+            na_names.append(name)
+        if v == "fail":
+            fail_names.append(name)
+    return {"tool": sc.get("tool") or sc.get("product"),
+            "version": sc.get("version"),
+            "bench_date": sc.get("bench_date") or sc.get("date"),
+            "bench_version": sc.get("bench_version"),
+            "environment": sc.get("environment"),
+            "verdict": sc.get("verdict"),
+            "checks_total": total, "counts": counts,
+            "not_tested_checks": na_names,
+            "failed_checks": fail_names}
+
+
+def load_snapshot():
+    global _SNAPSHOT
+    if _SNAPSHOT is None:
+        path = DATA_DIR / "verdict_snapshot.json"
+        _SNAPSHOT = json.loads(path.read_text()) if path.exists() else {}
+    return _SNAPSHOT
+
+
+def scorecard_summary(ref: str):
+    """Summary for a catalog scorecard_ref, or None if unavailable."""
+    snap = load_snapshot()
+    rec = (snap.get("cards") or {}).get(ref)
+    if rec is not None:
+        return rec["summary"]
+    if _repo_mode():
+        path = CETECH_DIR / ref  # the live Test Bench card, checkout only
+        if path.exists():
+            return summarize_card(json.loads(path.read_text()))
+    return None

eclipse_bazaar/check.py

@@ -0,0 +1,233 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""`bazaar check` — marketplace-standing check for configured MCP servers.
+
+Phase 1 (this build). Every configured server is classified into
+exactly one of four classes, from config text + the published Bazaar
+corpus only:
+
+  CERTIFIED    listed, with a Tier-2 Test Bench verdict on record
+  LISTED       in the catalog, no Tier-2 verdict (listing status shown)
+  NOT LISTED   no Bazaar record for the resolved identity (a neutral
+               fact — not a warning, not a failure)
+  UNRESOLVABLE no identity could be extracted from the config entry
+
+Later-phase vocabulary for not-yet-public record classes does not exist
+in this binary by construction: score/record fields for unpublished
+data classes are absent — not null, not stubbed, not behind a flag —
+and ship only in a later phase, once the underlying records themselves
+are public (the gate binds the data, not the channel).
+
+Fences (breach = gate K1): this module never executes a configured
+server, never reads a tool description, never contacts a configured
+server's endpoint, and never scores or ranks an unlisted server.
+There is deliberately no aggregate score over the report.
+
+Architecture (gate S1): the corpus is one bulk file, downloaded whole
+and sha256-verified against its manifest before use, then joined
+locally. Zero per-server queries leave the machine. The bundled corpus
+snapshot is the offline default; a per-name lookup mode does not exist.
+"""
+import hashlib
+import json
+import os
+import urllib.request
+from pathlib import Path
+
+from .catalog import DATA_DIR
+from .configparse import (default_config_paths, extract_identity,
+                          load_config_entries, unresolvable_reason)
+
+CERTIFIED = "CERTIFIED"
+LISTED = "LISTED"
+NOT_LISTED = "NOT LISTED"
+UNRESOLVABLE = "UNRESOLVABLE"
+CLASSES = (CERTIFIED, LISTED, NOT_LISTED, UNRESOLVABLE)
+
+CORPUS_BASE = ("https://raw.githubusercontent.com/"
+               "CYAN-ECLIPSE-TECHNOLOGIES-LLC/bazaar-mcp/main/corpus")
+CORPUS_URL = CORPUS_BASE + "/corpus.jsonl"
+MANIFEST_URL = CORPUS_BASE + "/corpus.manifest.json"
+
+
+class CorpusError(Exception):
+    pass
+
+
+# ---------------------------------------------------------------- corpus
+def _verify(raw: bytes, manifest: dict):
+    digest = hashlib.sha256(raw).hexdigest()
+    if manifest.get("sha256") != digest:
+        raise CorpusError(
+            f"corpus sha256 mismatch: manifest {manifest.get('sha256')}, "
+            f"downloaded {digest} — refusing unverified corpus")
+    return digest
+
+
+def _parse_corpus(raw: bytes):
+    records = []
+    for line in raw.decode("utf-8").splitlines():
+        line = line.strip()
+        if line:
+            records.append(json.loads(line))
+    return records
+
+
+def _bundled_corpus():
+    raw = (DATA_DIR / "corpus.jsonl").read_bytes()
+    manifest = json.loads((DATA_DIR / "corpus.manifest.json").read_text())
+    digest = _verify(raw, manifest)
+    return _parse_corpus(raw), {"source": "bundled snapshot",
+                                "sha256": digest, "manifest": manifest}
+
+
+def _download(url, timeout=20):
+    req = urllib.request.Request(url, headers={"Accept": "*/*"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return resp.read()
+
+
+def _refreshed_corpus():
+    manifest = json.loads(_download(MANIFEST_URL).decode("utf-8"))
+    raw = _download(CORPUS_URL)
+    digest = _verify(raw, manifest)
+    cache = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) \
+        / "eclipse-bazaar"
+    cache.mkdir(parents=True, exist_ok=True)
+    (cache / "corpus.jsonl").write_bytes(raw)
+    (cache / "corpus.manifest.json").write_text(json.dumps(manifest, indent=1))
+    return _parse_corpus(raw), {"source": f"refreshed from {CORPUS_URL}",
+                                "sha256": digest, "manifest": manifest}
+
+
+def load_corpus(corpus_path=None, refresh=False):
+    """(records, meta). Explicit local file wins; then refresh; the
+    bundled snapshot is the always-available fallback."""
+    if corpus_path:
+        raw = Path(corpus_path).read_bytes()
+        manifest_path = Path(str(corpus_path).replace(
+            "corpus.jsonl", "corpus.manifest.json"))
+        meta = {"source": f"local file {corpus_path}", "sha256": None,
+                "manifest": None}
+        if manifest_path.exists():
+            manifest = json.loads(manifest_path.read_text())
+            meta["sha256"] = _verify(raw, manifest)
+            meta["manifest"] = manifest
+            meta["source"] += " (sha256 verified against sibling manifest)"
+        return _parse_corpus(raw), meta
+    if refresh:
+        try:
+            return _refreshed_corpus()
+        except Exception as e:
+            records, meta = _bundled_corpus()
+            meta["refresh_error"] = f"{type(e).__name__}: {e}"
+            meta["source"] += " (refresh failed, bundled fallback)"
+            return records, meta
+    return _bundled_corpus()
+
+
+def build_index(records):
+    index = {}
+    for rec in records:
+        for ident in rec.get("identities", []):
+            index.setdefault(ident.lower(), rec)
+    return index
+
+
+# ------------------------------------------------------------ classify
+def classify(config_name, entry, index):
+    identity = extract_identity(entry)
+    if identity is None:
+        return {"config_name": config_name, "class": UNRESOLVABLE,
+                "identity": None,
+                "reason": unresolvable_reason(entry),
+                "listing": None, "drift": None, "version_note": None}
+    rec = index.get(identity["name"])
+    if rec is None and "/" in identity["name"]:
+        # Qualified reference (registry/owner image path, npm scope,
+        # remote authority): standing binds to the FULL qualified
+        # identity. A bare-name match under a foreign qualifier is a
+        # different source — never an inheritance path (PY-D3). It is
+        # reported NOT LISTED with the collision named, so the reader
+        # can tell an impersonation shape from an unknown name.
+        base = identity["name"].rsplit("/", 1)[-1]
+        base_rec = index.get(base)
+        if base_rec is not None:
+            hint = next((i for i in base_rec.get("identities", [])
+                         if "/" in i), base_rec["id"])
+            return {"config_name": config_name, "class": NOT_LISTED,
+                    "identity": identity,
+                    "reason": "no Bazaar listing record for this "
+                              f"identity; a product named {base!r} is "
+                              f"listed under a different source ({hint}) "
+                              "— standing does not transfer across "
+                              "registries, owners, or scopes",
+                    "listing": None, "drift": None, "version_note": None}
+    if rec is None:
+        return {"config_name": config_name, "class": NOT_LISTED,
+                "identity": identity,
+                "reason": "no Bazaar listing record for this identity",
+                "listing": None, "drift": None, "version_note": None}
+    cls = CERTIFIED if (rec.get("certified") and rec.get("bench_verdict")) else LISTED
+    drift = None
+    version_note = None
+    pin, listed = identity.get("pin"), rec.get("listing_version")
+    if pin and listed and pin != listed:
+        drift = {"pinned": pin, "listed": listed,
+                 "note": f"config pins version {pin}; the listing's current "
+                         f"version is {listed} — the tested standing below "
+                         f"belongs to the listed version"}
+    elif pin and not listed:
+        # The pin cannot be checked: the listing carries no version to
+        # check it against. Disclose, never imply verification (PY-D5).
+        version_note = ("version not checked: the listing carries no "
+                        "version, so the pin cannot be checked against it")
+    listing = {"id": rec["id"], "name": rec["name"], "status": rec["status"],
+               "bench_verdict": rec.get("bench_verdict"),
+               "certified_scope": rec.get("certified_scope"),
+               "listing_version": listed,
+               "scorecard_ref": rec.get("scorecard_ref"),
+               "listing_url": rec.get("listing_url")}
+    return {"config_name": config_name, "class": cls, "identity": identity,
+            "reason": None, "listing": listing, "drift": drift,
+            "version_note": version_note}
+
+
+def run_check(config_paths=None, corpus_path=None, refresh_corpus=False):
+    """The full Phase-1 check. Returns the report dict (no score —
+    counts per class only)."""
+    paths = [Path(p) for p in config_paths] if config_paths \
+        else default_config_paths()
+    records, corpus_meta = load_corpus(corpus_path, refresh_corpus)
+    index = build_index(records)
+    entries, file_notes = [], []
+    for path in paths:
+        loaded, error = load_config_entries(path)
+        if error:
+            file_notes.append({"config_file": str(path), "error": error})
+            continue
+        for name, entry in loaded:
+            row = classify(name, entry, index)
+            row["config_file"] = str(path)
+            entries.append(row)
+    summary = {c: 0 for c in CLASSES}
+    for row in entries:
+        summary[row["class"]] += 1
+    return {
+        "tool": "eclipse-bazaar check (phase 1)",
+        "corpus": {"records": len(records),
+                   "source": corpus_meta["source"],
+                   "sha256": corpus_meta["sha256"],
+                   "generated_at": (corpus_meta.get("manifest") or {}).get("generated_at"),
+                   "refresh_error": corpus_meta.get("refresh_error")},
+        "config_files": [str(p) for p in paths],
+        "file_notes": file_notes,
+        "summary": summary,
+        "entries": entries,
+        "notes": [
+            "Classes are facts about listing/verdict records, not safety "
+            "judgements. NOT LISTED is neutral: the Bazaar catalog v0.1 "
+            "covers Cyan Eclipse Technologies products.",
+            "env values in your configs were never read, copied, or "
+            "transmitted; the join ran locally against the bulk corpus.",
+        ],
+    }

eclipse_bazaar/cli.py

@@ -0,0 +1,178 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""`bazaar` command line — terminal face of the eclipse-bazaar SDK.
+
+  bazaar search <query> [--category C] [--refresh] [--json]
+  bazaar product <id> [--json]
+  bazaar categories [--json]
+  bazaar check [--config PATH ...] [--corpus PATH] [--refresh-corpus]
+               [--out PATH] [--json]
+  bazaar version
+
+`check` prints the config files it is about to read *before* reading
+them, and its report carries counts per class — never an aggregate
+score (see eclipse_bazaar.check for the Phase-1 fences).
+"""
+import argparse
+import json
+import sys
+
+from ._version import __version__
+from .check import run_check
+from .client import Bazaar
+from .configparse import default_config_paths
+
+
+def _emit(obj, as_json, render):
+    if as_json:
+        print(json.dumps(obj, indent=1))
+    else:
+        print(render(obj))
+
+
+def _render_search(res):
+    lines = [f"{res['count']} result(s) for {res['query']!r}:"]
+    for h in res["results"]:
+        cert = h["certification"]
+        badge = cert["bench_verdict"] or "no verdict on record"
+        lines.append(f"  {h['id']} — {h['name']} [{h['status']}] "
+                     f"({badge})")
+        lines.append(f"    {h['tagline']}")
+        for r in h["match_reasons"]:
+            lines.append(f"    · {r}")
+    return "\n".join(lines)
+
+
+def _render_product(res):
+    p = res["product"]
+    c = p["certification"]
+    lines = [f"{p['name']} ({p['id']}) — {p['status']}",
+             f"  {p['tagline']}",
+             f"  pricing: {p['pricing_model']}",
+             f"  categories: {', '.join(p['categories'])}",
+             f"  certification: {c['bench_verdict'] or 'NOT YET CERTIFIED'}",
+             "  capabilities:"]
+    lines += [f"    - {cap}" for cap in p["capabilities"]]
+    if c.get("not_tested"):
+        lines.append("  not tested:")
+        lines += [f"    - {n}" for n in c["not_tested"]]
+    return "\n".join(lines)
+
+
+def _render_categories(res):
+    lines = [f"{res['product_total']} products in "
+             f"{len(res['categories'])} categories:"]
+    for c in res["categories"]:
+        by = ", ".join(f"{k}={v}" for k, v in sorted(c["by_status"].items()))
+        lines.append(f"  {c['category']}: {c['total']} ({by})")
+    return "\n".join(lines)
+
+
+def _render_check(rep):
+    lines = [f"Corpus: {rep['corpus']['records']} listing records "
+             f"({rep['corpus']['source']}, sha256 "
+             f"{(rep['corpus']['sha256'] or 'n/a')[:16]}…)"]
+    for note in rep["file_notes"]:
+        lines.append(f"  ! {note['config_file']}: {note['error']}")
+    current = None
+    for e in rep["entries"]:
+        if e["config_file"] != current:
+            current = e["config_file"]
+            lines.append(f"\n{current}:")
+        ident = e["identity"]
+        idtxt = "—" if ident is None else \
+            f"{ident['kind']}:{ident['name']}" + \
+            (f"@{ident['pin']}" if ident.get("pin") else "")
+        lines.append(f"  {e['config_name']:<28} {e['class']:<13} {idtxt}")
+        if e["listing"]:
+            li = e["listing"]
+            verdict = li["bench_verdict"] or "no Tier-2 verdict"
+            lines.append(f"      -> {li['name']} [{li['status']}] — {verdict}")
+        if e["drift"]:
+            lines.append(f"      drift: {e['drift']['note']}")
+        if e.get("version_note"):
+            lines.append(f"      {e['version_note']}")
+        if e["reason"] and e["class"] in ("UNRESOLVABLE",):
+            lines.append(f"      reason: {e['reason']}")
+    s = rep["summary"]
+    lines.append("\nSummary: " + " · ".join(f"{k} {v}" for k, v in s.items()))
+    lines += [f"Note: {n}" for n in rep["notes"]]
+    return "\n".join(lines)
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="bazaar",
+        description="Eclipse Bazaar — Cyan Eclipse Technologies' catalog "
+                    "of tested MCP products: search it, inspect listings, "
+                    "and check your MCP client configs against it.")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("search", help="keyword search over the catalog")
+    p.add_argument("query")
+    p.add_argument("--category", default=None)
+    p.add_argument("--refresh", action="store_true",
+                   help="refresh the catalog (one bulk HTTPS fetch) first")
+    p.add_argument("--json", action="store_true")
+
+    p = sub.add_parser("product", help="full listing for one product id")
+    p.add_argument("id")
+    p.add_argument("--json", action="store_true")
+
+    p = sub.add_parser("categories", help="catalog categories + counts")
+    p.add_argument("--json", action="store_true")
+
+    p = sub.add_parser("check", help="classify your configured MCP servers "
+                                     "against the Bazaar corpus (phase 1)")
+    p.add_argument("--config", action="append", default=None,
+                   metavar="PATH", help="config file (repeatable); default: "
+                                        "discover known client locations")
+    p.add_argument("--corpus", default=None, metavar="PATH",
+                   help="local corpus.jsonl (default: bundled snapshot)")
+    p.add_argument("--refresh-corpus", action="store_true",
+                   help="download the current corpus + manifest and verify "
+                        "its sha256 before use")
+    p.add_argument("--out", default=None, metavar="PATH",
+                   help="also write the JSON report to this path")
+    p.add_argument("--json", action="store_true")
+
+    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 == "search":
+        bz = Bazaar(refresh=args.refresh)
+        _emit(bz.search(args.query, args.category), args.json, _render_search)
+        return 0
+    if args.cmd == "product":
+        _emit(Bazaar().get_listing(args.id), args.json, _render_product)
+        return 0
+    if args.cmd == "categories":
+        _emit(Bazaar().categories(), args.json, _render_categories)
+        return 0
+    if args.cmd == "check":
+        paths = args.config
+        if not paths:
+            found = default_config_paths()
+            print("Config files to read (discovered client locations):",
+                  file=sys.stderr)
+            for fp in found:
+                print(f"  {fp}", file=sys.stderr)
+            if not found:
+                print("  (none found — pass --config PATH)", file=sys.stderr)
+                return 2
+            paths = [str(fp) for fp in found]
+        rep = run_check(config_paths=paths, corpus_path=args.corpus,
+                        refresh_corpus=args.refresh_corpus)
+        if args.out:
+            from pathlib import Path
+            Path(args.out).write_text(json.dumps(rep, indent=1) + "\n")
+        _emit(rep, args.json, _render_check)
+        return 0
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

eclipse_bazaar/client.py

@@ -0,0 +1,53 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""Python SDK for Eclipse Bazaar (candidate C1 — plumbing, no novelty
+claim). A small read-only client over the same catalog and corpus the
+MCP server and CLI serve: identical ranking, identical match reasons,
+identical status labels, because it calls the same functions.
+
+    from eclipse_bazaar import Bazaar
+    bz = Bazaar()                      # bundled snapshot (offline)
+    bz = Bazaar(refresh=True)          # one bulk HTTPS refresh, fallback local
+    bz.search("certificate renewal")   # -> dict like the MCP tool's result
+    bz.get_listing("certbridge-mcp")   # full catalog entry
+    bz.check()                         # Phase-1 standing check of your configs
+
+No API key (year-one posture: free reads). No telemetry — the client
+sends nothing anywhere except the optional bulk catalog refresh.
+"""
+from . import mcp_server as _srv
+from .catalog import catalog_dict
+from .check import run_check
+
+
+class Bazaar:
+    def __init__(self, refresh: bool = False):
+        self._cat = catalog_dict(refresh=refresh)
+
+    # ------------------------------------------------------ discovery
+    def search(self, query: str, category: str = None) -> dict:
+        return _srv.t_search_products(
+            {"query": query, "category": category or ""}, self._cat)
+
+    def find_solutions(self, problem: str) -> dict:
+        return _srv.t_find_solutions({"problem": problem}, self._cat)
+
+    def get_listing(self, product_id: str) -> dict:
+        return _srv.t_get_product({"id": product_id}, self._cat)
+
+    get_product = get_listing
+
+    def compare(self, ids) -> dict:
+        return _srv.t_compare_products({"ids": list(ids)}, self._cat)
+
+    def get_certification(self, product_id: str) -> dict:
+        return _srv.t_get_certification({"id": product_id}, self._cat)
+
+    def categories(self) -> dict:
+        return _srv.t_list_categories({}, self._cat)
+
+    # ------------------------------------------------------ standing check
+    def check(self, config_paths=None, corpus_path=None,
+              refresh_corpus: bool = False) -> dict:
+        return run_check(config_paths=config_paths,
+                         corpus_path=corpus_path,
+                         refresh_corpus=refresh_corpus)