agent-bios 0.18.0 → 0.19.0

package/compose/corpus_ui_runtime.py

@@ -0,0 +1,278 @@
+"""Load the shipped pure-Python UI wheels offline into one process-owned directory."""
+from __future__ import annotations
+
+import atexit
+from email.parser import BytesParser
+import hashlib
+import importlib
+import io
+import json
+from pathlib import Path, PurePosixPath
+import re
+import stat
+import sys
+import tempfile
+import threading
+from typing import Any
+import zipfile
+import zlib
+
+
+SCHEMA_VERSION = 1
+MAX_ARCHIVE_BYTES = 32 * 1024 * 1024
+MAX_EXPANDED_BYTES = 128 * 1024 * 1024
+_LOCK = threading.RLock()
+_ACTIVE: tuple[str, tempfile.TemporaryDirectory[str]] | None = None
+
+
+class UiRuntimeError(RuntimeError):
+    pass
+
+
+def _canonical(value: Any) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def _bundle_id(manifest: dict[str, Any]) -> str:
+    return hashlib.sha256(_canonical({key: value for key, value in manifest.items() if key != "bundle_id"})).hexdigest()
+
+
+def _normalized_name(name: str) -> str:
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def _members(archive: zipfile.ZipFile) -> list[zipfile.ZipInfo]:
+    result = []
+    seen = set()
+    expanded = 0
+    for info in archive.infolist():
+        raw = info.filename.rstrip("/")
+        path = PurePosixPath(raw)
+        if not raw or path.is_absolute() or "\\" in raw or path.as_posix() != raw \
+                or any(part in {".", ".."} for part in path.parts) \
+                or any(ord(character) < 32 or ord(character) == 127 for character in raw):
+            raise UiRuntimeError(f"unsafe UI wheel member: {info.filename!r}")
+        if raw in seen:
+            raise UiRuntimeError(f"duplicate UI wheel member: {raw}")
+        seen.add(raw)
+        mode = info.external_attr >> 16
+        if stat.S_ISLNK(mode) or (stat.S_IFMT(mode) not in {0, stat.S_IFREG, stat.S_IFDIR}):
+            raise UiRuntimeError(f"non-regular UI wheel member: {raw}")
+        if info.is_dir():
+            continue
+        if info.flag_bits & 1:
+            raise UiRuntimeError(f"encrypted UI wheel member: {raw}")
+        if path.suffix.lower() in {".so", ".pyd", ".dll", ".dylib", ".pth", ".pyc"} \
+                or path.parts[0].endswith(".data"):
+            raise UiRuntimeError(f"UI wheel requires unsupported installation behavior: {raw}")
+        expanded += info.file_size
+        if expanded > MAX_EXPANDED_BYTES:
+            raise UiRuntimeError("UI wheel exceeds the extraction size limit")
+        result.append(info)
+    if not result:
+        raise UiRuntimeError("UI wheel has no files")
+    return result
+
+
+def wheel_metadata(filename: str, data: bytes) -> dict[str, Any]:
+    """Read wheel metadata and licensing without importing its Python code."""
+    if Path(filename).name != filename or not re.fullmatch(r"[A-Za-z0-9_.!+-]+-py[0-9.]+-none-any\.whl", filename):
+        raise UiRuntimeError(f"UI runtime requires a pure Python universal wheel: {filename}")
+    if not data or len(data) > MAX_ARCHIVE_BYTES:
+        raise UiRuntimeError(f"invalid UI wheel size: {filename}")
+    try:
+        with zipfile.ZipFile(io.BytesIO(data)) as archive:
+            members = _members(archive)
+            names = {member.filename for member in members}
+            metadata_paths = [name for name in names if name.endswith(".dist-info/METADATA")]
+            if len(metadata_paths) != 1:
+                raise UiRuntimeError(f"UI wheel needs exactly one distribution metadata file: {filename}")
+            metadata_path = metadata_paths[0]
+            info_root = metadata_path.rsplit("/", 1)[0]
+            wheel_path = info_root + "/WHEEL"
+            if wheel_path not in names:
+                raise UiRuntimeError(f"UI wheel lacks WHEEL metadata: {filename}")
+            metadata = BytesParser().parsebytes(archive.read(metadata_path))
+            wheel = BytesParser().parsebytes(archive.read(wheel_path))
+            tags = wheel.get_all("Tag", [])
+            if wheel.get("Root-Is-Purelib", "").lower() != "true" or not tags \
+                    or any(not re.fullmatch(r"py[0-9.]+-none-any", tag) for tag in tags):
+                raise UiRuntimeError(f"UI wheel is not pure Python: {filename}")
+            license_files = sorted(name for name in names if name.startswith(info_root + "/") and (
+                "/licenses/" in name.lower() or PurePosixPath(name).name.lower().startswith(("license", "licence", "copying"))))
+            if not license_files or any(not archive.read(name).strip() for name in license_files):
+                raise UiRuntimeError(f"UI wheel lacks an upstream license: {filename}")
+            modules = set()
+            for name in names:
+                parts = PurePosixPath(name).parts
+                if parts[0].endswith(".dist-info"):
+                    continue
+                root = parts[0][:-3] if len(parts) == 1 and parts[0].endswith(".py") else parts[0]
+                if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", root):
+                    modules.add(root)
+            name, version = metadata.get("Name"), metadata.get("Version")
+            if not isinstance(name, str) or not re.fullmatch(r"[A-Za-z0-9_.-]+", name) \
+                    or not isinstance(version, str) or not re.fullmatch(r"[A-Za-z0-9_.!+]+", version) or not modules:
+                raise UiRuntimeError(f"invalid UI distribution metadata: {filename}")
+            return {"name": _normalized_name(name), "version": version, "filename": filename,
+                    "sha256": hashlib.sha256(data).hexdigest(), "size_bytes": len(data),
+                    "expanded_bytes": sum(member.file_size for member in members),
+                    "modules": sorted(modules), "license_files": license_files,
+                    "requires_python": metadata.get("Requires-Python", ""),
+                    "requires_dist": metadata.get_all("Requires-Dist", [])}
+    except (zipfile.BadZipFile, KeyError, OSError, UnicodeError, RuntimeError, ValueError, EOFError, zlib.error) as exc:
+        if isinstance(exc, UiRuntimeError):
+            raise
+        raise UiRuntimeError(f"cannot read UI wheel {filename}: {exc}") from exc
+
+
+def _read_bundle(repo: Path) -> tuple[dict[str, Any], list[tuple[dict[str, Any], bytes]]]:
+    bundle = Path(repo) / "compose/ui_runtime"
+    manifest_path = bundle / "manifest.json"
+    if bundle.is_symlink() or manifest_path.is_symlink() or not manifest_path.is_file():
+        raise UiRuntimeError("bundled UI runtime manifest is missing or unsafe; reinstall the agent-bios package")
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        raise UiRuntimeError(f"cannot read UI runtime manifest: {exc}") from exc
+    if not isinstance(manifest, dict) or manifest.get("schema_version") != SCHEMA_VERSION \
+            or manifest.get("python_requirement") != ">=3.11" or manifest.get("source") != "pypi":
+        raise UiRuntimeError("unsupported UI runtime manifest")
+    if manifest.get("bundle_id") != _bundle_id(manifest):
+        raise UiRuntimeError("UI runtime manifest fingerprint mismatch")
+    requirements = manifest.get("root_requirement")
+    rows = manifest.get("packages")
+    if not isinstance(requirements, str) or not re.fullmatch(r"textual==[0-9][A-Za-z0-9_.!+]*", requirements) \
+            or not isinstance(rows, list) or not rows:
+        raise UiRuntimeError("UI runtime manifest has no valid package inventory")
+    supplied = set()
+    filenames = set()
+    modules = set()
+    files = set()
+    expanded = 0
+    archives = []
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("filename"), str):
+            raise UiRuntimeError("UI runtime manifest has an invalid package row")
+        filename = row["filename"]
+        if Path(filename).name != filename or filename in filenames:
+            raise UiRuntimeError(f"invalid or duplicate UI wheel name: {filename}")
+        path = bundle / filename
+        if path.is_symlink() or not path.is_file():
+            raise UiRuntimeError(f"bundled UI wheel missing or unsafe: {filename}")
+        if path.stat().st_size != row.get("size_bytes") or path.stat().st_size > MAX_ARCHIVE_BYTES:
+            raise UiRuntimeError(f"UI wheel size mismatch: {filename}")
+        data = path.read_bytes()
+        if hashlib.sha256(data).hexdigest() != row.get("sha256"):
+            raise UiRuntimeError(f"UI wheel SHA256 mismatch: {filename}")
+        actual = wheel_metadata(filename, data)
+        if actual != row:
+            raise UiRuntimeError(f"UI wheel metadata differs from its manifest: {filename}")
+        if row["name"] in supplied or modules.intersection(row["modules"]):
+            raise UiRuntimeError(f"UI distributions overlap: {filename}")
+        supplied.add(row["name"])
+        filenames.add(filename)
+        modules.update(row["modules"])
+        with zipfile.ZipFile(io.BytesIO(data)) as archive:
+            names = {member.filename for member in _members(archive)}
+        if files.intersection(names):
+            raise UiRuntimeError(f"UI wheel paths overlap: {filename}")
+        files.update(names)
+        expanded += row["expanded_bytes"]
+        if expanded > MAX_EXPANDED_BYTES:
+            raise UiRuntimeError("UI runtime exceeds the extraction size limit")
+        archives.append((row, data))
+    if {path.name for path in bundle.iterdir() if path.name != "manifest.json"} != filenames:
+        raise UiRuntimeError("UI runtime directory differs from its exact wheel inventory")
+    if not any(f"{row['name']}=={row['version']}" == requirements for row in rows):
+        raise UiRuntimeError("UI runtime root Textual requirement is not present")
+    return manifest, archives
+
+
+def runtime_inventory(repo: Path) -> dict[str, Any]:
+    """Report bundled hashes, purity, and licenses without extraction or UI imports."""
+    try:
+        manifest, _archives = _read_bundle(repo)
+    except (UiRuntimeError, OSError) as exc:
+        return {"schema_version": SCHEMA_VERSION, "status": "unavailable", "issues": [str(exc)], "packages": []}
+    return {**manifest, "status": "available", "issues": [],
+            "package_count": len(manifest["packages"]),
+            "size_bytes": sum(row["size_bytes"] for row in manifest["packages"]),
+            "expanded_bytes": sum(row["expanded_bytes"] for row in manifest["packages"]),
+            "license_file_count": sum(len(row["license_files"]) for row in manifest["packages"]),
+            "pure_python": True}
+
+
+def _preloaded_modules(modules: set[str], active: Path | None) -> list[str]:
+    conflicts = []
+    for name, module in tuple(sys.modules.items()):
+        if name.split(".", 1)[0] not in modules:
+            continue
+        filename = getattr(module, "__file__", None)
+        if active is not None and isinstance(filename, str):
+            try:
+                Path(filename).resolve().relative_to(active)
+                continue
+            except (ValueError, OSError):
+                pass
+        conflicts.append(name)
+    return sorted(conflicts)
+
+
+def _cleanup_runtime() -> None:
+    global _ACTIVE
+    if _ACTIVE is not None:
+        _bundle, temporary = _ACTIVE
+        sys.path[:] = [entry for entry in sys.path if entry != temporary.name]
+        temporary.cleanup()
+        _ACTIVE = None
+
+
+def release_ui_runtime() -> None:
+    """Release owned files immediately before process handoff; UI reuse needs a fresh process."""
+    with _LOCK:
+        _cleanup_runtime()
+
+
+def activate_ui_runtime(repo: Path) -> Path:
+    """Activate only verified shipped modules; imports must follow this call."""
+    global _ACTIVE
+    if sys.version_info < (3, 11):
+        raise UiRuntimeError("the bundled UI runtime requires Python 3.11 or newer")
+    with _LOCK:
+        manifest, archives = _read_bundle(repo)
+        if _ACTIVE is not None and _ACTIVE[0] != manifest["bundle_id"]:
+            raise UiRuntimeError("another UI bundle is active; start a fresh process for this agent-bios package")
+        active = Path(_ACTIVE[1].name).resolve() if _ACTIVE is not None else None
+        names = {name for row, _data in archives for name in row["modules"]}
+        conflicts = _preloaded_modules(names, active)
+        if conflicts:
+            raise UiRuntimeError("UI dependencies were imported before bundled activation: " + ", ".join(conflicts[:8])
+                                 + "; start a fresh process and activate the bundle before importing UI modules")
+        if active is not None:
+            if not active.is_dir():
+                raise UiRuntimeError("the active UI runtime directory is missing; start a fresh process")
+            return active
+        parent = Path(tempfile.gettempdir()).resolve()
+        home = Path.home().resolve()
+        if parent == home or home in parent.parents:
+            parent = Path("/tmp").resolve()
+        temporary = tempfile.TemporaryDirectory(prefix="agent-bios-ui-", dir=parent)
+        target = Path(temporary.name)
+        try:
+            for _row, data in archives:
+                with zipfile.ZipFile(io.BytesIO(data)) as archive:
+                    for member in _members(archive):
+                        path = target.joinpath(*PurePosixPath(member.filename).parts)
+                        path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+                        with path.open("xb") as output:
+                            output.write(archive.read(member))
+                        path.chmod(0o600)
+            sys.path.insert(0, str(target))
+            importlib.invalidate_caches()
+            _ACTIVE = (manifest["bundle_id"], temporary)
+            atexit.register(_cleanup_runtime)
+            return target
+        except BaseException:
+            temporary.cleanup()
+            raise

