holt-cli 0.1.0__py3-none-any.whl

holt/tui/widgets/stages.py

@@ -0,0 +1,232 @@
+"""The stage list, and the moment Stage D removes a claim.
+
+There is no progress bar here. A bar would have to invent a denominator — the
+number of threads a stage will read is not known until it has read them — and a
+bar that fills at a rate unrelated to the work is a lie told smoothly. What a
+running stage shows instead is a spinner, which claims only that something is
+happening, and an elapsed clock, which is a real number.
+"""
+
+from __future__ import annotations
+
+import time
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widget import Widget
+
+from holt.tui import animation, events, theme
+from holt.tui.visual import Line
+from holt.tui.widgets.evidence import cite
+
+
+class StageRow(Line):
+    """One stage: a gutter mark, its name, and where it has got to.
+
+    Three states, and they are visually distinct without relying on colour:
+    pending is an em dash, running is a turning spinner and a clock, finished is
+    the stage's own one-line result.
+    """
+
+    def __init__(self, stage: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.stage = stage
+        self._model = ""
+        self._state = "pending"
+        self._status = ""
+        self._started = 0.0
+        self._elapsed = 0.0
+        self._tick = 0
+        self._timer = None
+
+    def on_mount(self) -> None:
+        self._repaint()
+
+    def started(self, model: str) -> None:
+        self._model = model
+        self._state = "running"
+        self._started = time.monotonic()
+        self._tick = 0
+        if self._timer is None and animation.enabled():
+            self._timer = self.set_interval(animation.SPINNER_INTERVAL, self._spin)
+        self._repaint()
+
+    def finished(self, summary: str, seconds: float) -> None:
+        self._state = "done"
+        self._status = summary or "done"
+        if self._started:
+            self._elapsed = time.monotonic() - self._started
+        self._stop()
+        self._repaint()
+
+    def _spin(self) -> None:
+        self._tick += 1
+        self._repaint()
+
+    def _stop(self) -> None:
+        if self._timer is not None:
+            self._timer.stop()
+            self._timer = None
+
+    def on_unmount(self) -> None:
+        self._stop()
+
+    def _repaint(self) -> None:
+        text = Text()
+        text.append(f"{events.stage_mark(self.stage):<2} ", style=theme.FAINT)
+        text.append(f"{events.stage_title(self.stage):<16}", style=theme.DIM)
+
+        if self._state == "pending":
+            text.append("—", style=theme.FAINT)
+        elif self._state == "running":
+            spin = animation.frame(self._tick) if animation.enabled() else "·"
+            text.append(f"{spin} ", style=theme.CITE)
+            elapsed = time.monotonic() - self._started if self._started else 0.0
+            text.append(animation.elapsed(elapsed), style=theme.FAINT)
+        else:
+            text.append(self._status)
+            if self._elapsed >= 0.05:
+                text.append(f"   {animation.elapsed(self._elapsed)}", style=theme.FAINT)
+        self.update(text)
+
+
+class StageList(Vertical):
+    """Rows for the stages we expect, plus any the engine grows later.
+
+    A stage the engine adds appears at the end of the list with a blank gutter
+    mark rather than being dropped on the floor, so the interface reports the
+    pipeline that ran instead of the pipeline it was written against.
+    """
+
+    def compose(self) -> ComposeResult:
+        for stage, _mark in events.STAGE_ORDER:
+            if stage in events.OPTIONAL_STAGES:
+                continue
+            yield StageRow(stage, id=f"stage-{stage}")
+
+    def row(self, stage: str) -> StageRow | None:
+        for row in self.query(StageRow):
+            if row.stage == stage:
+                return row
+        return None
+
+    def ensure(self, stage: str) -> StageRow:
+        existing = self.row(stage)
+        if existing is not None:
+            return existing
+        row = StageRow(stage)
+        self.mount(row)
+        animation.reveal(row)
+        return row
+
+    def settle(self) -> None:
+        """Stop every spinner. Called when the run ends, however it ended.
+
+        Without this, a failure part-way through leaves the stage it died on
+        turning forever, which reads as still working.
+        """
+        for row in self.query(StageRow):
+            if row._state == "running":
+                row._state = "pending"
+                row._stop()
+                row._repaint()
+
+
+class EmittedFinding(Line):
+    """A claim a stage just made, with the ids it says support it.
+
+    Shown before Stage D has had its say, which is the point: the live view is
+    where you watch a claim arrive and then, sometimes, be taken away.
+    """
+
+    def __init__(
+        self, event: events.FindingEmitted, repo: str | None = None, **kwargs
+    ) -> None:
+        super().__init__(classes="finding", **kwargs)
+        self.event = event
+        self.repo = repo
+
+    def on_mount(self) -> None:
+        self.update(self._line())
+        animation.reveal(self)
+
+    def _line(self) -> Text:
+        event = self.event
+        text = Text()
+        if event.field == "thread_outcome" and isinstance(event.value, dict):
+            for eid in event.evidence_ids[:1]:
+                text.append_text(cite(eid, width=44, repo=self.repo))
+            text.append("  ")
+            text.append(str(event.value.get("outcome", "")), style=theme.DIM)
+        else:
+            text.append(f"{event.field} = {event.value}")
+            for eid in event.evidence_ids[:1]:
+                text.append("  ")
+                text.append_text(cite(eid, width=40, repo=self.repo))
+        return text
+
+
+class DroppedFinding(Widget):
+    """Stage D removed a claim.
+
+    Given room rather than compressed to a line. This is the behaviour the whole
+    pipeline is arranged around, and the reason a reader can trust the rest of
+    the report: a claim the model made, whose evidence did not hold up, and which
+    was therefore dropped rather than softened into a hedge.
+    """
+
+    def __init__(self, event: events.FindingDropped, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.event = event
+
+    def on_mount(self) -> None:
+        animation.reveal(self)
+
+    def compose(self) -> ComposeResult:
+        event = self.event
+        head = Text()
+        head.append("✗ ", style=theme.DROP)
+        head.append(f"{event.field} = {event.value!r}")
+        yield Line(head)
+
+        unquoted = getattr(event, "reason", "unresolved") == "unquoted"
+        for eid in event.cited:
+            row = Text("  ")
+            row.append("cited  ", style=theme.DIM)
+            # An unquoted claim cites a thread that is perfectly real; it is the
+            # words that are not there, and colouring the id as unresolvable
+            # would say the opposite of what happened.
+            row.append_text(cite(eid, resolves=unquoted, width=50))
+            row.append(
+                "   says no such thing" if unquoted else "   does not resolve",
+                style=theme.DROP,
+            )
+            yield Line(row)
+        if not event.cited:
+            row = Text("  ")
+            row.append("cited  ", style=theme.DIM)
+            row.append("no evidence at all", style=theme.DROP)
+            yield Line(row)
+
+        yield Line(
+            Text(
+                "Dropped, not softened. The quoted words are not in that thread, so "
+                "the claim does not reach the reader."
+                if unquoted else
+                "Dropped, not softened. The claim was asserted without a record that "
+                "carries it, so it does not reach the reader.",
+                style=theme.FAINT,
+            ),
+            classes="drop-reason",
+        )
+
+
+def unknown(event: object) -> Line:
+    """Anything this file has no specific rendering for.
+
+    An event added to the schema after this screen was written must still
+    produce a truthful line. Nothing in the UI may raise on an event it has not
+    seen before.
+    """
+    return Line(Text(events.describe(event), style=theme.FAINT), classes="finding")

holt/types.py

@@ -0,0 +1,48 @@
+"""Core types shared by the evidence layer, the agent stages, and the eval harness."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
+
+# The temporal holdout boundary.
+#
+# The agent may only see records at or before T; labels are computed only from
+# records after T. T sits just past the model's May 2026 training cutoff so that
+# the label window (Jun-Aug 2026) falls outside training data entirely. Moving T
+# earlier would drag the label window *into* training data, which is the leak
+# that actually matters.
+T_CUTOFF = datetime(2026, 6, 1, tzinfo=UTC)
+
+
+class Window(str, Enum):
+    """Which side of the holdout a provider is permitted to read."""
+
+    PRE_T = "pre_t"
+    POST_T = "post_t"
+
+
+@dataclass(frozen=True, slots=True)
+class EvidenceRecord:
+    """A single retrieved fact, addressable by a stable id.
+
+    Every claim Holt makes must cite an ``evidence_id`` that resolves back to one
+    of these. Stage D drops any finding whose id does not.
+    """
+
+    evidence_id: str
+    source: str
+    url: str
+    timestamp: datetime
+    payload: dict[str, Any]
+
+    def __post_init__(self) -> None:
+        if self.timestamp.tzinfo is None:
+            raise ValueError(
+                f"{self.evidence_id}: timestamp must be timezone-aware; "
+                "naive datetimes cannot be compared against the holdout boundary"
+            )
+        if not self.evidence_id:
+            raise ValueError("evidence_id must be non-empty")

holt_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.5
+Name: holt-cli
+Version: 0.1.0
+Summary: Evidence-backed assessment of whether a GitHub repository is a viable opportunity for an external contributor.
+Project-URL: Homepage, https://github.com/holt-oss/holt
+Project-URL: Documentation, https://github.com/holt-oss/holt/tree/main/docs
+Project-URL: Repository, https://github.com/holt-oss/holt.git
+Project-URL: Issues, https://github.com/holt-oss/holt/issues
+Project-URL: Changelog, https://github.com/holt-oss/holt/blob/main/CHANGELOG.md
+Project-URL: Security, https://github.com/holt-oss/holt/security/policy
+Author-email: Aahil Khan <aahilminookhan@gmail.com>
+Maintainer-email: Aahil Khan <aahilminookhan@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: cli,contributors,github,open-source,repository-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.60
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=3.6.0
+Requires-Dist: textual>=0.80
+Description-Content-Type: text/markdown
+
+# Holt
+
+[![CI](https://github.com/holt-oss/holt/actions/workflows/ci.yml/badge.svg)](https://github.com/holt-oss/holt/actions/workflows/ci.yml)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-83a9ff.svg)](https://github.com/holt-oss/holt/blob/main/LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-69c7a6.svg)](https://github.com/holt-oss/holt/blob/main/pyproject.toml)
+
+**Choose an open-source repository that is worth your time.**
+
+Holt reads recent GitHub contribution history and shows what happens when
+outside contributors try to help: whether they receive a response, whether
+substantive work gets reviewed and merged, and where newcomer contributions
+actually land. It turns that evidence into a verdict you can inspect before
+committing days or weeks to a project.
+
+![Holt terminal interface](https://raw.githubusercontent.com/holt-oss/holt/main/assets/holt.png)
+
+Holt is read-only. It never opens pull requests, posts comments, or contacts
+maintainers. Every factual claim in a full report links back to the pull request,
+review, or comment that supports it.
+
+> Winner of **Most useful real-world workflow** at the micro1 Frontier
+> Engineering Challenge. Holt is now maintained as an independent open-source
+> product by [`holt-oss`](https://github.com/holt-oss).
+
+## Install
+
+Holt is pre-1.0. You need [`uv`](https://docs.astral.sh/uv/) and Python 3.11 or
+newer.
+
+```sh
+uv tool install holt-cli
+```
+
+Create a classic GitHub token with no scopes and expose it to Holt:
+
+```sh
+export GITHUB_TOKEN=your_token
+```
+
+Start with the rules-only report. It calls no model and needs no model API key:
+
+```sh
+holt analyze pallets/flask --live --no-model
+```
+
+For a written report with cited findings and quotations, configure a supported
+model provider and run the full analysis:
+
+```sh
+export OPENAI_API_KEY=your_key
+holt analyze pallets/flask --live
+```
+
+Run `holt models` to inspect or change the provider. OpenAI, Anthropic, Gemini,
+Ollama, and OpenAI-compatible endpoints are supported.
+
+## Use the terminal interface
+
+Run Holt without a subcommand to open the interactive terminal interface:
+
+```sh
+holt
+```
+
+From there you can assess a repository, revisit past reports, inspect the
+evidence behind a claim, compare candidates, and configure model providers.
+
+## What you get
+
+A repository assessment answers five practical questions:
+
+- Do first-time contributors get meaningful work merged?
+- How quickly does someone usually respond?
+- Are pull requests reviewed by people or accepted mechanically?
+- Which parts of the codebase have accepted outsider work?
+- What specific evidence supports the verdict?
+
+The headline is one of:
+
+| Verdict | Meaning |
+|---|---|
+| **Worth your time** | There is evidence that outsiders can land useful work. |
+| **Not worth your time** | The observed contribution path is a poor fit for the time you have. |
+| **Not enough evidence** | Holt cannot support either conclusion from the available history. |
+
+Treat the verdict as a filter, not an oracle. Open the cited evidence before
+making a significant commitment.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `holt analyze <owner/repo> --live` | Assess one repository using current GitHub data. |
+| `holt compare <repo>… --live` | Compare repositories side by side. |
+| `holt profile` | Save the languages, topics, contribution type, and time budget you want. |
+| `holt discover --live` | Find and screen repositories for that profile. |
+| `holt next <repo> --as <login> --live` | Rank open issues after you have contributed to a project. |
+| `holt models` | Inspect or change the model provider. |
+| `holt tui` | Open the interactive terminal interface. |
+
+See [USAGE.md](https://github.com/holt-oss/holt/blob/main/USAGE.md) for the
+complete workflow and
+[docs/COMMANDS.md](https://github.com/holt-oss/holt/blob/main/docs/COMMANDS.md)
+for command details.
+
+## How it works
+
+Holt separates evidence collection, interpretation, verification, and the final
+decision:
+
+```text
+GitHub history
+    ↓
+contribution signals + cited findings
+    ↓
+evidence verification
+    ↓
+deterministic verdict
+    ↓
+written explanation
+```
+
+The model may interpret threads and explain the result, but it does not choose
+the verdict. Unsupported findings are removed before the decision is computed.
+The same verified inputs therefore produce the same verdict.
+
+The architecture and its boundaries are documented in
+[docs/DESIGN.md](https://github.com/holt-oss/holt/blob/main/docs/DESIGN.md).
+
+## Evaluation and limitations
+
+Holt has been measured on two temporally held-out repository pools. On the
+out-of-sample pool it reached 0.82 balanced accuracy and 0.63 Matthews
+correlation, compared with 0.61 and 0.21 for a single prompt over repository
+metadata and documentation. The committed fixtures and recordings make those
+results reproducible.
+
+The evaluation is evidence, not a guarantee. Repository cultures change, quiet
+periods can look worse than they are, and no benchmark captures whether a
+particular issue matches your skills. Holt is designed to show its work so you
+can disagree with it intelligently.
+
+- [Evaluation design and limitations](https://github.com/holt-oss/holt/blob/main/docs/EVALUATION.md)
+- [Reproduce the published results](https://github.com/holt-oss/holt/blob/main/REPRODUCTION.md)
+- [Recorded example analyses](https://github.com/holt-oss/holt/blob/main/trajectories/README.md)
+
+## Contributing
+
+Holt welcomes focused improvements to evidence providers, verdict rules,
+terminal UX, documentation, evaluation, and platform support.
+
+```sh
+git clone https://github.com/holt-oss/holt.git
+cd holt
+uv sync
+uv run pytest -rs
+```
+
+Read [CONTRIBUTING.md](https://github.com/holt-oss/holt/blob/main/CONTRIBUTING.md)
+before opening a pull request. Community participation is governed by the
+[Code of Conduct](https://github.com/holt-oss/holt/blob/main/CODE_OF_CONDUCT.md),
+and security reports follow
+[SECURITY.md](https://github.com/holt-oss/holt/blob/main/SECURITY.md).
+
+## License
+
+Holt is licensed under the
+[Apache License 2.0](https://github.com/holt-oss/holt/blob/main/LICENSE).

holt_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+holt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holt/baseline.py,sha256=Ros5hIpPKezf7gLK_Gt8YfUNO_-sO68y-RmpQYs0v-M,3163
+holt/baseline_matched.py,sha256=XLQVNXPAWtzruhCkWcLRl6VvIbhgr03IqtUEaCFnsaE,4791
+holt/cli.py,sha256=lsCBohRH9jZ2C-Xev6uQxLupZdnr3qehS02TT-3ffnI,26167
+holt/discover.py,sha256=mCFJwno7mOs66pNej-Msw3j3KKWPnoUFPlm9XNeLgoI,20786
+holt/issues.py,sha256=250OcM1IPQ9UT7VgV2EHpfu74yLcM34OQ8Ipp1aujrY,1543
+holt/model.py,sha256=wJXU64FRuLN4Jbk3MqqXRseN59tsxacMDqbsRAj5mf4,20112
+holt/profile.py,sha256=iCwfkqMqA39EgtUWoQXM0jqhezkktct3WSFW2BxPh3s,4921
+holt/report.py,sha256=PkZCUfEJyttRLEJz_LdqIehpC15WQ5uSGmL_9PP6YbM,6556
+holt/types.py,sha256=wzRi6iQvs_aSYRrQjJl3K5fHPyvvAoK36o9yuLA47rE,1549
+holt/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holt/agent/entry.py,sha256=F_ouy81cFmwIHeYbNw_xxwHSvVc7tyFivnlL9mx4IUg,3798
+holt/agent/findings.py,sha256=t_XsTM7DhRT_pWb2oElIp9tfEDtdq6__obpuBJYeb1Y,1495
+holt/agent/landing.py,sha256=cVQ2om1qNGivLXQAYmfC4HSWsinYG4G_qHPKwQNXTrU,5980
+holt/agent/pipeline.py,sha256=eQqZ_NL2o-Fcia2enmWESU6dpQlmyxekXpsb6Ea7Kpk,10488
+holt/agent/progression.py,sha256=4Rpjmo2qDFxbTfl8MDy9Y8TqPYCKzEanCo7YuwxDE80,15991
+holt/agent/signals.py,sha256=H4qhVfN87Q-vuROZ_JQLJJ59THYH2nuwF5r9nusPlM8,9258
+holt/agent/stages.py,sha256=lsLK7CPjo4o4PxBV4oOaJa3z_msBBu5xI3MTmdrfZWM,21153
+holt/agent/verdict.py,sha256=10pC7aoQvJl9yZzpKtQ1QE4Y7KvQ7H7NZ8uEGHgmFOE,10268
+holt/agent/verify.py,sha256=_PwvVYoRxQtOentE0502seEh78bR07goQ83We6Kf7-g,5760
+holt/evidence/__init__.py,sha256=xbcUlLUkTIbO0eWf53MGAE6J7sul38Zqt5Xq2d1ztfM,126
+holt/evidence/fixtures.py,sha256=We9lGRgKST6sJJ6c6GrIxLaxSZks1ODdEcnaUEgLtf0,5358
+holt/evidence/github_graphql.py,sha256=EUaK_0BrR7Mvel8J378cOT-8fzan0DfsoXdyE7NyHmc,20789
+holt/evidence/provider.py,sha256=zjT-Tn4wPfr5E7kf20qSjMOBX_LSzh4nO2bc-hpQhSg,3154
+holt/evidence/redact.py,sha256=pRivtIIrnJlsc-V2KO_kzA15yapNPZGeu08cmPoNM3k,2793
+holt/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holt/tui/animation.py,sha256=IGjD6pQDijhZ2CVroffVSL5urXBJCXeGHnUABC9EH3s,3017
+holt/tui/app.py,sha256=2irYvm_HKLaECM4oexhDsOn12C1AnktSzyMF4jhk2S0,12867
+holt/tui/clipboard.py,sha256=ObyGDFj8c7ytvOFIzl7tmemfmn9XZ5wfYn-lNg59Bvo,3632
+holt/tui/commands.py,sha256=Up2Ysz5YkvKCVie-29ay83fpYm-f7mK3XOF6bKxXlMA,5788
+holt/tui/discovery.py,sha256=2BCdJ6Zp2KheaAI_D6shV7h-JedeqlfJNjlvo4h-ccY,11704
+holt/tui/env.py,sha256=CQ5HB8DxO0uRkcK1rI0V2VscaDAEMOaMy8OYkqHvRzM,1697
+holt/tui/events.py,sha256=T4qrzVckOqLzKn-H07Xu2nDDNjD1w-s723FtfoOCTwQ,7609
+holt/tui/mascot.py,sha256=6OVYRekH9MDMXqDCQOtK0Tfqhbt2FRt-RdakXSZaYq8,4670
+holt/tui/models.py,sha256=_NHxrW7oXq1YItLxr7paQ9aM1zCcOeEoGFu3SetC-gk,23351
+holt/tui/observe.py,sha256=W0oEtTPnAp9YMOHNEFLdysUKC8bXI0kzrDevuln0Q_c,11355
+holt/tui/session.py,sha256=m83m2y5y0AQ3CkWY8ORGidNKNG1MTp61aY6SVaTUNqU,30330
+holt/tui/store.py,sha256=ZZqUlUM_t7Krq4FQ6vTTUd7lMK4rjGO2k64IBNGbwdM,17937
+holt/tui/theme.py,sha256=O3MJeLcYVl7N2PyxINF5z2OpUE_eKycslispwy4KUy0,13067
+holt/tui/visual.py,sha256=C8uGapA1DvxE2v5e9AYUYF1PX8hHymKbIhWBV2na1w8,1148
+holt/tui/screens/__init__.py,sha256=wbGP0Q_YuK4JObPxtX4xrkCdTy5i_6FsEhWKrhSZWak,1051
+holt/tui/screens/assessment.py,sha256=tHYSkaJqO461pkx0mW9aJBVN39QftVC3tgZD_DbqEVs,14319
+holt/tui/screens/confirm.py,sha256=DHFKJfQDWlTJW30ZPMwVjXC1d0kwE8WLvZj4LH_99iM,1945
+holt/tui/screens/discover.py,sha256=gZHLUYi2JMtd70gM3rhmIrhaB9V-nSN6IfPWg5Ag_6Q,18660
+holt/tui/screens/home.py,sha256=5zVJMa6eFZJ9JsMOuSdUCyEV8HNCMI_Adx1DeSiQ1yc,23159
+holt/tui/screens/inspector.py,sha256=PpX0gQiioT8LxMjuwwSMLKy75F4X1igOZWJ_sevNOCI,3953
+holt/tui/screens/live.py,sha256=vLRQbSuK5tAATrZEy-4jjlFe3OCLSLLZw9X1mEK5Gao,14180
+holt/tui/screens/models.py,sha256=7t-zQk-JK-LnjILwuQPIJL3Dru-zENfPTf9z-lmdILc,15376
+holt/tui/screens/next_steps.py,sha256=dyyf06Ft3qqSnxLMKXrh0H0-yLPRJUF41jPIS76l4hg,18654
+holt/tui/screens/profile.py,sha256=lK2SGllhUwFhmmqH1t7wa9nf3zvSC0NwAz_X7PPZHMo,4730
+holt/tui/widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holt/tui/widgets/candidates.py,sha256=pK77I3e0c0e0a-23OetG8ZszWuzptzfXX5gmnxG6FoI,2720
+holt/tui/widgets/claims.py,sha256=UjCm354yQAM5CYcDj-pvGKN51coRUXtZ9VM_1tKGMew,2035
+holt/tui/widgets/disclosure.py,sha256=U6kHO1ouosEe301kDQ_JqbgHtCR9yCOnbIPGZsC0kAc,4523
+holt/tui/widgets/evidence.py,sha256=3znmJpQ32eSKBNqMorE2e345C7LS4VbBqDJgodYOFQ8,4181
+holt/tui/widgets/masthead.py,sha256=fEK8ShfZquDU_wXQQBNJT772So7y9QQxW221koxsFks,4400
+holt/tui/widgets/recent.py,sha256=upzuQcnbWaxYTmbSpERiltQe5hBbT_cIZ-vanwOq57I,6302
+holt/tui/widgets/scrolling.py,sha256=X7NCOQ4kXpG7YPc5ndJ0htZrfT_ds03C-IIkZ0BPZdg,1747
+holt/tui/widgets/stages.py,sha256=hlsIzDVhbUwXugYElAWgwn8eFRXPxGJ5nU6853HizHE,8153
+holt_cli-0.1.0.dist-info/METADATA,sha256=-QyBSwCv_nHElq05s17pyGcNDs9Wf6O6aDkJ7z47w9U,7464
+holt_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+holt_cli-0.1.0.dist-info/entry_points.txt,sha256=nv3JMCxhB1SvX6AW7vjfHjez7bKJP6GiNHQoB3KrPQ0,39
+holt_cli-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+holt_cli-0.1.0.dist-info/licenses/NOTICE,sha256=6qCav9tAXKnPlsDpGdbqDRJFONQnNBDGiz5xC3eersQ,96
+holt_cli-0.1.0.dist-info/RECORD,,

holt_cli-0.1.0.dist-info/WHEEL

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

holt_cli-0.1.0.dist-info/entry_points.txt

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