guild-cli 0.1.0__py3-none-any.whl

guild/__init__.py

@@ -0,0 +1,11 @@
+"""guild — an agent and CLI that manages skills for the AgentCulture mesh."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _v
+
+try:
+    __version__ = _v("guild-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0+local"
+
+__all__ = ["__version__"]

guild/__main__.py

@@ -0,0 +1,8 @@
+"""Allow running guild as ``python -m guild``."""
+
+import sys
+
+from guild.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

guild/cli/__init__.py

@@ -0,0 +1,86 @@
+"""Unified CLI entry point for guild.
+
+Every handler raises :class:`guild.cli._errors.GuildError` on failure;
+``main()`` catches it via :func:`_dispatch` and routes through
+:mod:`guild.cli._output`. Argparse errors route through
+``_GuildArgumentParser`` so they share the same structured output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from guild import __version__
+from guild.cli._errors import EXIT_USER_ERROR, GuildError
+from guild.cli._output import emit_error
+
+
+class _GuildArgumentParser(argparse.ArgumentParser):
+    """ArgumentParser that routes errors through :func:`emit_error`."""
+
+    def error(self, message: str) -> None:  # type: ignore[override]
+        err = GuildError(
+            code=EXIT_USER_ERROR,
+            message=message,
+            remediation=f"run '{self.prog} --help' to see valid arguments",
+        )
+        emit_error(err)
+        raise SystemExit(err.code)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    # Deferred import to avoid coupling the parser module to the command modules
+    # at import time (matches the afi-cli pattern; cheap insurance).
+    from guild.cli._commands import explain as _explain_cmd
+    from guild.cli._commands import learn as _learn_cmd
+    from guild.cli._commands import whoami as _whoami_cmd
+
+    parser = _GuildArgumentParser(
+        prog="guild",
+        description="guild — an agent and CLI that manages skills for the AgentCulture mesh",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    sub = parser.add_subparsers(dest="command", parser_class=_GuildArgumentParser)
+
+    _whoami_cmd.register(sub)
+    _learn_cmd.register(sub)
+    _explain_cmd.register(sub)
+
+    return parser
+
+
+def _dispatch(args: argparse.Namespace) -> int:
+    try:
+        rc = args.func(args)
+    except GuildError as err:
+        emit_error(err)
+        return err.code
+    except Exception as err:  # noqa: BLE001 - last-resort: wrap so no traceback leaks
+        wrapped = GuildError(
+            code=EXIT_USER_ERROR,
+            message=f"unexpected: {err.__class__.__name__}: {err}",
+            remediation="file a bug at https://github.com/agentculture/guildmaster/issues",
+        )
+        emit_error(wrapped)
+        return wrapped.code
+    return rc if rc is not None else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    return _dispatch(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

guild/cli/_commands/__init__.py

@@ -0,0 +1,22 @@
+"""guild subcommands.
+
+``VERBS`` is the canonical one-line summary of each agent-affordance verb,
+shared by ``learn`` (which lists them) and ``explain`` (which can detail one).
+Keep it in sync with the registered subcommands.
+"""
+
+VERBS: dict[str, str] = {
+    "whoami": (
+        "Report this agent's identity — suffix, backend, and version. "
+        "The smallest offline auth/identity probe."
+    ),
+    "learn": (
+        "Onboard here: list the CLI verbs and vendored skills, and point "
+        "at the runtime prompt (CLAUDE.md)."
+    ),
+    "explain": (
+        "Explain one topic in depth — a vendored skill (prints its SKILL.md) " "or a CLI verb."
+    ),
+}
+
+__all__ = ["VERBS"]

guild/cli/_commands/explain.py

@@ -0,0 +1,85 @@
+"""``guild explain <topic>`` — explain one skill or verb in depth.
+
+The narrow agent-affordance verb (``learn`` is the broad survey). If the topic
+names a vendored skill, its full ``SKILL.md`` is printed; if it names a CLI
+verb, the verb's one-line summary is printed; otherwise the command fails with
+the list of valid topics. Offline and deterministic.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from guild.cli._commands import VERBS
+from guild.cli._errors import EXIT_USER_ERROR, GuildError
+from guild.cli._output import emit_result
+from guild.cli._repo import iter_skills, repo_root
+
+
+def register(sub: argparse._SubParsersAction) -> None:
+    parser = sub.add_parser(
+        "explain",
+        help="Explain one topic in depth — a vendored skill or a CLI verb.",
+        description=(
+            "Print the full SKILL.md for a vendored skill, or the summary for "
+            "a CLI verb. Run `guild learn` to see the available topics."
+        ),
+    )
+    parser.add_argument(
+        "topic",
+        help="A vendored skill name (under .claude/skills/) or a CLI verb.",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Wrap the explanation in a JSON object on stdout.",
+    )
+    parser.set_defaults(func=_handle)
+
+
+def _handle(args: argparse.Namespace) -> int:
+    topic = args.topic
+    root = repo_root()
+
+    # Index skills by both frontmatter name and directory name so `explain`
+    # works even if a skill's frontmatter name drifts from its directory.
+    skills = {}
+    for sk in iter_skills(root):
+        skills.setdefault(sk.name, sk)
+        skills.setdefault(sk.path.name, sk)
+
+    if topic in skills:
+        sk = skills[topic]
+        content = sk.skill_md.read_text(encoding="utf-8")
+        if args.json:
+            emit_result(
+                json.dumps(
+                    {
+                        "kind": "skill",
+                        "name": sk.name,
+                        "path": str(sk.skill_md),
+                        "content": content,
+                    },
+                    indent=2,
+                )
+            )
+        else:
+            emit_result(content)
+        return 0
+
+    if topic in VERBS:
+        if args.json:
+            emit_result(
+                json.dumps({"kind": "verb", "name": topic, "summary": VERBS[topic]}, indent=2)
+            )
+        else:
+            emit_result(f"guild {topic} — {VERBS[topic]}")
+        return 0
+
+    valid = sorted(set(VERBS) | set(skills))
+    raise GuildError(
+        code=EXIT_USER_ERROR,
+        message=f"unknown topic '{topic}'",
+        remediation="valid topics: " + ", ".join(valid),
+    )

guild/cli/_commands/learn.py

@@ -0,0 +1,75 @@
+"""``guild learn`` — onboard an agent (or human) to this repo.
+
+The broad agent-affordance verb: with no argument it surveys what you can do
+here — the CLI verbs and the vendored skills — and points at the runtime
+prompt. For depth on a single skill or verb, use ``guild explain <topic>``.
+Offline and deterministic: everything is read from the filesystem.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from guild.cli._commands import VERBS
+from guild.cli._output import emit_result
+from guild.cli._repo import iter_skills, repo_root
+
+_DESC_TRUNCATE = 100
+
+
+def register(sub: argparse._SubParsersAction) -> None:
+    parser = sub.add_parser(
+        "learn",
+        help="Survey this repo: CLI verbs + vendored skills + the runtime prompt.",
+        description=(
+            "List the CLI verbs and the skills vendored under .claude/skills/, "
+            "and point at the runtime prompt (CLAUDE.md). The onboarding "
+            "affordance — run `guild explain <topic>` for depth."
+        ),
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Emit the inventory as a JSON object to stdout instead of prose.",
+    )
+    parser.set_defaults(func=_handle)
+
+
+def _truncate(text: str) -> str:
+    if len(text) <= _DESC_TRUNCATE:
+        return text
+    return text[: _DESC_TRUNCATE - 1].rstrip() + "…"
+
+
+def _handle(args: argparse.Namespace) -> int:
+    root = repo_root()
+    skills = iter_skills(root)
+    has_prompt = (root / "CLAUDE.md").is_file()
+
+    if args.json:
+        payload = {
+            "version_prompt": "CLAUDE.md" if has_prompt else None,
+            "verbs": [{"name": name, "summary": summary} for name, summary in VERBS.items()],
+            "skills": [{"name": sk.name, "description": sk.description} for sk in skills],
+        }
+        emit_result(json.dumps(payload, indent=2))
+        return 0
+
+    lines = ["guild — what you can do here", "", "Verbs:"]
+    for name, summary in VERBS.items():
+        lines.append(f"  guild {name} — {_truncate(summary)}")
+    lines.append("")
+    if skills:
+        lines.append(f"Skills ({len(skills)}):")
+        for sk in skills:
+            desc = _truncate(sk.description) if sk.description else "(no description)"
+            lines.append(f"  {sk.name} — {desc}")
+    else:
+        lines.append("Skills: (none vendored under .claude/skills/)")
+    lines.append("")
+    if has_prompt:
+        lines.append("Project shape & conventions: see CLAUDE.md")
+    lines.append("Run `guild explain <topic>` for a skill's SKILL.md or a verb's detail.")
+    emit_result("\n".join(lines))
+    return 0

guild/cli/_commands/whoami.py

@@ -0,0 +1,57 @@
+"""``guild whoami`` — report this agent's identity.
+
+The smallest offline probe: it reads ``culture.yaml`` from the enclosing repo
+and reports the declared agent suffix(es) + backend alongside the installed
+``guild`` version. No network, no shelling out — so it is safe to call in a
+loop and deterministic under test.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from guild import __version__
+from guild.cli._output import emit_result
+from guild.cli._repo import declared_agents, repo_root
+
+
+def register(sub: argparse._SubParsersAction) -> None:
+    parser = sub.add_parser(
+        "whoami",
+        help="Report this agent's identity (suffix, backend, version).",
+        description=(
+            "Read the enclosing repo's culture.yaml and report the declared "
+            "agent(s) plus the installed guild version. Offline and "
+            "side-effect-free — the smallest identity probe."
+        ),
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Emit identity as a JSON object to stdout instead of human-readable lines.",
+    )
+    parser.set_defaults(func=_handle)
+
+
+def _handle(args: argparse.Namespace) -> int:
+    root = repo_root()
+    agents = declared_agents(root)
+
+    if args.json:
+        payload = {
+            "version": __version__,
+            "repo_root": str(root),
+            "agents": [{"suffix": a.get("suffix"), "backend": a.get("backend")} for a in agents],
+        }
+        emit_result(json.dumps(payload, indent=2))
+        return 0
+
+    lines = [f"guild {__version__}", f"repo: {root}"]
+    if agents:
+        for a in agents:
+            lines.append(f"agent: {a.get('suffix', '?')} (backend: {a.get('backend', '?')})")
+    else:
+        lines.append("agent: (none declared — no culture.yaml)")
+    emit_result("\n".join(lines))
+    return 0

guild/cli/_errors.py

@@ -0,0 +1,37 @@
+"""GuildError and exit-code policy.
+
+Every failure inside guild raises :class:`GuildError`. The top-level
+``main()`` catches it, formats via :mod:`guild.cli._output`, and exits with
+:attr:`GuildError.code`. This guarantees:
+
+* no Python traceback leaks to stderr;
+* every error has a structured shape ``{code, message, remediation}``;
+* the exit-code policy is centralised in one place.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+EXIT_SUCCESS = 0
+EXIT_USER_ERROR = 1
+EXIT_ENV_ERROR = 2
+
+
+@dataclass
+class GuildError(Exception):
+    """Structured error raised within guild; carries a remediation hint."""
+
+    code: int
+    message: str
+    remediation: str = ""
+
+    def __post_init__(self) -> None:
+        super().__init__(self.message)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "code": self.code,
+            "message": self.message,
+            "remediation": self.remediation,
+        }

guild/cli/_output.py

@@ -0,0 +1,41 @@
+"""stdout / stderr helpers with a strict split.
+
+Rule: results go to stdout, diagnostics and errors go to stderr. Agents
+parsing guild output can rely on this invariant.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, TextIO
+
+from guild.cli._errors import GuildError
+
+
+def emit_result(data: Any, *, stream: TextIO | None = None) -> None:
+    """Write a command result to stdout (default)."""
+    s = stream if stream is not None else sys.stdout
+    text = data if isinstance(data, str) else str(data)
+    s.write(text)
+    if not text.endswith("\n"):
+        s.write("\n")
+
+
+def emit_error(err: GuildError, *, stream: TextIO | None = None) -> None:
+    """Write a :class:`GuildError` to stderr.
+
+    Renders as one or two lines::
+
+        error: <message>
+        hint: <remediation>
+    """
+    s = stream if stream is not None else sys.stderr
+    s.write(f"error: {err.message}\n")
+    if err.remediation:
+        s.write(f"hint: {err.remediation}\n")
+
+
+def emit_diagnostic(message: str, *, stream: TextIO | None = None) -> None:
+    """Write a human diagnostic to stderr."""
+    s = stream if stream is not None else sys.stderr
+    s.write(message if message.endswith("\n") else message + "\n")

guild/cli/_repo.py

@@ -0,0 +1,116 @@
+"""Filesystem helpers shared by guild's read-only commands.
+
+These resolve the enclosing repo, its ``culture.yaml`` agent declaration, and
+the vendored skills under ``.claude/skills/``. Everything here is pure and
+offline — no network, no shelling out — so the agent-affordance verbs
+(``whoami`` / ``learn`` / ``explain``) stay deterministic and testable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+def find_git_root(start: Path | None = None) -> Path | None:
+    """Return the nearest enclosing directory containing ``.git`` (or None).
+
+    Walks up from ``start`` (default: cwd) but never past the filesystem root.
+    Bounding lookups to the git checkout keeps a command from picking up an
+    ancestor directory outside the user's current repo.
+    """
+    base = (start or Path.cwd()).resolve()
+    for directory in (base, *base.parents):
+        if (directory / ".git").exists():
+            return directory
+    return None
+
+
+def repo_root(start: Path | None = None) -> Path:
+    """Best-effort repo root: the git root if there is one, else cwd."""
+    base = (start or Path.cwd()).resolve()
+    return find_git_root(base) or base
+
+
+def load_culture_yaml(root: Path) -> dict[str, Any] | None:
+    """Parse ``<root>/culture.yaml`` into a dict, or None if absent/empty.
+
+    Raises nothing on malformed YAML beyond what ``yaml.safe_load`` raises;
+    callers that want graceful degradation should guard the call.
+    """
+    path = root / "culture.yaml"
+    if not path.is_file():
+        return None
+    data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    return data if isinstance(data, dict) else None
+
+
+def declared_agents(root: Path) -> list[dict[str, Any]]:
+    """Return the ``agents:`` list from ``culture.yaml`` (empty if none)."""
+    data = load_culture_yaml(root)
+    if not data:
+        return []
+    agents = data.get("agents")
+    if not isinstance(agents, list):
+        return []
+    return [a for a in agents if isinstance(a, dict)]
+
+
+@dataclass
+class Skill:
+    """A vendored skill: its directory name plus SKILL.md frontmatter."""
+
+    name: str
+    path: Path
+    description: str
+
+    @property
+    def skill_md(self) -> Path:
+        return self.path / "SKILL.md"
+
+
+def _parse_frontmatter(text: str) -> dict[str, Any]:
+    """Return the YAML frontmatter block of a markdown file as a dict.
+
+    Frontmatter is the content between a leading ``---`` line and the next
+    ``---`` line. Returns ``{}`` when there is no frontmatter or it doesn't
+    parse to a mapping.
+    """
+    lines = text.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return {}
+    block: list[str] = []
+    for line in lines[1:]:
+        if line.strip() == "---":
+            break
+        block.append(line)
+    try:
+        data = yaml.safe_load("\n".join(block))
+    except yaml.YAMLError:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def iter_skills(root: Path) -> list[Skill]:
+    """Discover skills under ``<root>/.claude/skills/*/SKILL.md``.
+
+    Sorted by directory name. A skill directory without a ``SKILL.md`` is
+    skipped (it isn't a usable skill); frontmatter ``name``/``description``
+    fall back to the directory name / empty string when absent.
+    """
+    skills_dir = root / ".claude" / "skills"
+    if not skills_dir.is_dir():
+        return []
+    found: list[Skill] = []
+    for child in sorted(skills_dir.iterdir()):
+        skill_md = child / "SKILL.md"
+        if not (child.is_dir() and skill_md.is_file()):
+            continue
+        fm = _parse_frontmatter(skill_md.read_text(encoding="utf-8"))
+        name = str(fm.get("name") or child.name)
+        description = " ".join(str(fm.get("description", "")).split())
+        found.append(Skill(name=name, path=child, description=description))
+    return found

guild_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: guild-cli
+Version: 0.1.0
+Summary: guildmaster — an agent and CLI that manages skills for the AgentCulture mesh.
+Project-URL: Homepage, https://github.com/agentculture/guildmaster
+Project-URL: Issues, https://github.com/agentculture/guildmaster/issues
+Author: AgentCulture
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# guildmaster
+
+**An agent and CLI that manages skills** for the
+[AgentCulture](https://github.com/agentculture) mesh.
+
+guildmaster is a sibling to [`steward`](https://github.com/agentculture/steward)
+(resident-agent alignment), [`culture`](https://github.com/agentculture/culture)
+(the IRC-based agent mesh), and [`daria`](https://github.com/agentculture/daria)
+(the awareness agent) in the Organic Development framework. Its mission is skill
+and skillversion management plus an overview surface for the mesh: per the
+settled division of labor ([issue #1](https://github.com/agentculture/guildmaster/issues/1)),
+guildmaster becomes the skills **supplier/manager** while steward retreats to
+agent-alignment. It onboards as a **consumer** first — vendoring the canonical
+skills like every other sibling — before taking over the upstream ledger,
+broadcast, and version tracking.
+
+The repo and the Culture agent are named `guildmaster`; the CLI ships as
+`guild-cli` on PyPI and installs the `guild` binary.
+
+## Install
+
+```bash
+# From PyPI (Trusted Publishing):
+uv tool install guild-cli
+
+# From source (dev):
+uv sync
+uv run guild --version
+```
+
+## Commands
+
+All verbs are read-only, offline, and deterministic — safe to call in agent
+loops. Add `--json` to any of them for structured output.
+
+| Verb | What it does |
+|------|--------------|
+| `guild whoami` | Report this agent's identity — suffix + backend (from `culture.yaml`) + version. The smallest identity probe. |
+| `guild learn` | Survey the repo: the CLI verbs, the vendored skills under `.claude/skills/`, and a pointer to `CLAUDE.md`. |
+| `guild explain <topic>` | Explain one topic in depth — print a vendored skill's `SKILL.md`, or a verb's summary. |
+
+```bash
+uv run guild whoami
+uv run guild learn
+uv run guild explain cicd
+```
+
+## Develop
+
+```bash
+uv sync
+uv run pytest -n auto -v
+uv run black --check guild tests && uv run isort --check-only guild tests
+uv run flake8 guild tests && uv run bandit -c pyproject.toml -r guild
+```
+
+Every PR bumps the version (CI's `version-check` enforces it):
+
+```bash
+python3 .claude/skills/version-bump/scripts/bump.py patch
+```
+
+See [`CLAUDE.md`](CLAUDE.md) for the full project shape, conventions, and the
+build/test/publish toolchain.

guild_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+guild/__init__.py,sha256=ONFAFjYjdPPKthDFPl6tDXPKgImAsuC2dJJYID0GfKo,306
+guild/__main__.py,sha256=sEQZF5lcGvj7AM-8WYses3beS16xjXHU7T8BvxUrevM,139
+guild/cli/__init__.py,sha256=k0VbojF1LMpS5eABioRtFNMgP3JiU9NY2jmHNHPp2Hg,2622
+guild/cli/_errors.py,sha256=Dx1cj8ebXeKqwSWrO0xIhsFWKBHgDEf5Gssc0l8NZkM,957
+guild/cli/_output.py,sha256=fYcfca1XjTi4QshAv9-lCa-KfbfJPYz6uJ87yoxN15k,1226
+guild/cli/_repo.py,sha256=kRpYBW1L6mo_cUHmN2T-yyJk0GsqLW0x25-P1oYnj_8,3893
+guild/cli/_commands/__init__.py,sha256=K7hksxWmOYQJh3jpnfq5nMloxY9QlapD_8xYJom5BQE,693
+guild/cli/_commands/explain.py,sha256=-1JsRX8ZBnSHxg78JGCZLzC86Ou-MYSFg0NiUs4SisI,2684
+guild/cli/_commands/learn.py,sha256=6RwnQLTgpwEa6mAXRKEOiooGbR8sSrq1P4WZmDwldIQ,2639
+guild/cli/_commands/whoami.py,sha256=JxPyvdTA1rqzHoQs6HlHoAnGDHot5btanTfxl0rszXM,1859
+guild_cli-0.1.0.dist-info/METADATA,sha256=svPNEXVLFK2XIqvjFXgMkR4ssEnqgFrYQiBGC5lviTo,2919
+guild_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+guild_cli-0.1.0.dist-info/entry_points.txt,sha256=YjelaFL3IWmYDp7Xymp0JU1YRHa585RjRZ9gq6fNPd0,41
+guild_cli-0.1.0.dist-info/licenses/LICENSE,sha256=wCcdPywGtFXx1P8N0j0eEDINSWfSjrIsU7ds1YZl-MA,1069
+guild_cli-0.1.0.dist-info/RECORD,,

guild_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

guild_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+guild = guild.cli:main

guild_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentCulture
+
+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.