hookbell 0.1.0__py3-none-any.whl

hookbell/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Top-level package for Hookbell."""
+
+__author__ = """Yukihiko Shinoda"""
+__email__ = "yuk.hik.future@gmail.com"
+__version__ = "0.1.0"

hookbell/claude_code/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Claude Code hook payload handling."""

hookbell/claude_code/event.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Composes a notification text from a Claude Code hook event."""
+
+from hookbell.claude_code.stdin import ClaudeCodeStdin
+from hookbell.claude_code.transcript import Transcript
+
+
+class ClaudeCodeHookEvent:
+    """A Claude Code hook event, combining its stdin payload and referenced transcript."""
+
+    def __init__(self, stdin: ClaudeCodeStdin) -> None:
+        self.stdin = stdin
+        self.transcript = Transcript(stdin.transcript_path)
+
+    @property
+    def text(self) -> str:
+        """Return the notification text for this hook event."""
+        content = self.transcript.text_content or self.stdin.fallback_text
+        return f"{content}\n\nMessage type: {self.stdin.message}\n\n```{self.transcript.report()}```"

hookbell/claude_code/stdin.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Parses Claude Code hook stdin payloads."""
+
+from __future__ import annotations
+
+import json
+from logging import getLogger
+from pathlib import Path
+from typing import Any
+
+
+class ClaudeCodeStdin:
+    """A Claude Code hook stdin payload."""
+
+    TRANSCRIPT_PATH_KEY = "transcript_path"
+
+    def __init__(self, data: dict[str, Any]) -> None:
+        self.data = data
+
+    @classmethod
+    def parse(cls, raw_stdin: str) -> ClaudeCodeStdin | None:
+        """Return a ClaudeCodeStdin when raw_stdin holds a Claude Code hook payload, else None."""
+        try:
+            data = json.loads(raw_stdin)
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(data, dict) or cls.TRANSCRIPT_PATH_KEY not in data:
+            return None
+        getLogger(__name__).debug("raw stdin: %s", raw_stdin)
+        return cls(data)
+
+    @property
+    def message(self) -> str:
+        """Return the hook's message, falling back to its event name."""
+        return str(self.data.get("message") or self.data.get("hook_event_name", "Notification"))
+
+    @property
+    def transcript_path(self) -> Path:
+        """Return the transcript file path this hook event refers to."""
+        return Path(self.data[self.TRANSCRIPT_PATH_KEY])
+
+    @property
+    def fallback_text(self) -> str:
+        """Return text to show when the transcript's last line has no readable text.
+
+        PermissionRequest payloads carry the pending tool call directly instead of assistant text, and Stop payloads
+        carry a ready-made last_assistant_message when the transcript's last line was something else (e.g. a sidechain
+        or summary entry).
+        """
+        last_assistant_message = self.data.get("last_assistant_message")
+        if last_assistant_message:
+            return str(last_assistant_message)
+        tool_name = self.data.get("tool_name")
+        if tool_name:
+            tool_input = json.dumps(self.data.get("tool_input", {}), ensure_ascii=False)
+            return f"Waiting for permission: {tool_name}({tool_input})"
+        return self.message

