PyPI - boost-skill-cli - Versions diffs - 1.0.93__tar.gz → 1.0.95__tar.gz - Mend

boost-skill-cli 1.0.93tar.gz → 1.0.95tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (244) hide show

{boost_skill_cli-1.0.93 → boost_skill_cli-1.0.95}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.93
+Version: 1.0.95
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.93 → boost_skill_cli-1.0.95}/boost_cli/_version.py RENAMED Viewed

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
-__version__ = version = '1.0.93'
-__version_tuple__ = version_tuple = (1, 0, 93)
+__version__ = version = '1.0.95'
+__version_tuple__ = version_tuple = (1, 0, 95)
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.93 → boost_skill_cli-1.0.95}/boost_cli/commands/configuration.py RENAMED Viewed

@@ -2,9 +2,7 @@
 completions, schedule, serve, mcp, self-update."""
 from __future__ import annotations
-import errno
 import getpass
-import html
 import json
 import os
 import re
@@ -12,15 +10,13 @@ import shutil
 import subprocess
 import sys
 import time
-import urllib.parse
 from datetime import datetime, timedelta
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from .. import cliparse
 from .. import __version__
 from ..core import agents, catalog, config, frontmatter, gitutil, journal
-from ..core import lockfile, mcp, paths, policy, rag, registry, store, util
+from ..core import lockfile, mcp, paths, policy, rag, registry, serve, store, util
 from ..core import output as out
 from ..errors import BoostError
@@ -730,106 +726,8 @@ def cmd_schedule(argv) -> int:
 # ---------------------------------------------------------------- serve
-_PAGE_CSS = ("body{background:#111;color:#ddd;font-family:ui-monospace,SFMono-Regular,"
-             "Menlo,monospace;max-width:720px;margin:2rem auto;padding:0 1rem}"
-             "h1{color:#fff;font-size:1.3rem}a{color:#7dc4ff;text-decoration:none}"
-             "a:hover{text-decoration:underline}table{border-collapse:collapse;width:100%}"
-             "th,td{text-align:left;padding:.3rem .8rem .3rem 0;"
-             "border-bottom:1px solid #2a2a2a}.dim{color:#777}")
-_SKILL_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+$")
-def _serve_page() -> str:
-    installed = lockfile.installed()
-    entries = catalog.all_entries()
-    taps = registry.list_taps()
-    rows = "".join(
-        '<tr><td><a href="/skill/%s">%s</a></td><td>%s</td><td>%s</td></tr>'
-        % (urllib.parse.quote(n), html.escape(n),
-           html.escape(str(e.get("version", "?"))),
-           html.escape(str(e.get("tap", "?"))))
-        for n, e in sorted(installed.items()))
-    return ("<!doctype html><html><head><meta charset='utf-8'>"
-            "<title>boost — skill catalog</title><style>%s</style></head><body>"
-            "<h1>⚡ boost <span class='dim'>v%s</span></h1>"
-            "<p class='dim'>%d installed · %d available across %d taps</p>"
-            "<table><tr><th>skill</th><th>version</th><th>tap</th></tr>%s</table>"
-            "<p><a href='/installed.json'>installed.json</a> · "
-            "<a href='/catalog.json'>catalog.json</a></p></body></html>"
-            % (_PAGE_CSS, __version__, len(installed), len(entries), len(taps),
-               rows or "<tr><td colspan='3' class='dim'>nothing installed</td></tr>"))
-def _skill_text(name: str):
-    """SKILL.md text for an installed skill, else from a tap. None if unknown."""
-    if not _SKILL_NAME_RE.fullmatch(name):
-        return None
-    fp = store.skill_store_dir(name) / "SKILL.md"
-    if fp.is_file():
-        return fp.read_text(encoding="utf-8", errors="replace")
-    for e in catalog.find(name):
-        try:
-            fp = registry.get(e["tap"]).path / e["skill_md"]
-        except BoostError:
-            continue
-        if fp.is_file():
-            return fp.read_text(encoding="utf-8", errors="replace")
-    return None
-class _CatalogHandler(BaseHTTPRequestHandler):
-    server_version = "boost/" + __version__
-    def log_message(self, fmt, *args):  # logged in _send instead
-        pass
-    def _send(self, status: int, ctype: str, body: bytes) -> None:
-        self.send_response(status)
-        self.send_header("Content-Type", ctype)
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-        out.dim("  %s %s → %d" % (self.command, self.path, status))
-    def do_GET(self):
-        path = urllib.parse.unquote(self.path.split("?", 1)[0])
-        try:
-            if path in ("/", "/index.html"):
-                self._send(200, "text/html; charset=utf-8", _serve_page().encode())
-            elif path == "/catalog.json":
-                self._send(200, "application/json",
-                           json.dumps(catalog.all_entries(), indent=2).encode())
-            elif path == "/installed.json":
-                self._send(200, "application/json",
-                           json.dumps(lockfile.read(), indent=2).encode())
-            elif path.startswith("/skill/"):
-                name = path[len("/skill/"):].strip("/")
-                if not _SKILL_NAME_RE.fullmatch(name):
-                    self._send(404, "application/json",
-                               json.dumps({"error": "no skill named %r" % name}).encode())
-                    return
-                text = _skill_text(name)
-                if text is None:
-                    self._send(404, "application/json",
-                               json.dumps({"error": "no skill named %r" % name}).encode())
-                else:
-                    self._send(200, "text/plain; charset=utf-8", text.encode())
-            else:
-                self._send(404, "application/json",
-                           json.dumps({"error": "not found"}).encode())
-        except BrokenPipeError:
-            pass
-        except Exception as e:  # noqa: BLE001 — keep the server alive
-            try:
-                self._send(500, "application/json",
-                           json.dumps({"error": str(e)}).encode())
-            except Exception:
-                pass
 def cmd_serve(argv) -> int:
-    """boost serve [--port N] [--host H]"""
+    """boost serve [--port N] [--host H] — thin wrapper over core.serve."""
     p = cliparse.parser(
         prog="boost serve",
         description="Serve the skill catalog over HTTP (port 8787)")
@@ -839,24 +737,7 @@ def cmd_serve(argv) -> int:
     p.add_argument("--host", default="127.0.0.1",
                    help="address to bind (default: 127.0.0.1)")
     args = p.parse_args(argv)
-    try:
-        httpd = ThreadingHTTPServer((args.host, args.port), _CatalogHandler)
-    except OSError as e:
-        if e.errno == errno.EADDRINUSE:
-            raise BoostError("port %d is already in use" % args.port,
-                            hint="pick another with --port")
-        raise BoostError("cannot bind %s:%d — %s" % (args.host, args.port, e),
-                        hint="check --host and --port")
-    out.info("⚡ serving skill catalog on http://%s:%d %s"
-             % (args.host, args.port, out.c("(ctrl-c to stop)", out.DIM)))
-    try:
-        httpd.serve_forever()
-    except KeyboardInterrupt:
-        print()
-        out.ok("server stopped")
-    finally:
-        httpd.server_close()
+    serve.serve_http(args.host, args.port)
     return 0
@@ -1021,70 +902,13 @@ _MCP_TOOLS = REGISTRY.specs()
 def _mcp_tool(tool: str, args: dict):
-    """Run one MCP tool -> (text, is_error). (None, _) for unknown tools."""
-    return REGISTRY.call(tool, args)
+    """Run one MCP tool -> (text, is_error). (None, _) for unknown tools.
-def _mcp_send(msg: dict) -> bool:
-    try:
-        sys.stdout.write(json.dumps(msg) + "\n")
-        sys.stdout.flush()
-        return True
-    except (BrokenPipeError, OSError):
-        return False
-def _mcp_serve_stdio() -> int:
-    """Newline-delimited JSON-RPC 2.0 MCP server on stdin/stdout."""
-    while True:
-        try:
-            line = sys.stdin.readline()
-        except (KeyboardInterrupt, OSError):
-            return 0
-        if not line:  # EOF
-            return 0
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            req = json.loads(line)
-        except json.JSONDecodeError:
-            if not _mcp_send({"jsonrpc": "2.0", "id": None,
-                              "error": {"code": -32700, "message": "parse error"}}):
-                return 0
-            continue
-        method = str(req.get("method", ""))
-        if "id" not in req:  # notification (e.g. notifications/initialized)
-            continue
-        resp = {"jsonrpc": "2.0", "id": req.get("id")}
-        if method == "initialize":
-            resp["result"] = {"protocolVersion": "2024-11-05",
-                              "capabilities": {"tools": {}},
-                              "serverInfo": {"name": "boost", "version": __version__}}
-        elif method == "ping":
-            resp["result"] = {}
-        elif method == "tools/list":
-            resp["result"] = {"tools": _MCP_TOOLS}
-        elif method == "tools/call":
-            params = req.get("params") or {}
-            tool = str(params.get("name", ""))
-            try:
-                text, is_err = _mcp_tool(tool, params.get("arguments") or {})
-            except BoostError as e:
-                text = "Error: %s" % e.message + ("\nhint: %s" % e.hint if e.hint else "")
-                is_err = True
-            except Exception as e:  # noqa: BLE001 — server must not die
-                text, is_err = "Error: %s" % e, True
-            if text is None:
-                resp["error"] = {"code": -32602, "message": "unknown tool %r" % tool}
-            else:
-                resp["result"] = {"content": [{"type": "text", "text": text}]}
-                if is_err:
-                    resp["result"]["isError"] = True
-        else:
-            resp["error"] = {"code": -32601, "message": "method not found: %s" % method}
-        if not _mcp_send(resp):
-            return 0
+    Thin shim over ``REGISTRY.call`` kept for the functional tests; the JSON-RPC
+    protocol itself now lives in ``core/mcp.py`` (``handle_request`` /
+    ``serve_stdio``).
+    """
+    return REGISTRY.call(tool, args)
 def cmd_mcp(argv) -> int:
@@ -1100,7 +924,7 @@ def cmd_mcp(argv) -> int:
     args = p.parse_args(argv)
     if args.stdio:
-        return _mcp_serve_stdio()
+        return mcp.serve_stdio(REGISTRY, version=__version__)
     shim = paths.launcher()
     if args.action == "register":

boost_skill_cli-1.0.95/boost_cli/core/mcp.py ADDED Viewed

@@ -0,0 +1,165 @@
+"""Extensible MCP tool registry — the Phase-3 "MCP as a hub" seam.
+An MCP tool is a *handler* — ``fn(args: dict) -> (text, is_error)`` — paired with
+its JSON spec (``name`` / ``description`` / ``inputSchema``). Instead of a flat
+``if/elif`` dispatcher, tools self-register on a :class:`Registry`; the JSON-RPC
+server iterates it for both ``tools/list`` and ``tools/call``. Adding a
+capability (a GitHub reach-out, a database query, some future dependency) is one
+``register()`` call — no dispatcher edits, no server changes.
+Handlers return ``(text, is_error)``. A handler that returns ``text is None``
+signals "I did not produce a result"; :meth:`Registry.call` also returns
+``(None, False)`` for an unknown tool, so the server can answer with a JSON-RPC
+``unknown tool`` error in exactly one place. Reach-out handlers degrade the way
+``core/ai.py`` does: probe for the dependency, and when it is absent return a
+short helpful message rather than raising.
+"""
+from __future__ import annotations
+import json
+import sys
+from typing import Callable, Dict, List, Optional, Tuple
+from ..errors import BoostError
+# A handler maps parsed arguments to (text, is_error). ``text is None`` means the
+# handler produced no result (treated by the server as an unknown/aborted tool).
+Handler = Callable[[dict], Tuple[Optional[str], bool]]
+class Registry:
+    """An ordered name -> (spec, handler) map for MCP tools."""
+    def __init__(self) -> None:
+        self._order: List[str] = []
+        self._specs: Dict[str, dict] = {}
+        self._handlers: Dict[str, Handler] = {}
+    def register(self, name: str, description: str, input_schema: dict,
+                 handler: Handler) -> None:
+        """Register one tool. Raises on an empty or duplicate name."""
+        if not name:
+            raise ValueError("MCP tool name must be non-empty")
+        if name in self._handlers:
+            raise ValueError("duplicate MCP tool %r" % name)
+        self._order.append(name)
+        self._specs[name] = {"name": name, "description": description,
+                             "inputSchema": input_schema}
+        self._handlers[name] = handler
+    def tool(self, name: str, description: str,
+             input_schema: dict) -> Callable[[Handler], Handler]:
+        """Decorator form of :meth:`register`; returns the handler unchanged."""
+        def deco(fn: Handler) -> Handler:
+            self.register(name, description, input_schema, fn)
+            return fn
+        return deco
+    def specs(self) -> List[dict]:
+        """The ``tools/list`` payload — specs in registration order."""
+        return [self._specs[name] for name in self._order]
+    def names(self) -> List[str]:
+        """Registered tool names, in registration order."""
+        return list(self._order)
+    def has(self, name: str) -> bool:
+        return name in self._handlers
+    def call(self, name: str, args: dict) -> Tuple[Optional[str], bool]:
+        """Dispatch to a handler. ``(None, False)`` for an unknown tool."""
+        handler = self._handlers.get(name)
+        if handler is None:
+            return None, False
+        return handler(args)
+# ── JSON-RPC 2.0 protocol ─────────────────────────────────────────────────
+# The wire protocol Claude Code speaks to `boost mcp --stdio`. handle_request is
+# a *pure* request→response mapping (no I/O), so the whole protocol is unit
+# testable; serve_stdio only adds the newline-delimited stdin/stdout loop.
+PROTOCOL_VERSION = "2024-11-05"
+def handle_request(req: dict, *, version: str,
+                   registry: "Registry") -> Optional[dict]:
+    """Map one parsed JSON-RPC request to its response dict.
+    Returns ``None`` for a notification (a request with no ``id``) — the caller
+    sends nothing back. Handlers that raise during ``tools/call`` are turned into
+    an error *result* (``isError``) rather than a protocol error, so a failing
+    tool never kills the session.
+    """
+    method = str(req.get("method", ""))
+    if "id" not in req:  # notification (e.g. notifications/initialized)
+        return None
+    resp: dict = {"jsonrpc": "2.0", "id": req.get("id")}
+    if method == "initialize":
+        resp["result"] = {"protocolVersion": PROTOCOL_VERSION,
+                          "capabilities": {"tools": {}},
+                          "serverInfo": {"name": "boost", "version": version}}
+    elif method == "ping":
+        resp["result"] = {}
+    elif method == "tools/list":
+        resp["result"] = {"tools": registry.specs()}
+    elif method == "tools/call":
+        params = req.get("params") or {}
+        tool = str(params.get("name", ""))
+        try:
+            text, is_err = registry.call(tool, params.get("arguments") or {})
+        except BoostError as e:
+            text = "Error: %s" % e.message + ("\nhint: %s" % e.hint if e.hint else "")
+            is_err = True
+        except Exception as e:  # noqa: BLE001 — server must not die
+            text, is_err = "Error: %s" % e, True
+        if text is None:
+            resp["error"] = {"code": -32602, "message": "unknown tool %r" % tool}
+        else:
+            resp["result"] = {"content": [{"type": "text", "text": text}]}
+            if is_err:
+                resp["result"]["isError"] = True
+    else:
+        resp["error"] = {"code": -32601, "message": "method not found: %s" % method}
+    return resp
+def serve_stdio(registry: "Registry", *, version: str,
+                stdin=None, stdout=None) -> int:
+    """Newline-delimited JSON-RPC 2.0 MCP server on stdin/stdout.
+    ``stdin``/``stdout`` default to the process streams but can be injected
+    (e.g. ``io.StringIO``) so the loop is testable end to end.
+    """
+    stdin = stdin if stdin is not None else sys.stdin
+    stdout = stdout if stdout is not None else sys.stdout
+    def send(msg: dict) -> bool:
+        try:
+            stdout.write(json.dumps(msg) + "\n")
+            stdout.flush()
+            return True
+        except (BrokenPipeError, OSError):
+            return False
+    while True:
+        try:
+            line = stdin.readline()
+        except (KeyboardInterrupt, OSError):
+            return 0
+        if not line:  # EOF
+            return 0
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            if not send({"jsonrpc": "2.0", "id": None,
+                         "error": {"code": -32700, "message": "parse error"}}):
+                return 0
+            continue
+        resp = handle_request(req, version=version, registry=registry)
+        if resp is None:  # notification — nothing to send
+            continue
+        if not send(resp):
+            return 0

boost_skill_cli-1.0.95/boost_cli/core/serve.py ADDED Viewed

@@ -0,0 +1,151 @@
+"""The `boost serve` HTTP catalog server — a small read-only view of the
+installed skills plus JSON endpoints, extracted from the command layer.
+The routing is a pure function (:func:`route`) that maps a request path to a
+``(status, content_type, body)`` triple with no socket bound, so the whole
+endpoint surface is unit-testable. :func:`serve_http` wires it into a threaded
+stdlib HTTP server for the CLI.
+"""
+from __future__ import annotations
+import errno
+import html
+import json
+import re
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Optional, Tuple
+from .. import __version__
+from ..errors import BoostError
+from . import catalog, lockfile, registry, store
+from . import output as out
+SKILL_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+_PAGE_CSS = ("body{background:#111;color:#ddd;font-family:ui-monospace,SFMono-Regular,"
+             "Menlo,monospace;max-width:720px;margin:2rem auto;padding:0 1rem}"
+             "h1{color:#fff;font-size:1.3rem}a{color:#7dc4ff;text-decoration:none}"
+             "a:hover{text-decoration:underline}table{border-collapse:collapse;width:100%}"
+             "th,td{text-align:left;padding:.3rem .8rem .3rem 0;"
+             "border-bottom:1px solid #2a2a2a}.dim{color:#777}")
+def serve_page() -> str:
+    """The HTML index: a table of installed skills with JSON-endpoint links."""
+    installed = lockfile.installed()
+    entries = catalog.all_entries()
+    taps = registry.list_taps()
+    rows = "".join(
+        '<tr><td><a href="/skill/%s">%s</a></td><td>%s</td><td>%s</td></tr>'
+        % (urllib.parse.quote(n), html.escape(n),
+           html.escape(str(e.get("version", "?"))),
+           html.escape(str(e.get("tap", "?"))))
+        for n, e in sorted(installed.items()))
+    return ("<!doctype html><html><head><meta charset='utf-8'>"
+            "<title>boost — skill catalog</title><style>%s</style></head><body>"
+            "<h1>⚡ boost <span class='dim'>v%s</span></h1>"
+            "<p class='dim'>%d installed · %d available across %d taps</p>"
+            "<table><tr><th>skill</th><th>version</th><th>tap</th></tr>%s</table>"
+            "<p><a href='/installed.json'>installed.json</a> · "
+            "<a href='/catalog.json'>catalog.json</a></p></body></html>"
+            % (_PAGE_CSS, __version__, len(installed), len(entries), len(taps),
+               rows or "<tr><td colspan='3' class='dim'>nothing installed</td></tr>"))
+def skill_text(name: str) -> Optional[str]:
+    """SKILL.md text for an installed skill, else from a tap. None if unknown."""
+    if not SKILL_NAME_RE.fullmatch(name):
+        return None
+    fp = store.skill_store_dir(name) / "SKILL.md"
+    if fp.is_file():
+        return fp.read_text(encoding="utf-8", errors="replace")
+    for e in catalog.find(name):
+        try:
+            fp = registry.get(e["tap"]).path / e["skill_md"]
+        except BoostError:
+            continue
+        if fp.is_file():
+            return fp.read_text(encoding="utf-8", errors="replace")
+    return None
+def _json_body(obj) -> bytes:
+    return json.dumps(obj, indent=2).encode()
+def route(path: str) -> Tuple[int, str, bytes]:
+    """Map a GET path to ``(status, content_type, body)``. Pure — no socket.
+    Mirrors the historical dispatch exactly: ``/`` and ``/index.html`` serve the
+    HTML page; ``/catalog.json`` and ``/installed.json`` the JSON views; a
+    ``/skill/<name>`` path the raw SKILL.md (404 for an invalid or unknown name);
+    anything else a JSON ``not found``.
+    """
+    path = urllib.parse.unquote(path.split("?", 1)[0])
+    if path in ("/", "/index.html"):
+        return 200, "text/html; charset=utf-8", serve_page().encode()
+    if path == "/catalog.json":
+        return 200, "application/json", _json_body(catalog.all_entries())
+    if path == "/installed.json":
+        return 200, "application/json", _json_body(lockfile.read())
+    if path.startswith("/skill/"):
+        name = path[len("/skill/"):].strip("/")
+        if not SKILL_NAME_RE.fullmatch(name):
+            return (404, "application/json",
+                    json.dumps({"error": "no skill named %r" % name}).encode())
+        text = skill_text(name)
+        if text is None:
+            return (404, "application/json",
+                    json.dumps({"error": "no skill named %r" % name}).encode())
+        return 200, "text/plain; charset=utf-8", text.encode()
+    return 404, "application/json", json.dumps({"error": "not found"}).encode()
+class _CatalogHandler(BaseHTTPRequestHandler):
+    server_version = "boost/" + __version__
+    def log_message(self, fmt, *args):  # logged in _send instead
+        pass
+    def _send(self, status: int, ctype: str, body: bytes) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+        out.dim("  %s %s → %d" % (self.command, self.path, status))
+    def do_GET(self):
+        try:
+            status, ctype, body = route(self.path)
+            self._send(status, ctype, body)
+        except BrokenPipeError:
+            pass
+        except Exception as e:  # noqa: BLE001 — keep the server alive
+            try:
+                self._send(500, "application/json",
+                           json.dumps({"error": str(e)}).encode())
+            except Exception:
+                pass
+def serve_http(host: str, port: int) -> None:
+    """Bind and run the catalog server until interrupted (blocks)."""
+    try:
+        httpd = ThreadingHTTPServer((host, port), _CatalogHandler)
+    except OSError as e:
+        if e.errno == errno.EADDRINUSE:
+            raise BoostError("port %d is already in use" % port,
+                            hint="pick another with --port")
+        raise BoostError("cannot bind %s:%d — %s" % (host, port, e),
+                        hint="check --host and --port")
+    out.info("⚡ serving skill catalog on http://%s:%d %s"
+             % (host, port, out.c("(ctrl-c to stop)", out.DIM)))
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print()
+        out.ok("server stopped")
+    finally:
+        httpd.server_close()

{boost_skill_cli-1.0.93 → boost_skill_cli-1.0.95}/boost_skill_cli.egg-info/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.93
+Version: 1.0.95
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.93 → boost_skill_cli-1.0.95}/boost_skill_cli.egg-info/SOURCES.txt RENAMED Viewed

@@ -48,6 +48,7 @@ boost_cli/core/paths.py
 boost_cli/core/policy.py
 boost_cli/core/rag.py
 boost_cli/core/registry.py
+boost_cli/core/serve.py
 boost_cli/core/staleness.py
 boost_cli/core/store.py
 boost_cli/core/typosquat.py
@@ -229,6 +230,7 @@ tests/unit/test_rag.py
 tests/unit/test_registries_fresh.py
 tests/unit/test_registry.py
 tests/unit/test_roadmap_fresh.py
+tests/unit/test_serve.py
 tests/unit/test_spin.py
 tests/unit/test_staleness.py
 tests/unit/test_store.py

boost_skill_cli-1.0.95/docs/roadmap/items/extract-mcp-http-servers-out-of-configuration-py.md ADDED Viewed

@@ -0,0 +1,26 @@
+---
+id: extract-mcp-http-servers-out-of-configuration-py
+board: code
+section: shipped
+status: shipped
+category: Tech-debt
+complexity: L
+impact: High
+wow: 4
+note: two servers now testable in core
+order: 5
+owner: loop/extract-serve-mcp
+pr: 106
+title: Extract MCP + HTTP servers out of <code>configuration.py</code>
+---
+~200 lines implementing a full HTTP catalog server <b>and</b> a JSON-RPC 2.0 MCP
+server lived inside the "configuration" command module — nearly untestable in
+place. The JSON-RPC protocol now lives in <code>core/mcp.py</code> as a <em>pure</em>
+<code>handle_request(req, *, version, registry)</code> plus a
+<code>serve_stdio()</code> loop with injectable stdin/stdout; the HTTP server
+moved to a new <code>core/serve.py</code> with a pure <code>route()</code>
+function, <code>serve_page()</code>/<code>skill_text()</code>, and
+<code>serve_http()</code>. <code>cmd_serve</code> and <code>cmd_mcp --stdio</code>
+became thin wrappers. Behavior is preserved exactly (the full-server and
+stdio-protocol functional tests pass unchanged) and the extracted core is pinned
+by new unit tests covering every branch.

boost-skill-cli 1.0.93__tar.gz → 1.0.95__tar.gz

boost-skill-cli 1.0.93tar.gz → 1.0.95tar.gz