baudrier 0.2.2__tar.gz

baudrier-0.2.2/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+node_modules/
+.next/
+.env
+.cache/
+.superpowers/
+test-results/
+playwright-report/
+.env.*
+!.env.example
+!deploy/.env.prod.example

baudrier-0.2.2/LICENSE

@@ -0,0 +1,28 @@
+Baudrier CLI - Proprietary Licence (draft, to be reviewed)
+
+Copyright (c) 2026 Jonathan Mondaut. All rights reserved.
+
+1. Grant. You may install and use this software (the "CLI") solely to access and
+   use the Baudrier service.
+
+2. Restrictions. You may not redistribute, sublicense, sell, resell or rent the CLI;
+   modify it for the purpose of redistribution; or reverse engineer, decompile or
+   attempt to extract the source or workings of the Baudrier service.
+
+3. Ownership. The CLI and the Baudrier service remain the property of the copyright
+   holder. No rights are granted except those stated above.
+
+4. No warranty. The CLI is provided "as is", without warranty of any kind, express
+   or implied, including merchantability, fitness for a particular purpose and
+   non-infringement.
+
+5. Limitation of liability. To the maximum extent permitted by law, the copyright
+   holder is not liable for any indirect, incidental or consequential damages, or
+   for any loss of data or profits, arising from the use of the CLI. Total
+   liability is limited to the amount you paid for the Baudrier service in the
+   twelve months before the claim (zero for free beta use).
+
+6. Termination. This licence ends automatically if you breach it.
+
+7. Governing law. This licence is governed by French law. Courts of France have
+   jurisdiction, subject to any mandatory consumer protection rules.