hookbell/claude_code/transcript.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Reads and sanitizes a Claude Code transcript's last entry."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import TYPE_CHECKING
+from typing import Any
+
+if TYPE_CHECKING:
+    import io
+    from pathlib import Path
+
+
+class FileLastLineGetter:
+    """Gets the last line of a file without reading the whole file into memory."""
+
+    def __init__(self, file_path: Path) -> None:
+        self.file_path = file_path
+
+    def get_last_line(self) -> str:
+        """Return the last line of the file."""
+        with self.file_path.open("rb") as file_pointer:
+            return self._get_last_line(file_pointer)
+
+    @staticmethod
+    def _get_last_line(file_pointer: io.BufferedIOBase) -> str:
+        try:
+            FileLastLineGetter._seek_to_last_new_line(file_pointer)
+        except OSError:
+            # In case of a one line file
+            file_pointer.seek(0)
+        return file_pointer.readline().decode("utf-8").strip()
+
+    @staticmethod
+    def _seek_to_last_new_line(file_pointer: io.BufferedIOBase) -> None:
+        file_pointer.seek(-2, os.SEEK_END)
+        while file_pointer.read(1) != b"\n":
+            file_pointer.seek(-2, os.SEEK_CUR)
+
+
+class Transcript:
+    """A Claude Code transcript.
+
+    The transcript's last line is not always a plain assistant text message: it may be a tool call, a sub-
+    agent/sidechain entry, or a compaction summary entry, each with a different shape. Every accessor here must
+    tolerate keys being absent rather than assume the full schema.
+    """
+
+    UNREADABLE_KEYS = ("parentUuid", "isSidechain", "sessionId", "version", "requestId", "uuid", "timestamp")
+
+    def __init__(self, path: Path) -> None:
+        transcript_json_string = FileLastLineGetter(path).get_last_line()
+        self.data: Any = json.loads(transcript_json_string)
+
+    def report(self) -> str:
+        """Return the last transcript entry as pretty-printed, sanitized JSON."""
+        return json.dumps(self._remove_unreadable_keys(), indent=2, ensure_ascii=False)
+
+    def _remove_unreadable_keys(self) -> dict[str, Any]:
+        if not isinstance(self.data, dict):
+            return {"raw": self.data}
+        data = self.data.copy()
+        for key in self.UNREADABLE_KEYS:
+            data.pop(key, None)
+        message = data.get("message")
+        if isinstance(message, dict):
+            self._remove_unreadable_message_keys(message)
+        return data
+
+    @staticmethod
+    def _remove_unreadable_message_keys(message: dict[str, Any]) -> None:
+        message.pop("id", None)
+        for message_content in message.get("content") or []:
+            if isinstance(message_content, dict):
+                message_content.pop("id", None)
+
+    @property
+    def text_content(self) -> str:
+        """Return the concatenated assistant text blocks of the last transcript entry."""
+        if not isinstance(self.data, dict):
+            return ""
+        contents = self.data.get("message", {}).get("content") or []
+        if not isinstance(contents, list):
+            return ""
+        texts = [item["text"] for item in contents if isinstance(item, dict) and item.get("type") == "text"]
+        return "\n".join(texts)

hookbell/cli.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Console script for hookbell."""
+
+import sys
+from logging import DEBUG
+from logging import basicConfig
+from logging import getLogger
+from pathlib import Path
+
+import click
+
+from hookbell.claude_code.event import ClaudeCodeHookEvent
+from hookbell.claude_code.stdin import ClaudeCodeStdin
+from hookbell.notifiers.slack import SlackNotifier
+from hookbell.notify_style import PlainTextNotification
+
+basicConfig(filename=Path("slack.log"), level=DEBUG)
+
+
+@click.command()
+def main() -> int:
+    """Notify Slack, either as a Claude Code hook or from any piped input.
+
+    Reads stdin (unless it is a TTY) and decides which mode applies: a Claude Code hook payload (JSON carrying
+    "transcript_path") is reported through its referenced transcript; anything else is posted as free-form text.
+    """
+    raw_stdin = "" if sys.stdin.isatty() else sys.stdin.read()
+    claude_code_stdin = ClaudeCodeStdin.parse(raw_stdin) if raw_stdin else None
+    if claude_code_stdin is not None:
+        _notify_claude_code_hook(claude_code_stdin)
+    else:
+        _notify_plain_text(raw_stdin)
+    return 0
+
+
+def _notify_claude_code_hook(claude_code_stdin: ClaudeCodeStdin) -> None:
+    # Reason: This runs as a Claude Code hook, where a failed notification is best-effort side-
+    # channel noise rather than something that should surface as this hook's own failure. Logging
+    # and swallowing keeps a transient issue (a malformed transcript line, the network being
+    # briefly down, an unreachable webhook) from producing hook-failure feedback for a non-critical
+    # path. The failure surface spans stdlib json, pathlib and urllib plus future code, so
+    # narrowing to specific exception types would leave gaps:
+    # - Pylint broad-exception-caught (W0718): no narrower alternative fits an evolving surface
+    #   https://pylint.readthedocs.io/en/latest/user_guide/messages/warning/broad-exception-caught.html
+    try:
+        SlackNotifier.from_environment().notify(ClaudeCodeHookEvent(claude_code_stdin).text)
+    except Exception:  # pylint: disable=broad-exception-caught
+        getLogger(__name__).exception("Failed to notify Claude Code hook event")
+
+
+def _notify_plain_text(raw_stdin: str) -> None:
+    # Reason: same broad failure surface as _notify_claude_code_hook above, but this branch is a
+    # direct, interactive invocation, so the failure is surfaced to the caller by re-raising as
+    # ClickException instead of only logged. Click's standalone mode ignores this
+    # command callback's own return value for the process exit code (only a raised exception, or an
+    # explicit ctx.exit(), controls it), and ClickException is the one exception type Click always
+    # turns into a clean "Error: ..." message on stderr plus a guaranteed exit code of exactly 1:
+    # - Pylint broad-exception-caught (W0718): no narrower alternative fits an evolving surface
+    #   https://pylint.readthedocs.io/en/latest/user_guide/messages/warning/broad-exception-caught.html
+    try:
+        SlackNotifier.from_environment().notify(PlainTextNotification(raw_stdin).text)
+    except Exception as error:  # pylint: disable=broad-exception-caught
+        raise click.ClickException(str(error)) from error
+
+
+if __name__ == "__main__":
+    sys.exit(main())  # pragma: no cover

hookbell/notifiers/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Notification backends."""

