eclipse-bazaar 0.1.0__py3-none-any.whl

eclipse_bazaar/integrations/__init__.py

@@ -0,0 +1,3 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""Framework adapters (optional extras). Thin wrappers over the SDK —
+standard adapter pattern, presence value only."""

eclipse_bazaar/integrations/crewai_tools.py

@@ -0,0 +1,44 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""CrewAI adapter — the Bazaar SDK as CrewAI tools, so a crew agent can
+query the marketplace mid-task without an MCP client configured.
+
+Install: pip install "eclipse-bazaar[crewai]"
+Usage:
+    from eclipse_bazaar.integrations.crewai_tools import make_crewai_tools
+    tools = make_crewai_tools()
+"""
+import json
+
+from ..client import Bazaar
+
+
+def make_crewai_tools(bazaar: Bazaar = None):
+    try:
+        from crewai.tools import BaseTool
+    except ImportError as e:  # pragma: no cover - optional extra
+        raise RuntimeError(
+            "crewai is not installed — "
+            "pip install 'eclipse-bazaar[crewai]'") from e
+    bz = bazaar or Bazaar()
+
+    class BazaarSearchTool(BaseTool):
+        name: str = "bazaar_search"
+        description: str = (
+            "Search Eclipse Bazaar (Cyan Eclipse Technologies' catalog of "
+            "tested MCP products) by keyword. Input: a search query string. "
+            "Returns listings with status and Test Bench verdicts.")
+
+        def _run(self, query: str) -> str:
+            return json.dumps(bz.search(query), indent=1)
+
+    class BazaarListingTool(BaseTool):
+        name: str = "bazaar_get_listing"
+        description: str = (
+            "Full Eclipse Bazaar catalog entry for one product id, "
+            "including its certification block and what was NOT tested. "
+            "Input: the product id.")
+
+        def _run(self, product_id: str) -> str:
+            return json.dumps(bz.get_listing(product_id), indent=1)
+
+    return [BazaarSearchTool(), BazaarListingTool()]

eclipse_bazaar/integrations/langchain_tools.py