package/compose/setup/START.md

@@ -0,0 +1,147 @@
+# Set up agent-bios through conversation
+
+This guide uses the same installation controller as the terminal wizard. The
+conversation collects choices and presents effects; `setup` validates and executes
+them. It needs local command and file access on the intended machine, Bash, and
+Python 3.11 or newer. Codex CLI, an additional model login, and Textual are not
+requirements for this route.
+
+## Start without an installed skill
+
+The user can request installation using the public repository link. Follow the
+repository's root `INSTALL.md` to obtain and verify the source, select the language
+and run `setup start`. The agent resolves paths; the user does not need a checkout,
+an installed skill or a long installation prompt. An explicitly selected trusted
+local source remains valid. Preserve the acquisition's exact revision and location
+for the review and any resume. If the selected public revision lacks conversation
+setup, report that limitation instead of invoking an older installation route.
+
+## Choose the entrypoint and language
+
+For an already registered app bridge, run `python3 "$BRIDGE" setup start`, where
+`BRIDGE` is the absolute helper path beside the loaded skill. Read the returned
+`guide_path`. For an acquired source, use the verified `setup_argv` from its start
+response. Keep using that entrypoint and the reported private roots throughout
+the review. Shell variables from one app tool call do not persist to the next;
+pass absolute arguments or set the variable in the same call.
+
+`start` returns language choices, a suggested language and execution context without
+probing dependencies or creating private setup state. Confirm English, 한국어 or
+日本語, honoring an explicit language already chosen by the user, before `inspect`.
+Use the selected language for questions and explanations; retain identifiers,
+paths, versions, raw diagnostics and command arguments exactly. Use a native
+question control when the current host exposes one for this interaction, or ask
+ordinary concise questions. The conversation does not require custom widgets.
+
+The commands below use `agent-bios` as shorthand for that verified entrypoint. In
+an app bridge call, replace `agent-bios setup` with `python3 "$BRIDGE" setup`.
+
+```bash
+agent-bios setup inspect --language ko
+agent-bios setup discover --project-root /absolute/project
+```
+
+## Collect and review the choices
+
+Use `inspect`'s `default_plan`, inventory and choices. Present all dependency
+capabilities with readiness, purpose and installation destination. Only returned
+installation recipes are selectable; do not create shell recipes from model
+memory. A dependency's presence does not authorize installing another one.
+
+Collect the six plan fields without asking the user to author JSON:
+
+- `selection_mode` and `targets`: keep saved policy, no active corpus, all available
+  corpus, or specific returned package/domain/item targets. Start from the returned
+  default. No active corpus retains private library assets but delivers no corpus.
+- `dependencies`: chosen installable inventory IDs; an empty list installs none.
+- `app_bridge`: explicit registration choice; registration enables discovery only.
+- `project_roots` and `import_paths`: absolute project folders and explicitly
+  selected files from discovery. Capture is independent of corpus selection.
+
+Keep saved policy uses `selection_mode: null` and `targets: null`. No active corpus
+uses `"none"` and `[]`. Explicit choices use `"selected"` and their target list;
+all available corpus uses `"selected"` and `["all"]`.
+
+Discovery checks known global instruction locations and the specified project
+roots. Show detected sources before selecting them. Capture preserves originals
+and prepares private evidence for later model review; it is not an automatically
+optimized personal corpus. Read the import procedure only when the user requests
+that subsequent review.
+
+Save choices to a new caller-owned artifact. Run `plan` and save its complete
+stdout bytes to another new caller-owned artifact:
+
+```bash
+agent-bios setup plan --language ko --input /absolute/choices.json > /absolute/review.json
+```
+
+The returned review envelope contains `review_id`, `context`, `language`,
+`preview` and `summary`. Keep the entire envelope; do not reconstruct it from the
+summary, copy only `preview`, change its IDs, or accept truncated output. Show the
+concrete private paths, selected dependency commands/destinations, corpus policy,
+app discovery change and selected capture sources. Keep the exact artifact
+available for inspection. Preparing these caller-owned files is separate from
+applying installation effects.
+
+Apply the saved envelope only when its concrete choices are authorized. Existing
+authorization for those exact choices does not require another confirmation.
+
+```bash
+agent-bios setup apply --input /absolute/review.json --review-id REVIEW_ID --yes
+```
+
+The engine checks the reviewed context, source bytes, private state and package
+before its effects. If the review is stale, show a fresh plan and explain the
+changed effects; do not bypass checks. Report completed dependencies, private
+installation, bridge registration and pending import separately. A partial failure
+or cancellation does not roll back completed external package installations.
+
+## Continue or resume
+
+```bash
+agent-bios setup status --review-id REVIEW_ID
+agent-bios setup resume --review-id REVIEW_ID
+```
+
+These commands do not execute the remaining installation. `status` reports the
+recorded attempt in `receipt`, `result` and `state`; a past `complete` result does
+not establish the current runtime's health. Inspect `handoff` for current readiness
+and any `needs_action`. Package verification, full runtime verification and helper
+verification are independent observations; one does not prove the others.
+`replayed: true` means the existing attempt was returned without executing it again.
+If `handoff.verification` is `"deferred"`, its readiness fields are null: they are
+unverified, not false. Status can return recorded progress while setup holds the
+private-state lock. Follow `needs_action` and retry status when that operation has
+settled; require checked readiness before using a handoff to continue.
+
+`resume` adds `remaining_plan`, `review` and `needs_action`. When `review` is
+non-null, save that entire nested review object to a new caller-owned JSON artifact
+using deterministic JSON extraction. Do not pass the enclosing status response or
+`remaining_plan` to Apply. Preserve every review field, including `continuation`,
+and use the nested review's own `review_id`. Review its remaining effects before
+applying within the user's authorization. If `review` is null, inspect the stated
+reason; unknown prior effects are not permission to replay package installation.
+When `resumed_from` is present, the response has followed a receipt's `continued_by`
+link to an existing continuation. Report the returned child `review_id` rather than
+assuming the original ID is current.
+
+After an explicit app registration succeeds, use `handoff.helper_argv` only when
+`helper_usable` is true, appending `setup` and the desired operation.
+`helper_verified` confirms helper bytes, while `helper_usable` also requires a
+verified package and no pending work blocking it. Otherwise inspect `needs_action`
+and current readiness before continuing. A usable helper can continue in this task
+even if native skill discovery has not refreshed. Without a
+verified helper, a verified runtime's `setup_argv` already includes `setup`;
+`cli_argv` does not. Supply the returned `environment` with each call. These arrays
+are command arguments, not shell snippets. Finish applying an existing review
+through its reviewed entrypoint/context; changing entrypoints requires a fresh
+review. Status and subsequent setup can use the verified handoff.
+Do not create a duplicate personal skill or edit host discovery settings to force
+refresh. Once discovered, `$agent-bios` is the ordinary entrypoint. Registration
+on disk is not proof of discovery or corpus loading.
+
+If capture completed, report its actual capture ID and returned next action. Its
+semantic review, proposed consumption placement and revision-checked import are
+separate from installation. Setup enables no hooks, native agent registration,
+permissions or edits to global/project instruction files. Each app task requires
+its own explicit corpus use; neither setup nor opening the app performs it.