baudrier-0.2.2/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.5
+Name: baudrier
+Version: 0.2.2
+Summary: Baudrier CLI: connect projects to your AI coding harness and validate harness repositories
+Project-URL: Homepage, https://jack-of-all-trades.dev
+License: Baudrier CLI - Proprietary Licence (draft, to be reviewed)
+        
+        Copyright (c) 2026 Jonathan Mondaut. All rights reserved.
+        
+        1. Grant. You may install and use this software (the "CLI") solely to access and
+           use the Baudrier service.
+        
+        2. Restrictions. You may not redistribute, sublicense, sell, resell or rent the CLI;
+           modify it for the purpose of redistribution; or reverse engineer, decompile or
+           attempt to extract the source or workings of the Baudrier service.
+        
+        3. Ownership. The CLI and the Baudrier service remain the property of the copyright
+           holder. No rights are granted except those stated above.
+        
+        4. No warranty. The CLI is provided "as is", without warranty of any kind, express
+           or implied, including merchantability, fitness for a particular purpose and
+           non-infringement.
+        
+        5. Limitation of liability. To the maximum extent permitted by law, the copyright
+           holder is not liable for any indirect, incidental or consequential damages, or
+           for any loss of data or profits, arising from the use of the CLI. Total
+           liability is limited to the amount you paid for the Baudrier service in the
+           twelve months before the claim (zero for free beta use).
+        
+        6. Termination. This licence ends automatically if you breach it.
+        
+        7. Governing law. This licence is governed by French law. Courts of France have
+           jurisdiction, subject to any mandatory consumer protection rules.
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: fastmcp<5,>=4.0
+Requires-Dist: jsonschema>=4.21
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: verify
+Description-Content-Type: text/markdown
+
+# baudrier
+
+The command-line client for [Baudrier](https://jack-of-all-trades.dev): it connects a project folder to your
+Baudrier harness so your AI coding agents (Claude Code, Codex, Gemini CLI, Copilot) get the right instructions
+and skills, and it can validate harness repositories.
+
+## Install
+
+```bash
+uv tool install baudrier
+```
+
+## Quick start
+
+```bash
+baudrier login                  # sign in with your browser
+baudrier init --slug <slug>     # connect this project folder
+baudrier validate .             # validate a harness repository
+```
+
+The CLI talks to the hosted service (`https://api.baudrier-ai.com`) by default; pass `--url` only for another server.
+
+Run `baudrier --help` for all commands. Documentation: https://jack-of-all-trades.dev
+
+## Licence
+
+Proprietary, all rights reserved. See `LICENSE`. Use is permitted to access the Baudrier service.

baudrier-0.2.2/README.md

@@ -0,0 +1,27 @@
+# baudrier
+
+The command-line client for [Baudrier](https://jack-of-all-trades.dev): it connects a project folder to your
+Baudrier harness so your AI coding agents (Claude Code, Codex, Gemini CLI, Copilot) get the right instructions
+and skills, and it can validate harness repositories.
+
+## Install
+
+```bash
+uv tool install baudrier
+```
+
+## Quick start
+
+```bash
+baudrier login                  # sign in with your browser
+baudrier init --slug <slug>     # connect this project folder
+baudrier validate .             # validate a harness repository
+```
+
+The CLI talks to the hosted service (`https://api.baudrier-ai.com`) by default; pass `--url` only for another server.
+
+Run `baudrier --help` for all commands. Documentation: https://jack-of-all-trades.dev
+
+## Licence
+
+Proprietary, all rights reserved. See `LICENSE`. Use is permitted to access the Baudrier service.

baudrier-0.2.2/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "baudrier"
+version = "0.2.2"
+description = "Baudrier CLI: connect projects to your AI coding harness and validate harness repositories"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"
+dependencies = ["pydantic>=2.7", "pyyaml>=6.0", "jsonschema>=4.21", "fastmcp>=4.0,<5"]
+classifiers = [
+  "License :: Other/Proprietary License",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Environment :: Console",
+]
+
+[project.urls]
+Homepage = "https://jack-of-all-trades.dev"
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+verify = []  # kept so older `baudrier[verify]` install lines still resolve; fastmcp is a default dependency
+
+[project.scripts]
+baudrier = "baudrier_core.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/baudrier_core"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = ["slow: builds and installs the wheel in a clean venv (packaging guard)"]

baudrier-0.2.2/src/baudrier_core/__init__.py

@@ -0,0 +1,9 @@
+from baudrier_core.errors import BaudrierError, HarnessResolutionError, HarnessValidationError
+from baudrier_core.hashing import tree_hash
+from baudrier_core.models import ResolvedHarness, ResolvedSkill
+from baudrier_core.resolver import load_harness, resolve_harness_at, validate_harness
+
+__all__ = [
+    "BaudrierError", "HarnessResolutionError", "HarnessValidationError", "ResolvedHarness",
+    "ResolvedSkill", "load_harness", "resolve_harness_at", "tree_hash", "validate_harness",
+]

baudrier-0.2.2/src/baudrier_core/account.py

@@ -0,0 +1,250 @@
+"""The CLI's REST client for the account routes (stdlib only: no new dependency)."""
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import re
+import socket
+import time
+import urllib.error
+import urllib.request
+import webbrowser
+
+from baudrier_core import credentials
+from baudrier_core.errors import BaudrierError
+
+TIMEOUT_S = 15
+
+
+class AccountError(BaudrierError):
+    pass
+
+
+class NotLoggedIn(AccountError):
+    pass
+
+
+def default_label() -> str:
+    return f"{socket.gethostname().split('.')[0]} cli"[:100]
+
+
+def clean_label(text: str | None) -> str:
+    cleaned = "".join(c for c in (text or "") if c.isprintable()).strip()[:100].strip()
+    return cleaned or default_label()
+
+
+def _scrub(text: str, token: str | None) -> str:
+    return text.replace(token, "***") if token else text
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    """Never follow a redirect: urllib would resend the Authorization header to whatever host it names."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):  # noqa: PLR0913 (urllib's signature)
+        return None
+
+
+_OPENER = urllib.request.build_opener(_NoRedirect)
+
+
+def _version() -> str:
+    try:
+        return importlib.metadata.version("baudrier")
+    except importlib.metadata.PackageNotFoundError:
+        return "dev"
+
+
+USER_AGENT = f"baudrier/{_version()}"
+
+
+def _open(req: urllib.request.Request, timeout: float):
+    return _OPENER.open(req, timeout=timeout)
+
+
+def _need(data: object, *keys: str) -> dict:
+    """The JSON object with these keys, or an AccountError (never a KeyError) when the server sent something else."""
+    if not isinstance(data, dict) or any(k not in data for k in keys):
+        raise AccountError(f"unexpected answer from the server (missing {', '.join(keys)})")
+    return data
+
+
+def request(method: str, url: str, *, token: str | None = None, body: object = None,
+            headers: dict | None = None, timeout: float | None = None) -> tuple[int, object]:
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(url, data=data, method=method)
+    req.add_header("User-Agent", USER_AGENT)  # Cloudflare blocks urllib's default one (error 1010)
+    req.add_header("Accept", "application/json")
+    if data is not None:
+        req.add_header("Content-Type", "application/json")
+    if token:
+        req.add_header("Authorization", f"Bearer {token}")
+    for k, v in (headers or {}).items():
+        req.add_header(k, v)
+    try:
+        with _open(req, TIMEOUT_S if timeout is None else timeout) as resp:
+            raw = resp.read()
+            return resp.status, (json.loads(raw) if raw else None)
+    except urllib.error.HTTPError as exc:
+        if 300 <= exc.code < 400:
+            location = _scrub(str(exc.headers.get("Location", "")), token)
+            raise AccountError(f"the server redirected to {location}; use that as --url") from None
+        try:
+            return exc.code, json.loads(exc.read() or b"null")
+        except ValueError:
+            return exc.code, None
+    except (urllib.error.URLError, OSError, ValueError) as exc:
+        reason = getattr(exc, "reason", exc)
+        raise AccountError(_scrub(f"cannot reach {url.split('/api/')[0]}: {reason}", token)) from None
+
+
+def _detail(data: object, status: int) -> str:
+    d = data.get("detail") if isinstance(data, dict) else None
+    if isinstance(d, list):
+        d = "; ".join(str(x.get("msg", x)) if isinstance(x, dict) else str(x) for x in d)
+    return str(d or f"HTTP {status}")
+
+
+def call(base: str, method: str, path: str, *, token: str, body: object = None) -> object:
+    status, data = request(method, credentials.norm_url(base) + path, token=token, body=body)
+    if status == 401:
+        raise NotLoggedIn("not logged in, or your login expired: run `baudrier login`")
+    if status >= 400:
+        raise AccountError(_scrub(_detail(data, status), token))
+    return data
+
+
+def _say(text: str) -> None:
+    print(text, flush=True)  # the code must show at once even when stdout is a pipe or a file (no TTY)
+
+
+def login(base: str, label: str, *, open_browser: bool = True, out=_say, sleep=time.sleep,
+          clock=time.monotonic) -> dict:
+    base = credentials.norm_url(base)
+    status, d = request("POST", f"{base}/api/cli/device", body={"label": label})
+    if status != 200 or not isinstance(d, dict):
+        raise AccountError(f"could not start the login: {_detail(d, status)}")
+    _need(d, "device_code", "user_code", "verification_uri", "verification_uri_complete")
+    out(f"Open {d['verification_uri']} and check that it shows the code {d['user_code']}")
+    if open_browser:
+        try:
+            webbrowser.open(d["verification_uri_complete"])
+        except webbrowser.Error:
+            pass
+    interval = int(d.get("interval", 5))
+    deadline = clock() + int(d.get("expires_in", 600))
+    while clock() < deadline:
+        sleep(interval)
+        status, r = request("POST", f"{base}/api/cli/device/token", body={"device_code": d["device_code"]})
+        if status == 429:
+            interval += 5
+            continue
+        if status >= 400 or not isinstance(r, dict):
+            raise AccountError(f"login failed: {_detail(r, status)}")
+        if r.get("status") == "approved":
+            _need(r, "token", "login", "expires_at")
+            credentials.set_account(base, r["token"], r["login"], r["expires_at"])
+            return {"login": r["login"], "expires_at": r["expires_at"]}
+        if r.get("status") == "denied":
+            raise AccountError("the login was denied in the browser")
+        if r.get("status") == "expired":
+            break
+    raise AccountError("the code expired; run `baudrier login` again")
+
+
+def logout(base: str, projects: bool = False) -> None:
+    acc = credentials.account(base)
+    if acc and acc.get("token"):
+        try:
+            request("DELETE", credentials.norm_url(base) + "/api/account/tokens/current", token=acc["token"])
+        except AccountError:
+            pass  # best effort: forget it locally anyway
+    credentials.clear_account(base, projects=projects)
+
+
+def whoami(base: str) -> dict:
+    token = credentials.account_token(base)
+    if not token:
+        raise NotLoggedIn("not logged in, or your login expired: run `baudrier login`")
+    me = _need(call(base, "GET", "/api/auth/me", token=token), "login")
+    acc = credentials.account(base) or {}
+    return {"login": me["login"], "url": credentials.norm_url(base), "expires_at": acc.get("expires_at", "")}
+
+
+_REPO_REF = re.compile(
+    r"^(?:https?://)?github\.com/(?P<repo>[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+?)(?:\.git)?"
+    r"(?:/(?P<path>[^@#]+?))?/?(?:@(?P<ref>[^#@]+))?(?:#(?P<name>[^#]+))?$")
+# `owner/repo[/<path>][@<ref>][#<name>]` without the host: GitHub owners have no dots, so `gitlab.com/a/b` stays rejected.
+_SHORT_REF = re.compile(
+    r"^(?P<repo>[A-Za-z0-9-]+/[A-Za-z0-9_.-]+?)(?:\.git)?"
+    r"(?:/(?P<path>[^@#]+?))?/?(?:@(?P<ref>[^#@]+))?(?:#(?P<name>[^#]+))?$")
+_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$")
+
+
+def parse_harness_ref(ref: str) -> dict:
+    ref = ref.strip()
+    m = _REPO_REF.match(ref) or _SHORT_REF.match(ref)
+    if m:
+        return {"kind": "repo", "repo": m["repo"], "path": m["path"], "ref": m["ref"], "name": m["name"]}
+    if "/" not in ref and _NAME.match(ref):
+        return {"kind": "name", "name": ref}
+    raise AccountError(f"{ref!r} is neither a harness name nor [github.com/]<owner>/<repo>[/<path>][@<ref>][#<name>]")
+
+
+def find_project(base: str, token: str, slug: str) -> dict:
+    for p in call(base, "GET", "/api/projects", token=token):
+        if p["slug"] == slug:
+            return p
+    raise AccountError(f"no project {slug!r} in your account; create it with `baudrier project create`")
+
+
+def create_project(base: str, token: str, name: str, slug: str | None) -> dict:
+    return call(base, "POST", "/api/projects", token=token, body={"name": name, "slug": slug})
+
+
+def _pick(base: str, token: str, ref: dict) -> dict:
+    if ref["kind"] == "name":
+        matches = [h for h in call(base, "GET", "/api/harnesses", token=token) if h["name"] == ref["name"]]
+        if not matches:
+            raise AccountError(f"no harness named {ref['name']!r} in your Library; add its repo with "
+                               "`baudrier add harness github.com/<owner>/<repo>`")
+        if len(matches) > 1:
+            where = ", ".join(f"{h['repo']}/{h['path']}".rstrip("/") for h in matches)
+            raise AccountError(f"several harnesses are named {ref['name']!r} ({where}); use "
+                               f"github.com/<owner>/<repo>#{ref['name']} to choose")
+        return matches[0]
+    body = {"repo": ref["repo"], "ref": ref["ref"] or "main"}
+    if ref["path"]:
+        body["path"] = ref["path"]
+    found = call(base, "POST", "/api/sources", token=token, body=body)
+    if ref["name"]:
+        found = [h for h in found if h["name"] == ref["name"]]
+        if not found:
+            raise AccountError(f"{ref['repo']} has no harness named {ref['name']!r}")
+    if len(found) > 1:
+        names = ", ".join(h["name"] for h in found)
+        raise AccountError(f"{ref['repo']} has several harnesses ({names}); pick one with #<name>")
+    return found[0]
+
+
+def add_harnesses(base: str, token: str, slug: str, refs: list[str]) -> list[str]:
+    parsed = [parse_harness_ref(r) for r in refs]  # all refs are checked before anything is attached
+    project = find_project(base, token, slug)
+    names = []
+    for ref in parsed:
+        h = _pick(base, token, ref)
+        call(base, "POST", f"/api/projects/{project['id']}/harnesses", token=token, body={"harness_id": h["id"]})
+        names.append(h["name"])
+    return names
+
+
+def ensure_project_token(base: str, slug: str, label: str) -> bool:
+    if credentials.project_token(base, slug):
+        return False
+    token = credentials.account_token(base)
+    if not token:
+        raise NotLoggedIn("no token for this project: run `baudrier login` first (or set BAUDRIER_TOKEN)")
+    project = find_project(base, token, slug)
+    created = _need(call(base, "POST", f"/api/projects/{project['id']}/tokens", token=token, body={"label": label}),
+                    "token")
+    credentials.set_project_token(base, slug, created["token"])
+    return True