@@ -0,0 +1,43 @@
+# Eclipse Bazaar · © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+"""LangChain adapter — the Bazaar SDK as LangChain tools, so an agent
+mid-task can query the marketplace without an MCP client configured.
+
+Install: pip install "eclipse-bazaar[langchain]"
+Usage:
+    from eclipse_bazaar.integrations.langchain_tools import make_langchain_tools
+    tools = make_langchain_tools()
+"""
+import json
+
+from ..client import Bazaar
+
+
+def make_langchain_tools(bazaar: Bazaar = None):
+    try:
+        from langchain_core.tools import BaseTool
+    except ImportError as e:  # pragma: no cover - optional extra
+        raise RuntimeError(
+            "langchain-core is not installed — "
+            "pip install 'eclipse-bazaar[langchain]'") from e
+    bz = bazaar or Bazaar()
+
+    class BazaarSearchTool(BaseTool):
+        name: str = "bazaar_search"
+        description: str = (
+            "Search Eclipse Bazaar (Cyan Eclipse Technologies' catalog of "
+            "tested MCP products) by keyword. Returns listings with status "
+            "and Test Bench verdicts, plus why each matched.")
+
+        def _run(self, query: str) -> str:
+            return json.dumps(bz.search(query), indent=1)
+
+    class BazaarListingTool(BaseTool):
+        name: str = "bazaar_get_listing"
+        description: str = (
+            "Full Eclipse Bazaar catalog entry for one product id, "
+            "including its certification block and what was NOT tested.")
+
+        def _run(self, product_id: str) -> str:
+            return json.dumps(bz.get_listing(product_id), indent=1)
+
+    return [BazaarSearchTool(), BazaarListingTool()]

eclipse_bazaar/mcp_server.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+# Eclipse Bazaar MCP
+# Copyright © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+
+"""Eclipse Bazaar MCP — the agent-facing discovery layer for
+Eclipse Bazaar, Cyan Eclipse Technologies' tested MCP marketplace.
+
+Powered by Cyan Eclipse Technologies (cetech.ai).
+
+Why this exists: agents shop by problem, not by product name. A listing
+in a registry tells an agent a server exists; it does not tell it what
+problem the tool solves, whether anyone tested it, or — just as
+important — what was NOT tested. This server answers those questions
+from the Bazaar catalog:
+
+  * search_products  — keyword search with transparent match reasons
+  * find_solutions   — problem-first matching with fit explanations
+  * get_product      — full entry incl. certification + not-tested list
+  * compare_products — status / pricing / certification side by side
+  * get_certification — latest Test Bench verdict + scorecard summary
+  * list_categories  — catalog shape, counts by status
+
+Honesty rules (inherited from the Bazaar concept): a product with no
+Test Bench verdict says so; spec-stage products are labelled spec and
+never certified; nothing in the catalog is invented — every entry is
+seeded from a bazaar-manifest.json, a Test Bench scorecard, or the
+CETech MCP product slate (see catalog.json "sources").
+
+v0.1.0 scope: CETech catalog only. Third-party listings are P2.
+No purchasing yet — purchase hooks are future work: x402 pay-per-call
+for paid tools and an Agent Wallet policy check before any charge.
+
+Transport: MCP over stdio (newline-delimited JSON-RPC 2.0), stdlib only.
+Catalog: bundled snapshot (repo mode: the repo-root catalog.json;
+override with $BAZAAR_CATALOG). Scorecards: the stamped verdict
+snapshot bundled in eclipse_bazaar/data (gate A1 — an installed wheel
+never reaches for ../test-bench/results/); repo mode falls back to the
+referenced card when the snapshot lacks the ref.
+"""
+import json
+import re
+import sys
+
+from ._version import __version__
+from .catalog import catalog_dict, freshness, scorecard_summary
+
+STOP = {"a", "an", "the", "i", "my", "me", "to", "for", "of", "is", "it",
+        "can", "do", "does", "need", "want", "give", "get", "with",
+        "without", "and", "or", "on", "in", "an", "agent", "agents",
+        "mcp", "tool", "tools", "ai"}
+
+
+class ToolError(Exception):
+    pass
+
+
+def load_catalog() -> dict:
+    try:
+        return catalog_dict()
+    except FileNotFoundError as e:
+        raise ToolError(f"catalog not found: {e.filename}")
+
+
+def toks(text: str) -> list:
+    return [t for t in re.findall(r"[a-z0-9][a-z0-9\-]*", text.lower())
+            if len(t) >= 3 and t not in STOP]
+
+
+def match_terms(qtoks: list, text: str) -> list:
+    tt = set(toks(text))
+    return [t for t in qtoks if t in tt]
+
+
+def brief(p: dict) -> dict:
+    c = p["certification"]
+    return {"id": p["id"], "name": p["name"], "vendor": p["vendor"],
+            "tagline": p["tagline"], "status": p["status"],
+            "pricing_model": p["pricing_model"],
+            "categories": p["categories"], "platforms": p["platforms"],
+            "certification": {"bench_verdict": c["bench_verdict"],
+                              "certified": c["certified"]}}
+
+
+def score_product(p: dict, qtoks: list, weights: dict):
+    """Returns (score, match_reasons[]). weights keyed by field."""
+    score, reasons = 0, []
+    fields = [("name", p["name"]), ("tagline", p["tagline"]),
+              ("categories", " ".join(p["categories"])),
+              ("capabilities", " ".join(p["capabilities"])),
+              ("problem_statements", " ".join(p["problem_statements"]))]
+    for field, text in fields:
+        hits = match_terms(qtoks, text)
+        if hits:
+            score += weights[field] * len(hits)
+            reasons.append(f"{field} matched: {', '.join(sorted(set(hits)))}")
+    return score, reasons
+
+
+# --------------------------------------------------------------------- tools
+def t_search_products(args, cat=None):
+    query = str(args.get("query", "")).strip()
+    if not query:
+        raise ToolError("query is required")
+    category = str(args.get("category", "")).strip().lower()
+    cat = cat if cat is not None else load_catalog()
+    qt = toks(query)
+    weights = {"name": 5, "categories": 4, "capabilities": 3,
+               "problem_statements": 2, "tagline": 2}
+    hits = []
+    for p in cat["products"]:
+        if category and category not in [c.lower() for c in p["categories"]]:
+            continue
+        s, reasons = score_product(p, qt, weights)
+        if s > 0:
+            h = brief(p)
+            h["score"] = s
+            h["match_reasons"] = reasons
+            hits.append(h)
+    hits.sort(key=lambda h: (-h["score"], h["name"]))
+    return {"query": query, "count": len(hits), "results": hits,
+            "data_freshness": freshness(cat)}
+
+
+def t_find_solutions(args, cat=None):
+    problem = str(args.get("problem", "")).strip()
+    if not problem:
+        raise ToolError("problem is required")
+    cat = cat if cat is not None else load_catalog()
+    qt = toks(problem)
+    weights = {"problem_statements": 4, "capabilities": 3, "categories": 2,
+               "name": 2, "tagline": 2}
+    out = []
+    for p in cat["products"]:
+        s, reasons = score_product(p, qt, weights)
+        if s > 0:
+            c = p["certification"]
+            badge = c["bench_verdict"] or (
+                "not certified (spec-stage)" if p["status"] == "spec"
+                else "not yet certified")
+            out.append({
+                "id": p["id"], "name": p["name"], "score": s,
+                "fit": f"{p['name']} — {p['tagline']} "
+                       f"Matched on: {'; '.join(reasons)}.",
+                "match_reasons": reasons, "status": p["status"],
+                "certification_badge": badge,
+                "certified": c["certified"],
+                "pricing_model": p["pricing_model"],
+                "top_capabilities": p["capabilities"][:3]})
+    out.sort(key=lambda h: (-h["score"], h["name"]))
+    return {"problem": problem, "count": len(out), "solutions": out[:8],
+            "data_freshness": freshness(cat)}
+
+
+def _get(cat, pid):
+    for p in cat["products"]:
+        if p["id"] == pid:
+            return p
+    raise ToolError(f"unknown product id: {pid}")
+
+
+def t_get_product(args, cat=None):
+    pid = str(args.get("id", "")).strip()
+    if not pid:
+        raise ToolError("id is required")
+    cat = cat if cat is not None else load_catalog()
+    p = dict(_get(cat, pid))
+    p["honesty_note"] = (
+        "certification.bench_verdict is null when no Test Bench run exists; "
+        "not_tested lists what the bench did not cover — absence of a verdict "
+        "is stated, never implied.")
+    return {"product": p, "data_freshness": freshness(cat)}
+
+
+def t_compare_products(args, cat=None):
+    ids = args.get("ids") or []
+    if not isinstance(ids, list) or len(ids) < 2:
+        raise ToolError("ids must be a list of at least two product ids")
+    cat = cat if cat is not None else load_catalog()
+    rows = []
+    for pid in ids:
+        p = _get(cat, str(pid))
+        c = p["certification"]
+        rows.append({"id": p["id"], "name": p["name"], "status": p["status"],
+                     "pricing_model": p["pricing_model"],
+                     "certification": c["bench_verdict"] or "none on record",
+                     "certified": c["certified"],
+                     "certified_scope": c["certified_scope"],
+                     "platforms": p["platforms"],
+                     "categories": p["categories"],
+                     "capability_count": len(p["capabilities"]),
+                     "tools": p["tools"]})
+    return {"comparison": rows, "data_freshness": freshness(cat)}
+
+
+def t_get_certification(args, cat=None):
+    pid = str(args.get("id", "")).strip()
+    if not pid:
+        raise ToolError("id is required")
+    cat = cat if cat is not None else load_catalog()
+    p = _get(cat, pid)
+    c = p["certification"]
+    base = {"id": p["id"], "name": p["name"], "status": p["status"],
+            "bench_verdict": c["bench_verdict"], "certified": c["certified"],
+            "certified_scope": c["certified_scope"],
+            "scorecard_ref": c["scorecard_ref"],
+            "not_tested": c["not_tested"],
+            "data_freshness": freshness(cat)}
+    if not c["bench_verdict"]:
+        base["certification_status"] = (
+            "NOT YET CERTIFIED — no Test Bench verdict on record for this "
+            "product. " + ("This product is spec-stage (not built), so no "
+                           "bench run is possible yet." if p["status"] == "spec"
+                           else "A bench run is pending; treat all capability "
+                                "claims as vendor-stated, not bench-verified."))
+        base["scorecard_summary"] = None
+        return base
+    base["certification_status"] = (
+        f"Bench verdict on record: {c['bench_verdict']} — scope and "
+        f"not_tested state exactly what that verdict does and does not cover.")
+    ref = c.get("scorecard_ref")
+    base["scorecard_summary"] = scorecard_summary(ref) if ref else None
+    return base
+
+
+def t_list_categories(args, cat=None):
+    cat = cat if cat is not None else load_catalog()
+    cats = {}
+    for p in cat["products"]:
+        for cname in p["categories"]:
+            e = cats.setdefault(cname, {"category": cname, "total": 0,
+                                        "by_status": {}, "products": []})
+            e["total"] += 1
+            e["by_status"][p["status"]] = e["by_status"].get(p["status"], 0) + 1
+            e["products"].append(p["id"])
+    return {"categories": sorted(cats.values(), key=lambda e: e["category"]),
+            "product_total": len(cat["products"]),
+            "data_freshness": freshness(cat)}
+
+
+TOOLS = {
+    "search_products": (t_search_products,
+                        "Keyword search over the Bazaar catalog (names, capabilities, categories, problem statements). Every hit carries match_reasons — why it matched is never hidden. Optional category filter.",
+                        {"query": {"type": "string"}, "category": {"type": "string"}}, ["query"]),
+    "find_solutions": (t_find_solutions,
+                       "Describe a problem in plain language; get ranked products with a fit explanation, status, and certification badge inline. Spec-stage products are labelled spec-stage, uncertified products say so.",
+                       {"problem": {"type": "string"}}, ["problem"]),
+    "get_product": (t_get_product,
+                    "Full catalog entry for one product id: capabilities, problem statements, pricing model, platforms, tools, and the certification block including what was NOT tested.",
+                    {"id": {"type": "string"}}, ["id"]),
+    "compare_products": (t_compare_products,
+                         "Side-by-side comparison of 2+ product ids: status, pricing model, certification verdict and scope, platforms, categories.",
+                         {"ids": {"type": "array", "items": {"type": "string"}}}, ["ids"]),
+    "get_certification": (t_get_certification,
+                          "The latest Test Bench verdict for a product, with a live scorecard summary, the certified scope, and the not_tested list. Returns an explicit NOT YET CERTIFIED answer when no verdict exists.",
+                          {"id": {"type": "string"}}, ["id"]),
+    "list_categories": (t_list_categories,
+                        "All catalog categories with product counts broken down by status (live / dogfood / in-development / spec).",
+                        {}, []),
+}
+
+
+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": "eclipse-bazaar", "version": __version__}}}
+    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()
+
+# Eclipse Bazaar MCP · © 2026 Cyan Eclipse Technologies LLC · cetech.ai

eclipse_bazaar-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: eclipse-bazaar
+Version: 0.1.0
+Summary: Eclipse Bazaar — Cyan Eclipse Technologies' catalog of tested MCP products: MCP server, CLI, and Python SDK in one distribution.
+Author: Cyan Eclipse Technologies LLC
+License: MIT
+Project-URL: Homepage, https://eclipsebazaar.com
+Project-URL: Repository, https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/bazaar-mcp
+Project-URL: Vendor, https://cetech.ai
+Keywords: mcp,model-context-protocol,marketplace,catalog,agent-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == "crewai"
+Dynamic: license-file
+
+# eclipse-bazaar
+
+**Eclipse Bazaar is Cyan Eclipse Technologies' own catalog** of tested
+MCP products — at v0.1.0 it lists Cyan Eclipse Technologies products
+only (86 listings). It is not a general index of every MCP server, and
+this package does not claim to be one. Third-party listings are future
+work (P2 on the server's own roadmap).
+
+One distribution, three surfaces:
+
+## 1. The Bazaar MCP server
+
+```json
+{ "mcpServers": { "eclipse-bazaar": { "command": "uvx", "args": ["eclipse-bazaar"] } } }
+```
+
+Six tools — `search_products`, `find_solutions`, `get_product`,
+`compare_products`, `get_certification`, `list_categories` — that let an
+agent shop by *problem*, with transparent match reasons. Every listing
+carries its Test Bench verdict and scope, or states plainly that it has
+none; every entry carries a `not_tested` list. A product labelled
+spec-stage is a spec, not a product; an uncertified product says so.
+
+Catalog data ships as a stamped snapshot bundled in the wheel, and
+verdict summaries ship as a hash-pinned verdict snapshot generated from
+the Test Bench cards — an installed run never reads files outside the
+package.
+
+## 2. The `bazaar` CLI
+
+```console
+$ bazaar search "certificate renewal"
+$ bazaar product certbridge-mcp
+$ bazaar categories
+$ bazaar check            # classify your configured MCP servers
+```
+
+`bazaar check` reads your MCP client configs, extracts each configured
+server's *identity* (package / image / URL / local path), and joins it
+locally against the published Bazaar corpus — downloaded whole and
+verified against its sha256 manifest first. Each entry is classified
+`CERTIFIED` (listed, Tier-2 verdict on record), `LISTED` (in the
+catalog, no verdict yet), `NOT LISTED` (no record — a neutral fact), or
+`UNRESOLVABLE` (no identity could be extracted, with the reason).
+Version pins that differ from the listed version are flagged as drift.
+
+Privacy, by construction: config `env` **values are never read, copied,
+hashed, logged, or transmitted** — the parser redacts them structurally
+before anything else runs. There is no telemetry. The check never
+executes a configured server and never contacts one.
+
+## 3. The Python SDK
+
+```python
+from eclipse_bazaar import Bazaar
+
+bz = Bazaar()                    # bundled snapshot, works offline
+bz.search("ssl certificate")     # same ranking/reasons as the MCP tool
+bz.get_listing("certbridge-mcp")
+bz.check()                       # the Phase-1 standing check, as a dict
+```
+
+Optional framework adapters (standard adapter pattern):
+
+```console
+$ pip install "eclipse-bazaar[langchain]"   # or [crewai]
+```
+
+```python
+from eclipse_bazaar.integrations.langchain_tools import make_langchain_tools
+tools = make_langchain_tools()
+```
+
+## Scope and honesty
+
+- Statuses and verdicts are as of the catalog build date stamped in
+  every response (`data_freshness`).
+- Spec-stage listings are labelled spec; in-development listings say
+  so; absence of a verdict is stated, never implied.
+- `bazaar check` v0.1 is Phase 1: it speaks only about listing and
+  Tier-2 verdict records. Further record classes join the vocabulary
+  only when the underlying records themselves are public.
+
+Powered by Cyan Eclipse Technologies LLC (cetech.ai) — a Veteran-Owned
+Small Business. MIT licensed.

eclipse_bazaar-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+eclipse_bazaar/__init__.py,sha256=E5zjKG3MNxJiHZ3wCU4HHP66YR89sOcvXnEJwLLeTDI,592
+eclipse_bazaar/_version.py,sha256=wBlRCELbe_bSWnl6oI25jkE4Wxe61ex-OHqDafxrSls,93
+eclipse_bazaar/catalog.py,sha256=bY7xSTaEUJBrsA-oggePG5RSO59fYYVtVGGZRd9vPDU,6514
+eclipse_bazaar/check.py,sha256=aQA7dDmdDtM3ZT1-IpvZSlU3CW6oX8993WmUgPok-Ko,10185
+eclipse_bazaar/cli.py,sha256=ednopR5KWk4EhRzSCnIyBinw64d0D85aUjKNuYrMHBM,7005
+eclipse_bazaar/client.py,sha256=k2zuY10-Det9l2ghNZpEOjm4zd4sZt5GcydYvFib1is,2284
+eclipse_bazaar/configparse.py,sha256=Gg3ESRKQNLnAywoQ6K2fDWreQVsYHteP1GgFn_uvc_E,12515
+eclipse_bazaar/mcp_server.py,sha256=FqLzXDspR5NTGMAnsqzZUGu1eLxKBmPoJ9HPtN9R8EU,13818
+eclipse_bazaar/data/catalog.json,sha256=mTtlPp6JXqJzuu0s9hBRi6PrPdvUs-7Y4Zw7KG59xPI,444067
+eclipse_bazaar/data/corpus.jsonl,sha256=hZihUiOjcX4G-Wbe0kGBdXcim0Aoa8k_KZiTSAfKYqk,138121
+eclipse_bazaar/data/corpus.manifest.json,sha256=k3_W6iqIz1w6ZBQk2qU5LR580lZG8Yvvq_ZZ14hoLBM,235
+eclipse_bazaar/data/verdict_snapshot.json,sha256=qLslwAsBjXuBUBgmLQGZyyRCKHel8ZJRKTOnhgEt0LA,49952
+eclipse_bazaar/integrations/__init__.py,sha256=cK3XXx6M2vp-CpoVFtCtB9Cyy_wlJRhHWjxJDug6zHY,193
+eclipse_bazaar/integrations/crewai_tools.py,sha256=u6Dbv8-XONg1MwzyBCmMiMmljwnMhdn3p-ThqMiNHqs,1630
+eclipse_bazaar/integrations/langchain_tools.py,sha256=sObSvxHSQ21TuRPpdH8wqr8vE3jIiNb9s-yFIX4KtVU,1621
+eclipse_bazaar-0.1.0.dist-info/licenses/LICENSE,sha256=J64raxD33SRnnCn8p1F-lRl0rnesurM9Jlkd3auDZvA,1086
+eclipse_bazaar-0.1.0.dist-info/METADATA,sha256=M5s099IzuB7obSS-Zmw3xGkTi9X25Z5PZOi7VztPuXM,4280
+eclipse_bazaar-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+eclipse_bazaar-0.1.0.dist-info/entry_points.txt,sha256=ZRXz9qIcm9sPTlH8n7hR5lGiGnImMWSnSfxv3zNQXpk,99
+eclipse_bazaar-0.1.0.dist-info/top_level.txt,sha256=bRBeXTwM8PdEqRu2SI8dFdnM5Kyt1y1GgSG5H9lsTEs,15
+eclipse_bazaar-0.1.0.dist-info/RECORD,,

eclipse_bazaar-0.1.0.dist-info/WHEEL

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

eclipse_bazaar-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bazaar = eclipse_bazaar.cli:main
+eclipse-bazaar = eclipse_bazaar.mcp_server:main

eclipse_bazaar-0.1.0.dist-info/licenses/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_bazaar-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eclipse_bazaar