hookbell/notifiers/base.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Notifier interface shared by every notification backend."""
+
+from abc import ABC
+from abc import abstractmethod
+
+
+class Notifier(ABC):
+    """A destination hookbell can send a notification text to."""
+
+    @abstractmethod
+    def notify(self, text: str) -> None:
+        """Send text as a notification."""

hookbell/notifiers/slack.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Slack notification backend."""
+
+from __future__ import annotations
+
+import json
+import os
+import ssl
+from logging import getLogger
+from pathlib import Path
+from typing import ClassVar
+from urllib import request
+
+import certifi
+
+from hookbell.notifiers.base import Notifier
+
+
+class SlackNotifier(Notifier):
+    """Posts a notification to Slack via an incoming webhook."""
+
+    HEADERS: ClassVar[dict[str, str]] = {"Content-Type": "application/json"}
+    WEBHOOK_URL_SECRET_PATH = Path("/run/secrets/slack_webhook_url")
+
+    def __init__(self, webhook_url: str) -> None:
+        self.webhook_url = webhook_url
+        self.logger = getLogger(__name__)
+
+    @classmethod
+    def from_environment(cls) -> SlackNotifier:
+        """Build a SlackNotifier from the Docker secret, falling back to the environment variable."""
+        if cls.WEBHOOK_URL_SECRET_PATH.exists():
+            return cls(webhook_url=cls.WEBHOOK_URL_SECRET_PATH.read_text(encoding="utf-8").strip())
+        return cls(webhook_url=os.environ["SLACK_WEBHOOK_URL"])
+
+    def notify(self, text: str) -> None:
+        """Post text to Slack as a single section block."""
+        if not self.webhook_url.startswith("https://"):
+            message = f"Slack webhook URL must use https://, got: {self.webhook_url!r}"
+            raise ValueError(message)
+        data = {"blocks": [{"type": "section", "text": {"type": "mrkdwn", "text": text}}]}
+        # Reason: self.webhook_url is only ever populated by from_environment() above, from an
+        # operator-configured Docker secret file or the SLACK_WEBHOOK_URL environment variable --
+        # never from untrusted external input -- and the https:// scheme check right above rules
+        # out the file:/custom-scheme risk this rule targets. Ruff still flags the call even with
+        # that check in place, since it does no control-flow analysis:
+        # - Ruff Rule S310: suspicious-url-open-usage
+        #   https://docs.astral.sh/ruff/rules/suspicious-url-open-usage/
+        # - Bandit B310: urllib urlopen
+        #   https://bandit.readthedocs.io/en/1.9.4/blacklists/blacklist_calls.html#b310-urllib-urlopen
+        # - Issue: Avoid raising S310 if user explicitly checks for URL scheme
+        #   https://github.com/astral-sh/ruff/issues/7918
+        req = request.Request(  # noqa: S310
+            self.webhook_url,
+            data=json.dumps(data).encode("utf-8"),
+            headers=self.HEADERS,
+        )
+        ssl_context = ssl.create_default_context(cafile=certifi.where())
+        with request.urlopen(req, context=ssl_context) as response:  # noqa: S310  # nosec B310
+            response_data = response.read().decode("utf-8")
+            self.logger.debug("response_data: %s", response_data)

