factguard 0.1.0__tar.gz

factguard-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false # report every combination, not just the first failure
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python: ["3.10", "3.11", "3.12", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python }}
+      - run: uv sync
+      - run: uv run pytest
+      - name: lint
+        if: matrix.os == 'ubuntu-latest' && matrix.python == '3.13'
+        run: |
+          uv run ruff format --check .
+          uv run ruff check .

factguard-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v7
+      - run: uv run pytest
+      - run: uv build
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # PyPI trusted publishing, no stored token
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

factguard-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/
+.DS_Store
+.claude/settings.local.json

factguard-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,42 @@
+# Contributing to factguard
+
+Thanks for your interest! factguard aims to stay small, dependency-free and
+easy to read, so the best contributions are focused.
+
+## Getting started
+
+1. Fork the repo and create a branch from `main`.
+2. Install [uv](https://docs.astral.sh/uv/) and set up the project:
+   ```sh
+   uv sync
+   uv run pytest
+   ```
+3. Make your change with a test, then check formatting and lint:
+   ```sh
+   uv run ruff format .
+   uv run ruff check .
+   ```
+4. Open a pull request describing what you changed and why.
+
+CI runs the tests on Python 3.10 to 3.13 on Linux, macOS and Windows, so
+please make sure it stays green.
+
+## Good first contributions
+
+- **False positives and misses.** A sentence that was flagged but shouldn't be,
+  or let through but shouldn't be. Add it as a test case first.
+- **Date formats.** More ways of writing dates and periods that should be
+  checked against the analysis window.
+- **Formatting.** Locale-aware number formats, such as lakh and crore grouping.
+- **Examples.** Short examples for other LLM SDKs.
+
+For larger changes (new rule kinds, API changes, any new dependency), please
+open an issue first so we can agree on the approach.
+
+## Code style
+
+- Python 3.10+, standard library only.
+- Readable over clever. Prefer small functions and plain loops.
+- Strict by default: a new allowance should be narrow and, where in doubt,
+  opt-in.
+- Write brief comments explaining *why* a rule exists.

factguard-0.1.0/LICENSE

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

factguard-0.1.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.5
+Name: factguard
+Version: 0.1.0
+Summary: Keep LLM-written text free of numbers your code didn't compute: fact placeholders, a strict validator, one retry, then drop the sentence
+Project-URL: Homepage, https://github.com/shivamsingh262/factguard
+Project-URL: Issues, https://github.com/shivamsingh262/factguard/issues
+Project-URL: Design notes, https://shivamsingh262.github.io/notes/code-computes-llm-interprets/
+Author: Shivam Singh
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,analytics,grounding,guardrails,hallucination,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# factguard
+
+[![CI](https://github.com/shivamsingh262/factguard/actions/workflows/ci.yml/badge.svg)](https://github.com/shivamsingh262/factguard/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
+![No dependencies](https://img.shields.io/badge/dependencies-none-brightgreen)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](CONTRIBUTING.md)
+
+Keep LLM-written text free of numbers your code didn't compute.
+
+If an LLM writes a wrong number confidently, users stop trusting every other
+number on the screen. factguard enforces one rule: **code computes every
+number, the LLM only interprets.**
+
+- Your code registers each number as a **fact**: a key, a value, a format
+  (money, percent, count, ratio...) and where it came from.
+- The LLM cites facts as placeholders like `{{fact:spend}}` and never types the
+  digits itself.
+- A **validator** rejects any literal number, unknown fact key, or date or
+  duration outside the analysis window.
+- On failure the model gets **one retry** with a message naming exactly what
+  broke. If the retry fails too, the offending **sentences are dropped**. A
+  shorter answer is better than a wrong one.
+
+It works with any LLM and any SDK, and has no dependencies. The design comes
+from a production AI analyst for marketing teams; the write-up is
+[Stopping an LLM from making up numbers in an AI analyst](https://shivamsingh262.github.io/notes/code-computes-llm-interprets/).
+
+## Install
+
+```sh
+pip install git+https://github.com/shivamsingh262/factguard
+```
+
+## Quick start
+
+```python
+from datetime import date
+from factguard import Facts, guard
+
+facts = Facts(currency="INR")
+facts.add("spend", 61_240, "money", label="Ad spend this week")
+facts.add("roas", 1.8, "ratio", label="ROAS this week")
+facts.add("roas_prev", 2.4, "ratio", label="ROAS last week")
+
+system_prompt = facts.prompt()   # the rules, plus "- {{fact:spend}} = INR 61.2K (...)"
+
+def generate(retry):
+    # Call your LLM here. On a retry, show it retry.draft and retry.feedback.
+    ...
+
+week = (date(2026, 9, 22), date(2026, 9, 28))
+result = guard(generate, facts, windows=[week], user_text="Why did ROAS drop?")
+
+result.text      # "ROAS fell from 2.4x to 1.8x while spend held at INR 61.2K."
+result.dropped   # sentences removed because they still broke the rules
+result.attempts  # 1 or 2
+```
+
+[`examples/anthropic_analyst.py`](examples/anthropic_analyst.py) is a complete
+example using Claude.
+
+## What counts as a violation
+
+| Kind | Example | Why it fails |
+|---|---|---|
+| `literal_number` | `CPA is up 40%` | The model typed a number. Cite a fact or say it without the figure. |
+| `unknown_fact` | `{{fact:f_9999.roas}}` | No such fact was computed. |
+| `malformed_placeholder` | `{{spend}}` | Placeholders must be exactly `{{fact:key}}`. |
+| `date` | `since Oct 3` | Dates, months and years must fall inside a window you passed. |
+| `duration` | `over the last 45 days` | Durations must match the length of a window you passed. |
+| `number_word` | `spend nearly doubled` | Only with `number_words=True`. |
+
+Allowed without a fact:
+
+- numbered list markers (`1.`, `2)`)
+- attribution labels (`7-day click`, `1-day view`)
+- names like `GA4`, `B2B`, `3rd-party` and `24/7`
+- numbers the user typed (`user_text`), so "campaigns with ROAS below 2" can
+  repeat the 2
+- your own patterns: `allow=[r"SKU-\d+"]`
+
+Without `windows`, every date and duration fails. That is deliberate: the
+model shouldn't do date arithmetic. Resolve "last month" in code and pass the
+window you actually queried. Pass both windows when you compare two periods.
+
+## The pieces
+
+**`Facts`** holds the facts for one answer.
+
+- `facts.add(key, value, kind, label=..., currency=..., decimals=..., source=..., step=...)`
+- `facts.prompt()` returns the citation rules and fact list for your system prompt.
+- `facts.render(text)` replaces placeholders with formatted values. It also strips a currency the model typed in
+  front of a money placeholder (`INR {{fact:spend}}`), since the fact brings its own.
+- `Facts.from_records(json_data)` loads facts from JSON.
+
+Formats: `money` renders as `INR 61.2K` or `$1.2M` (pass `Formatter(compact=False)` for `61,240`). `percent` takes
+fractions, so `0.034` renders as `3.4%`. `count` renders as `12,480`, `ratio` as `2.3x`, and `text` as-is. To use
+your own formatting, pass any `Callable[[Fact], str]` as `formatter=`.
+
+**`validate(text, facts, **rules)`** returns a `Report` with `.ok`, `.violations` (kind, token, start, end) and
+`.feedback`, a retry message that names each offending token.
+
+**`guard(generate, facts, retries=1, **rules)`** runs the whole loop. `generate(None)` should return a first draft,
+and `generate(retry)` a corrected one. Use `aguard` for async code.
+
+**`StreamGuard(facts, **rules)`** checks streamed text one sentence at a time. A sentence already on screen can't
+be rewritten, so a failing sentence is dropped instead of retried:
+
+```python
+sg = StreamGuard(facts, windows=[week])
+for chunk in llm_stream:
+    for sentence in sg.feed(chunk):
+        ui.append(sentence)
+for sentence in sg.close():
+    ui.append(sentence)
+```
+
+**Evals.** Check every recorded answer for zero ungrounded numbers, not just for the right answer:
+
+```python
+from factguard.testing import assert_grounded
+
+def test_recorded_answer():
+    assert_grounded(answer, facts, windows=[week])
+```
+
+Or from the shell or CI:
+
+```sh
+factguard check answer.txt --facts facts.json --window 2026-09-22:2026-09-28
+factguard render answer.txt --facts facts.json
+```
+
+## Trade-offs
+
+The prose gets stiffer. Without "nearly double" or "about a third", the model
+writes more literal sentences. Some sentences get dropped, and a retry adds
+latency. If users have to trust the numbers before the interpretation is worth
+anything, that trade is worth it.
+
+Placeholders don't stop the model from citing the *wrong* fact, so keep fact
+labels clear and test with recorded questions. And `number_words` is a
+heuristic: it is off by default because words like "half" are often harmless.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Bug reports with a sentence that was
+wrongly flagged or wrongly let through are especially useful.
+
+## License
+
+[MIT](LICENSE)

factguard-0.1.0/README.md

@@ -0,0 +1,153 @@
+# factguard
+
+[![CI](https://github.com/shivamsingh262/factguard/actions/workflows/ci.yml/badge.svg)](https://github.com/shivamsingh262/factguard/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
+![No dependencies](https://img.shields.io/badge/dependencies-none-brightgreen)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](CONTRIBUTING.md)
+
+Keep LLM-written text free of numbers your code didn't compute.
+
+If an LLM writes a wrong number confidently, users stop trusting every other
+number on the screen. factguard enforces one rule: **code computes every
+number, the LLM only interprets.**
+
+- Your code registers each number as a **fact**: a key, a value, a format
+  (money, percent, count, ratio...) and where it came from.
+- The LLM cites facts as placeholders like `{{fact:spend}}` and never types the
+  digits itself.
+- A **validator** rejects any literal number, unknown fact key, or date or
+  duration outside the analysis window.
+- On failure the model gets **one retry** with a message naming exactly what
+  broke. If the retry fails too, the offending **sentences are dropped**. A
+  shorter answer is better than a wrong one.
+
+It works with any LLM and any SDK, and has no dependencies. The design comes
+from a production AI analyst for marketing teams; the write-up is
+[Stopping an LLM from making up numbers in an AI analyst](https://shivamsingh262.github.io/notes/code-computes-llm-interprets/).
+
+## Install
+
+```sh
+pip install git+https://github.com/shivamsingh262/factguard
+```
+
+## Quick start
+
+```python
+from datetime import date
+from factguard import Facts, guard
+
+facts = Facts(currency="INR")
+facts.add("spend", 61_240, "money", label="Ad spend this week")
+facts.add("roas", 1.8, "ratio", label="ROAS this week")
+facts.add("roas_prev", 2.4, "ratio", label="ROAS last week")
+
+system_prompt = facts.prompt()   # the rules, plus "- {{fact:spend}} = INR 61.2K (...)"
+
+def generate(retry):
+    # Call your LLM here. On a retry, show it retry.draft and retry.feedback.
+    ...
+
+week = (date(2026, 9, 22), date(2026, 9, 28))
+result = guard(generate, facts, windows=[week], user_text="Why did ROAS drop?")
+
+result.text      # "ROAS fell from 2.4x to 1.8x while spend held at INR 61.2K."
+result.dropped   # sentences removed because they still broke the rules
+result.attempts  # 1 or 2
+```
+
+[`examples/anthropic_analyst.py`](examples/anthropic_analyst.py) is a complete
+example using Claude.
+
+## What counts as a violation
+
+| Kind | Example | Why it fails |
+|---|---|---|
+| `literal_number` | `CPA is up 40%` | The model typed a number. Cite a fact or say it without the figure. |
+| `unknown_fact` | `{{fact:f_9999.roas}}` | No such fact was computed. |
+| `malformed_placeholder` | `{{spend}}` | Placeholders must be exactly `{{fact:key}}`. |
+| `date` | `since Oct 3` | Dates, months and years must fall inside a window you passed. |
+| `duration` | `over the last 45 days` | Durations must match the length of a window you passed. |
+| `number_word` | `spend nearly doubled` | Only with `number_words=True`. |
+
+Allowed without a fact:
+
+- numbered list markers (`1.`, `2)`)
+- attribution labels (`7-day click`, `1-day view`)
+- names like `GA4`, `B2B`, `3rd-party` and `24/7`
+- numbers the user typed (`user_text`), so "campaigns with ROAS below 2" can
+  repeat the 2
+- your own patterns: `allow=[r"SKU-\d+"]`
+
+Without `windows`, every date and duration fails. That is deliberate: the
+model shouldn't do date arithmetic. Resolve "last month" in code and pass the
+window you actually queried. Pass both windows when you compare two periods.
+
+## The pieces
+
+**`Facts`** holds the facts for one answer.
+
+- `facts.add(key, value, kind, label=..., currency=..., decimals=..., source=..., step=...)`
+- `facts.prompt()` returns the citation rules and fact list for your system prompt.
+- `facts.render(text)` replaces placeholders with formatted values. It also strips a currency the model typed in
+  front of a money placeholder (`INR {{fact:spend}}`), since the fact brings its own.
+- `Facts.from_records(json_data)` loads facts from JSON.
+
+Formats: `money` renders as `INR 61.2K` or `$1.2M` (pass `Formatter(compact=False)` for `61,240`). `percent` takes
+fractions, so `0.034` renders as `3.4%`. `count` renders as `12,480`, `ratio` as `2.3x`, and `text` as-is. To use
+your own formatting, pass any `Callable[[Fact], str]` as `formatter=`.
+
+**`validate(text, facts, **rules)`** returns a `Report` with `.ok`, `.violations` (kind, token, start, end) and
+`.feedback`, a retry message that names each offending token.
+
+**`guard(generate, facts, retries=1, **rules)`** runs the whole loop. `generate(None)` should return a first draft,
+and `generate(retry)` a corrected one. Use `aguard` for async code.
+
+**`StreamGuard(facts, **rules)`** checks streamed text one sentence at a time. A sentence already on screen can't
+be rewritten, so a failing sentence is dropped instead of retried:
+
+```python
+sg = StreamGuard(facts, windows=[week])
+for chunk in llm_stream:
+    for sentence in sg.feed(chunk):
+        ui.append(sentence)
+for sentence in sg.close():
+    ui.append(sentence)
+```
+
+**Evals.** Check every recorded answer for zero ungrounded numbers, not just for the right answer:
+
+```python
+from factguard.testing import assert_grounded
+
+def test_recorded_answer():
+    assert_grounded(answer, facts, windows=[week])
+```
+
+Or from the shell or CI:
+
+```sh
+factguard check answer.txt --facts facts.json --window 2026-09-22:2026-09-28
+factguard render answer.txt --facts facts.json
+```
+
+## Trade-offs
+
+The prose gets stiffer. Without "nearly double" or "about a third", the model
+writes more literal sentences. Some sentences get dropped, and a retry adds
+latency. If users have to trust the numbers before the interpretation is worth
+anything, that trade is worth it.
+
+Placeholders don't stop the model from citing the *wrong* fact, so keep fact
+labels clear and test with recorded questions. And `number_words` is a
+heuristic: it is off by default because words like "half" are often harmless.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Bug reports with a sentence that was
+wrongly flagged or wrongly let through are especially useful.
+
+## License
+
+[MIT](LICENSE)

factguard-0.1.0/examples/anthropic_analyst.py

@@ -0,0 +1,66 @@
+"""Ask Claude why ROAS dropped, with every number in the answer guarded.
+
+    pip install factguard anthropic
+    export ANTHROPIC_API_KEY=...
+    python examples/anthropic_analyst.py
+
+The numbers below are made up. In a real system they come from your own
+queries; the point is that code computes them and the model only cites them.
+"""
+
+from datetime import date
+
+import anthropic
+
+from factguard import Facts, Retry, guard
+
+this_week = (date(2026, 9, 22), date(2026, 9, 28))
+last_week = (date(2026, 9, 15), date(2026, 9, 21))
+
+facts = Facts(currency="INR")
+facts.add("spend", 61_240, "money", label="Ad spend this week", source="meta_ads")
+facts.add("spend_prev", 59_800, "money", label="Ad spend last week", source="meta_ads")
+facts.add("roas", 1.8, "ratio", label="ROAS this week", source="shopify + meta_ads")
+facts.add("roas_prev", 2.4, "ratio", label="ROAS last week", source="shopify + meta_ads")
+facts.add("ctr", 0.0121, "percent", decimals=2, label="CTR this week", source="meta_ads")
+facts.add("ctr_prev", 0.0184, "percent", decimals=2, label="CTR last week", source="meta_ads")
+facts.add("top_ad", "Summer UGC v3", "text", label="Ad set with the biggest CTR drop", source="meta_ads")
+
+question = "Why did ROAS drop last week?"
+system = (
+    "You are a marketing analyst. Answer in a short paragraph or a few bullets.\n"
+    f"This week is {this_week[0]:%b %d} to {this_week[1]:%b %d}; "
+    f"it is compared with {last_week[0]:%b %d} to {last_week[1]:%b %d}.\n\n" + facts.prompt()
+)
+
+client = anthropic.Anthropic()
+
+
+def generate(retry: Retry | None) -> str:
+    messages = [{"role": "user", "content": question}]
+    if retry:
+        # Show the model its own draft and exactly what broke the rules.
+        messages += [
+            {"role": "assistant", "content": retry.draft},
+            {"role": "user", "content": retry.feedback},
+        ]
+    response = client.beta.messages.create(
+        model="claude-opus-5-5",
+        max_tokens=16000,
+        system=system,
+        messages=messages,
+        # If the model declines, the API reruns the request on a fallback model.
+        betas=["server-side-fallback-2026-07-01"],
+        fallbacks="default",
+    )
+    if response.stop_reason == "refusal":
+        raise RuntimeError("the model declined to answer")
+    return "".join(block.text for block in response.content if block.type == "text")
+
+
+result = guard(generate, facts, windows=[this_week, last_week], user_text=question)
+
+print(result.text)
+print(f"\n[{result.attempts} attempt(s)]")
+for sentence in result.dropped:
+    print(f"[dropped] {sentence}")

factguard-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "factguard"
+version = "0.1.0"
+description = "Keep LLM-written text free of numbers your code didn't compute: fact placeholders, a strict validator, one retry, then drop the sentence"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Shivam Singh" }]
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["llm", "hallucination", "grounding", "ai-agents", "guardrails", "analytics"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/shivamsingh262/factguard"
+Issues = "https://github.com/shivamsingh262/factguard/issues"
+"Design notes" = "https://shivamsingh262.github.io/notes/code-computes-llm-interprets/"
+
+[project.scripts]
+factguard = "factguard.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+extend-exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

factguard-0.1.0/src/factguard/__init__.py

@@ -0,0 +1,29 @@
+"""Code computes every number, the LLM only interprets.
+
+factguard keeps LLM-written text free of numbers your code didn't compute.
+"""
+
+from .facts import RULES, Fact, Facts, Formatter
+from .guard import Result, Retry, StreamGuard, aguard, guard
+from .sentences import drop_sentences, split_sentences
+from .validate import Report, Violation, Window, validate
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "RULES",
+    "Fact",
+    "Facts",
+    "Formatter",
+    "Report",
+    "Result",
+    "Retry",
+    "StreamGuard",
+    "Violation",
+    "Window",
+    "aguard",
+    "drop_sentences",
+    "guard",
+    "split_sentences",
+    "validate",
+]

factguard-0.1.0/src/factguard/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())