package/compose/ui_runtime/manifest.json

@@ -0,0 +1,238 @@
+{
+  "schema_version": 1,
+  "source": "pypi",
+  "python_requirement": ">=3.11",
+  "root_requirement": "textual==8.2.8",
+  "packages": [
+    {
+      "name": "linkify-it-py",
+      "version": "2.2.0",
+      "filename": "linkify_it_py-2.2.0-py3-none-any.whl",
+      "sha256": "3adc40eb5af300b2605fcfdb968c24e1d780a90f1f2221af7c15e5111e94d443",
+      "size_bytes": 21971,
+      "expanded_bytes": 66766,
+      "modules": [
+        "linkify_it"
+      ],
+      "license_files": [
+        "linkify_it_py-2.2.0.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.10",
+      "requires_dist": [
+        "pytest; extra == \"test\"",
+        "coverage; extra == \"test\"",
+        "pytest-cov; extra == \"test\"",
+        "pytest-timeout; extra == \"test\"",
+        "pre-commit; extra == \"dev\"",
+        "isort; extra == \"dev\"",
+        "flake8; extra == \"dev\"",
+        "black; extra == \"dev\"",
+        "pyproject-flake8; extra == \"dev\"",
+        "pytest; extra == \"benchmark\"",
+        "pytest-benchmark; extra == \"benchmark\"",
+        "sphinx; extra == \"doc\"",
+        "sphinx_book_theme; extra == \"doc\"",
+        "myst-parser; extra == \"doc\""
+      ]
+    },
+    {
+      "name": "markdown-it-py",
+      "version": "4.2.0",
+      "filename": "markdown_it_py-4.2.0-py3-none-any.whl",
+      "sha256": "9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a",
+      "size_bytes": 91687,
+      "expanded_bytes": 244684,
+      "modules": [
+        "markdown_it"
+      ],
+      "license_files": [
+        "markdown_it_py-4.2.0.dist-info/licenses/LICENSE",
+        "markdown_it_py-4.2.0.dist-info/licenses/LICENSE.markdown-it"
+      ],
+      "requires_python": ">=3.10",
+      "requires_dist": [
+        "mdurl~=0.1",
+        "psutil ; extra == \"benchmarking\"",
+        "pytest ; extra == \"benchmarking\"",
+        "pytest-benchmark ; extra == \"benchmarking\"",
+        "commonmark~=0.9 ; extra == \"compare\"",
+        "markdown~=3.4 ; extra == \"compare\"",
+        "mistletoe~=1.0 ; extra == \"compare\"",
+        "mistune~=3.0 ; extra == \"compare\"",
+        "panflute~=2.3 ; extra == \"compare\"",
+        "markdown-it-pyrs ; extra == \"compare\"",
+        "linkify-it-py>=1,<3 ; extra == \"linkify\"",
+        "mdit-py-plugins>=0.5.0 ; extra == \"plugins\"",
+        "gprof2dot ; extra == \"profiling\"",
+        "mdit-py-plugins>=0.5.0 ; extra == \"rtd\"",
+        "myst-parser ; extra == \"rtd\"",
+        "pyyaml ; extra == \"rtd\"",
+        "sphinx ; extra == \"rtd\"",
+        "sphinx-copybutton ; extra == \"rtd\"",
+        "sphinx-design ; extra == \"rtd\"",
+        "sphinx-book-theme~=1.0 ; extra == \"rtd\"",
+        "jupyter_sphinx ; extra == \"rtd\"",
+        "ipykernel ; extra == \"rtd\"",
+        "coverage ; extra == \"testing\"",
+        "pytest ; extra == \"testing\"",
+        "pytest-cov ; extra == \"testing\"",
+        "pytest-regressions ; extra == \"testing\"",
+        "pytest-timeout ; extra == \"testing\"",
+        "requests ; extra == \"testing\""
+      ]
+    },
+    {
+      "name": "mdit-py-plugins",
+      "version": "0.6.1",
+      "filename": "mdit_py_plugins-0.6.1-py3-none-any.whl",
+      "sha256": "214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d",
+      "size_bytes": 66663,
+      "expanded_bytes": 172036,
+      "modules": [
+        "mdit_py_plugins"
+      ],
+      "license_files": [
+        "mdit_py_plugins-0.6.1.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.10",
+      "requires_dist": [
+        "markdown-it-py>=2.0.0,<5.0.0",
+        "pre-commit ; extra == \"code-style\"",
+        "myst-parser ; extra == \"rtd\"",
+        "sphinx-book-theme ; extra == \"rtd\"",
+        "coverage ; extra == \"testing\"",
+        "pytest ; extra == \"testing\"",
+        "pytest-cov ; extra == \"testing\"",
+        "pytest-regressions ; extra == \"testing\"",
+        "pytest-timeout ; extra == \"testing\""
+      ]
+    },
+    {
+      "name": "mdurl",
+      "version": "0.1.2",
+      "filename": "mdurl-0.1.2-py3-none-any.whl",
+      "sha256": "84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8",
+      "size_bytes": 9979,
+      "expanded_bytes": 23308,
+      "modules": [
+        "mdurl"
+      ],
+      "license_files": [
+        "mdurl-0.1.2.dist-info/LICENSE"
+      ],
+      "requires_python": ">=3.7",
+      "requires_dist": []
+    },
+    {
+      "name": "platformdirs",
+      "version": "4.11.8",
+      "filename": "platformdirs-4.11.8-py3-none-any.whl",
+      "sha256": "52f2f181bbfde907966932cc8312d967d02976422d66d537ea16092b8e291081",
+      "size_bytes": 24027,
+      "expanded_bytes": 129535,
+      "modules": [
+        "platformdirs"
+      ],
+      "license_files": [
+        "platformdirs-4.11.8.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.10",
+      "requires_dist": []
+    },
+    {
+      "name": "pygments",
+      "version": "2.21.0",
+      "filename": "pygments-2.21.0-py3-none-any.whl",
+      "sha256": "2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9",
+      "size_bytes": 1250147,
+      "expanded_bytes": 4621166,
+      "modules": [
+        "pygments"
+      ],
+      "license_files": [
+        "pygments-2.21.0.dist-info/licenses/AUTHORS",
+        "pygments-2.21.0.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.9",
+      "requires_dist": [
+        "colorama>=0.4.6; extra == 'windows-terminal'"
+      ]
+    },
+    {
+      "name": "rich",
+      "version": "15.0.0",
+      "filename": "rich-15.0.0-py3-none-any.whl",
+      "sha256": "33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb",
+      "size_bytes": 310654,
+      "expanded_bytes": 1245816,
+      "modules": [
+        "rich"
+      ],
+      "license_files": [
+        "rich-15.0.0.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.9.0",
+      "requires_dist": [
+        "ipywidgets (>=7.5.1,<9) ; extra == \"jupyter\"",
+        "markdown-it-py (>=2.2.0)",
+        "pygments (>=2.13.0,<3.0.0)"
+      ]
+    },
+    {
+      "name": "textual",
+      "version": "8.2.8",
+      "filename": "textual-8.2.8-py3-none-any.whl",
+      "sha256": "267375fd402dc8d981457212efa71f0e3365fd17bba144ba9bb3ed7563cb374a",
+      "size_bytes": 731418,
+      "expanded_bytes": 2827661,
+      "modules": [
+        "textual"
+      ],
+      "license_files": [
+        "textual-8.2.8.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.9,<4.0",
+      "requires_dist": [
+        "markdown-it-py[linkify] (>=2.1.0)",
+        "mdit-py-plugins",
+        "platformdirs (>=3.6.0,<5)",
+        "pygments (>=2.19.2,<3.0.0)",
+        "rich (>=14.2.0)",
+        "tree-sitter (>=0.25.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-bash (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-css (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-go (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-html (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-java (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-javascript (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-json (>=0.24.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-markdown (>=0.3.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-python (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-regex (>=0.24.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-rust (>=0.23.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-sql (>=0.3.11) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-toml (>=0.6.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-xml (>=0.7.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "tree-sitter-yaml (>=0.6.0) ; (python_version >= \"3.10\") and (extra == \"syntax\")",
+        "typing-extensions (>=4.4.0,<5.0.0)"
+      ]
+    },
+    {
+      "name": "typing-extensions",
+      "version": "4.16.0",
+      "filename": "typing_extensions-4.16.0-py3-none-any.whl",
+      "sha256": "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8",
+      "size_bytes": 45571,
+      "expanded_bytes": 182767,
+      "modules": [
+        "typing_extensions"
+      ],
+      "license_files": [
+        "typing_extensions-4.16.0.dist-info/licenses/LICENSE"
+      ],
+      "requires_python": ">=3.9",
+      "requires_dist": []
+    }
+  ],
+  "bundle_id": "f86c64655f21c67f45a1b43cf5ea16da5f4b6957a5ce0b8b222e8e8f8d2c1194"
+}