hookbell/notify_style.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2026 Yukihiko Shinoda
+"""Composes a plain-text notification from captured stdin.
+
+A bare invocation notifies "Finished!", and piped stdin gets wrapped into a code block beneath it, truncated to Slack's
+message character limit.
+"""
+
+
+class PlainTextNotification:
+    """A plain-text notification built from optional piped stdin."""
+
+    DEFAULT_TEXT = "Finished!"
+    # Following the character length limit on Slack messages:
+    # https://api.slack.com/changelog/2018-04-truncating-really-long-messages
+    STDIN_CHARACTER_LIMIT = 39900
+
+    def __init__(self, captured_stdin: str) -> None:
+        self.captured_stdin = captured_stdin
+
+    @property
+    def text(self) -> str:
+        """Return the notification text."""
+        if not self.captured_stdin:
+            return self.DEFAULT_TEXT
+        truncated = self.captured_stdin[-self.STDIN_CHARACTER_LIMIT :]
+        return f"{self.DEFAULT_TEXT}\n```\n{truncated}\n```"

hookbell-0.1.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: hookbell
+Version: 0.1.0
+Summary: Notifies Slack, as a Claude Code hook or as a notify-compatible CLI.
+Author-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+Maintainer-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Yukihiko Shinoda
+        
+        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.
+        
+Project-URL: homepage, https://github.com/yukihiko-shinoda/hookbell
+Project-URL: repository, https://github.com/yukihiko-shinoda/hookbell
+Keywords: hookbell
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=2026.7.22
+Requires-Dist: click>=7.0
+Dynamic: license-file
+
+# Hookbell
+
+[![Test](https://github.com/yukihiko-shinoda/hookbell/workflows/Test/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ATest)
+[![CodeQL](https://github.com/yukihiko-shinoda/hookbell/workflows/CodeQL/badge.svg)](https://github.com/yukihiko-shinoda/hookbell/actions?query=workflow%3ACodeQL)
+[![Code Coverage](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/coverage.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Maintainability](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell/maintainability.svg)](https://qlty.sh/gh/yukihiko-shinoda/projects/hookbell)
+[![Dependabot](https://flat.badgen.net/github/dependabot/yukihiko-shinoda/hookbell?icon=dependabot)](https://github.com/yukihiko-shinoda/hookbell/security/dependabot)
+[![Python versions](https://img.shields.io/pypi/pyversions/hookbell)](https://pypi.org/project/hookbell/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/hookbell)](https://pypi.org/project/hookbell/)
+[![X URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fyukihiko-shinoda%2Fhookbell)](https://x.com/intent/post?text=Hookbell&url=https%3A%2F%2Fpypi.org%2Fproject%2Fhookbell%2F&hashtags=python)
+
+Notifies Slack — as a Claude Code hook, or as a general "notify me when this finishes" command for
+any piped output.
+
+## Advantage
+
+A Claude Code hook script that only understands its own hook JSON payload
+(`transcript_path`, `hook_event_name`, ...) can't double as a general-purpose notification command
+for anything else you run — and a general-purpose command built without Claude Code in mind knows
+nothing about its transcripts, so it can't report what the assistant actually said or which
+permission it's waiting on. Maintaining one script per use case means duplicating the Slack-posting
+logic each time.
+
+Hookbell covers both with a single command: it inspects stdin and automatically picks the right
+behavior. A Claude Code hook payload gets reported through its referenced transcript; anything else
+is treated as free-form piped text and posted as-is.
+
+## Quickstart
+
+```bash
+uv tool install hookbell
+```
+
+Set the webhook URL from a Slack [Incoming Webhook](https://api.slack.com/messaging/webhooks):
+
+```bash
+export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/T000/B000/XXXX"
+```
+
+Pipe any text into hookbell to post it to Slack:
+
+```bash
+echo 'Hello world' | uvx hookbell
+```
+
+That posts this single Slack message:
+
+````text
+Finished!
+```
+Hello world
+```
+````
+
+Since any piped input gets wrapped the same way, piping a long-running command's own output into
+hookbell delivers that output to Slack the moment the command is done, without having to watch the
+terminal for it — redirecting stderr into stdout matters here, since build tools like
+`docker compose build` write their progress there:
+
+```bash
+docker compose build 2>&1 | uvx hookbell
+```
+
+When the command's output isn't worth forwarding and only knowing it ended matters, chaining with
+`;` instead leaves hookbell's stdin empty, so it just posts `Finished!` on its own:
+
+```bash
+docker compose build; uvx hookbell
+```
+
+<!-- markdownlint-disable no-trailing-punctuation -->
+## How do I...
+<!-- markdownlint-enable no-trailing-punctuation -->
+
+### How do I use hookbell as a Claude Code hook?
+
+Point Claude Code's `Notification`, `PermissionRequest`, and `Stop` hooks at hookbell in
+`settings.json`:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [{ "type": "command", "command": "uvx hookbell" }]
+      }
+    ]
+  }
+}
+```
+
+Hookbell recognizes a Claude Code hook payload by its `transcript_path` field and posts a message
+built from that transcript: the assistant's own last message when there is one, or a description of
+the pending permission request otherwise. A failed notification here is logged (see `slack.log`)
+rather than raised, so a flaky network never turns into hook-failure noise.
+
+### How do I use hookbell in a Docker container?
+
+Hookbell checks `/run/secrets/slack_webhook_url` before falling back to `SLACK_WEBHOOK_URL`, so a
+[Docker secret] keeps the webhook URL out of the container's environment and image layers entirely.
+With Compose, write the URL to a local file Compose reads at build/run time, and mount it as a
+secret named `slack_webhook_url` so Docker places it at that exact path:
+
+```yaml
+services:
+  app:
+    secrets:
+      - slack_webhook_url
+
+secrets:
+  slack_webhook_url:
+    file: ./slack_webhook_url.txt
+```
+
+[Docker secret]: https://docs.docker.com/compose/how-tos/use-secrets/
+
+## Credits
+
+This package was created with [Cookiecutter] and the [yukihiko-shinoda/cookiecutter-pypackage] project template.
+
+[Cookiecutter]: https://github.com/audreyr/cookiecutter
+[yukihiko-shinoda/cookiecutter-pypackage]: https://github.com/audreyr/cookiecutter-pypackage

hookbell-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+hookbell/__init__.py,sha256=tOSJtsVldBmhyCqV4cl94I9tjOpSq79nylKqaAVKAFc,174
+hookbell/cli.py,sha256=D30ufAgXDzGgbcLw0ackYUWpOfwx_xuxX4v9IDjMdgg,3310
+hookbell/notify_style.py,sha256=Vh9gZFajtdr1AUgXuFm1YnVRYlwwwG5Sh1Je46t4OdA,943
+hookbell/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hookbell/claude_code/__init__.py,sha256=7r_mOOE7X98SvdJmEUhG_58yoIul4aoJM3dDFO6HeBA,79
+hookbell/claude_code/event.py,sha256=pyo8uzyLY06giZ-SBa9NiSmN3WkyVUawCPzbMSrGk9U,762
+hookbell/claude_code/stdin.py,sha256=AUUuuHdWNRPHXg8a5b-ZUi-uM1SbETBxjtoVzbH2E9g,2112
+hookbell/claude_code/transcript.py,sha256=NoSt53xFbZCAbuJ3BuRnuj57BwhkuG3tcVU7od1p-dw,3224
+hookbell/notifiers/__init__.py,sha256=c1nk2qGKtvx64f3XlURdDLDK6egnXU4toRU402u4DQI,67
+hookbell/notifiers/base.py,sha256=Y_ka9p_ACPrFjO_NJA7g9e3C8bB1-nWLB_0PSQ2NgyI,347
+hookbell/notifiers/slack.py,sha256=Q2JSxSo6-K7zV-ZBO-uC0zCZ0UqEQ_7NYFEnQILGKEQ,2778
+hookbell-0.1.0.dist-info/licenses/LICENSE,sha256=wR3OZFWiZhZS_5KnHg9cOJyRZaeaa72r2g0727YlfQI,1073
+hookbell-0.1.0.dist-info/METADATA,sha256=DIAe_QOutB_Q_flS7Bbv6QZsM35uzsmGE0XpQsln7NU,7472
+hookbell-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hookbell-0.1.0.dist-info/entry_points.txt,sha256=UiHEavoJquKk3SdQVO8ZSqEmsebAGq1CULy80PlDQ1s,47
+hookbell-0.1.0.dist-info/top_level.txt,sha256=K28WvqQwaUVmXOewxTACFaXmTLZ8Gp_AGYk5bMsUKWM,9
+hookbell-0.1.0.dist-info/RECORD,,

hookbell-0.1.0.dist-info/WHEEL

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

hookbell-0.1.0.dist-info/entry_points.txt

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

hookbell-0.1.0.dist-info/licenses/LICENSE

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

hookbell-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hookbell