story-test 1.2.0__tar.gz

story_test-1.2.0/LICENSE

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

story_test-1.2.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: story-test
+Version: 1.2.0
+Summary: Evaluate story assertions with a local Ollama model.
+Author: legomb
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/legomb/story-test
+Project-URL: Issues, https://github.com/legomb/story-test/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: ollama>=0.6
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# Story test
+
+[![Build](https://github.com/legomb/story-test/actions/workflows/build.yml/badge.svg)](https://github.com/legomb/story-test/actions/workflows/build.yml)
+
+CLI tool that runs tests against a story.
+
+Lets you define a list of checks you expect from your story (e.g. "The hero wins in the end"), and determines whether each one passes or fails.
+
+It does not replace a human editor, but it's a great tool to aid in the editing phase, for both writers and editors:
+
+- Make sure your story's main points are addressed while editing your story.
+- Build and grow a repository with standard tests you want to run on manuscripts, and make specific tests for specific genres, etc.
+
+Uses a local [Ollama](https://ollama.com/) model.
+
+## Usage
+
+Create a test file containing assertions about a story:
+
+```yaml
+tests:
+	- name: author
+		assertion: The story was written by Edgar Allan Poe.
+	- name: ending
+		assertion: The narrator confesses at the end of the story.
+```
+
+Run the tests against one or more Markdown files:
+
+```bash
+story-test story.tests.yml story.md
+story-test story.tests.yml chapter-1.md chapter-2.md
+```
+
+Failed assertions are reported without failing the process by default. For CI, use strict mode:
+
+```bash
+story-test story.tests.yml story.md --fail-on-test-failure
+```
+
+## 🚀 Getting Started
+
+This repo uses **direnv**, **Devbox**, **Taskfile**, and **pre-commit** for a reproducible dev environment and automatic schema/YAML validation.
+
+### Setup
+
+```bash
+# Automatically enter devbox via direnv (if available)
+direnv allow
+
+# Enter dev environment
+devbox shell
+
+# Install pre-commit hooks
+task pre-commit:install
+```
+
+### Tasks
+
+Run `task` to see a list of available tasks.
+
+Install the development dependencies with:
+
+```bash
+task environment:dev:install
+```
+
+For a local user installation, run the bootstrap script from this repository:
+
+```bash
+sh install.sh
+```
+
+This creates an isolated Python environment, installs the `story-test` command,
+and pulls the default Ollama model. The installed command can then be used from
+any directory:
+
+```bash
+story-test path/to/story.tests.yml path/to/story.md
+```
+
+Set `STORY_TEST_MODEL` before running the installer to use another model:
+
+```bash
+STORY_TEST_MODEL=qwen3:30b-a3b sh install.sh
+```
+
+Install Ollama separately, then download the default model through Task:
+
+```bash
+task environment:ollama:install
+```
+
+To use a model already installed locally:
+
+```bash
+OLLAMA_MODEL=qwen3:30b-a3b task environment:ollama:install
+```
+
+Run the sample story tests. Failed story assertions are reported but do not
+fail the task by default:
+
+```bash
+task test:example-story
+```
+
+The local model is `qwen3:8b` by default. Set `STORY_TEST_MODEL` to use another
+model already installed in Ollama.
+
+The model can be changed with `STORY_TEST_MODEL`, and the context window can be
+changed with `STORY_TEST_CONTEXT_LENGTH`.
+
+To make failed story assertions fail the task, use the strict variant:
+
+```bash
+task test:example-story:strict
+```
+
+Run the complete local validation suite:
+
+```bash
+task test:all
+```
+
+This runs schema validation, Python unit tests, and the sample story tests.
+
+The GitHub Actions workflow installs Ollama and pulls `qwen3:8b` automatically.
+Qwen open-weight models are Apache 2.0 licensed and Ollama is MIT licensed;
+always review the license for the exact model tag you deploy.
+
+Run formatting and pre-commit checks with:
+
+```bash
+task format:check
+task pre-commit:run
+```
+
+Before publishing a release, build and validate both distribution formats:
+
+```bash
+task package:check
+```
+
+This creates the wheel and source archive under `dist/` and validates them with
+Twine. Increment the version in `pyproject.toml` before building a new release.
+
+## Features
+
+- [x] JSON structure validation using `jq`
+- [x] Schema validation using `check-jsonschema` (temporarily disabled)
+- [x] CI/CD integration with GitHub Actions
+- [x] Versioning schemas with directories like `schemas/v1`, `schemas/v2`
+- [x] Documentation with inline schema descriptions
+- [x] Code formatting using `prettier` or `jq`
+- [ ] Documentation with `README` or extended docs folder (pending)
+- [ ] Schema hosting via `$id` URLs or SchemaStore (pending)

story_test-1.2.0/README.md

@@ -0,0 +1,156 @@
+# Story test
+
+[![Build](https://github.com/legomb/story-test/actions/workflows/build.yml/badge.svg)](https://github.com/legomb/story-test/actions/workflows/build.yml)
+
+CLI tool that runs tests against a story.
+
+Lets you define a list of checks you expect from your story (e.g. "The hero wins in the end"), and determines whether each one passes or fails.
+
+It does not replace a human editor, but it's a great tool to aid in the editing phase, for both writers and editors:
+
+- Make sure your story's main points are addressed while editing your story.
+- Build and grow a repository with standard tests you want to run on manuscripts, and make specific tests for specific genres, etc.
+
+Uses a local [Ollama](https://ollama.com/) model.
+
+## Usage
+
+Create a test file containing assertions about a story:
+
+```yaml
+tests:
+	- name: author
+		assertion: The story was written by Edgar Allan Poe.
+	- name: ending
+		assertion: The narrator confesses at the end of the story.
+```
+
+Run the tests against one or more Markdown files:
+
+```bash
+story-test story.tests.yml story.md
+story-test story.tests.yml chapter-1.md chapter-2.md
+```
+
+Failed assertions are reported without failing the process by default. For CI, use strict mode:
+
+```bash
+story-test story.tests.yml story.md --fail-on-test-failure
+```
+
+## 🚀 Getting Started
+
+This repo uses **direnv**, **Devbox**, **Taskfile**, and **pre-commit** for a reproducible dev environment and automatic schema/YAML validation.
+
+### Setup
+
+```bash
+# Automatically enter devbox via direnv (if available)
+direnv allow
+
+# Enter dev environment
+devbox shell
+
+# Install pre-commit hooks
+task pre-commit:install
+```
+
+### Tasks
+
+Run `task` to see a list of available tasks.
+
+Install the development dependencies with:
+
+```bash
+task environment:dev:install
+```
+
+For a local user installation, run the bootstrap script from this repository:
+
+```bash
+sh install.sh
+```
+
+This creates an isolated Python environment, installs the `story-test` command,
+and pulls the default Ollama model. The installed command can then be used from
+any directory:
+
+```bash
+story-test path/to/story.tests.yml path/to/story.md
+```
+
+Set `STORY_TEST_MODEL` before running the installer to use another model:
+
+```bash
+STORY_TEST_MODEL=qwen3:30b-a3b sh install.sh
+```
+
+Install Ollama separately, then download the default model through Task:
+
+```bash
+task environment:ollama:install
+```
+
+To use a model already installed locally:
+
+```bash
+OLLAMA_MODEL=qwen3:30b-a3b task environment:ollama:install
+```
+
+Run the sample story tests. Failed story assertions are reported but do not
+fail the task by default:
+
+```bash
+task test:example-story
+```
+
+The local model is `qwen3:8b` by default. Set `STORY_TEST_MODEL` to use another
+model already installed in Ollama.
+
+The model can be changed with `STORY_TEST_MODEL`, and the context window can be
+changed with `STORY_TEST_CONTEXT_LENGTH`.
+
+To make failed story assertions fail the task, use the strict variant:
+
+```bash
+task test:example-story:strict
+```
+
+Run the complete local validation suite:
+
+```bash
+task test:all
+```
+
+This runs schema validation, Python unit tests, and the sample story tests.
+
+The GitHub Actions workflow installs Ollama and pulls `qwen3:8b` automatically.
+Qwen open-weight models are Apache 2.0 licensed and Ollama is MIT licensed;
+always review the license for the exact model tag you deploy.
+
+Run formatting and pre-commit checks with:
+
+```bash
+task format:check
+task pre-commit:run
+```
+
+Before publishing a release, build and validate both distribution formats:
+
+```bash
+task package:check
+```
+
+This creates the wheel and source archive under `dist/` and validates them with
+Twine. Increment the version in `pyproject.toml` before building a new release.
+
+## Features
+
+- [x] JSON structure validation using `jq`
+- [x] Schema validation using `check-jsonschema` (temporarily disabled)
+- [x] CI/CD integration with GitHub Actions
+- [x] Versioning schemas with directories like `schemas/v1`, `schemas/v2`
+- [x] Documentation with inline schema descriptions
+- [x] Code formatting using `prettier` or `jq`
+- [ ] Documentation with `README` or extended docs folder (pending)
+- [ ] Schema hosting via `$id` URLs or SchemaStore (pending)

story_test-1.2.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "story-test"
+version = "1.2.0"
+description = "Evaluate story assertions with a local Ollama model."
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{name = "legomb"}]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  "jsonschema>=4.0",
+  "ollama>=0.6",
+  "PyYAML>=6.0",
+]
+
+[project.scripts]
+story-test = "story_test:main"
+
+[project.urls]
+Homepage = "https://github.com/legomb/story-test"
+Issues = "https://github.com/legomb/story-test/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["story_test"]
+
+[tool.setuptools.data-files]
+"share/story-test/schemas/v1" = ["schemas/v1/tests.schema.json"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

story_test-1.2.0/schemas/v1/tests.schema.json

@@ -0,0 +1,33 @@
+{
+  "$id": "https://example.com/story-tests.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Story tests schema",
+  "description": "Schema for a list of assertions about a story.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["tests"],
+  "properties": {
+    "tests": {
+      "type": "array",
+      "description": "A list of story assertions to evaluate.",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name", "assertion"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "A unique name for the test.",
+            "minLength": 1
+          },
+          "assertion": {
+            "type": "string",
+            "description": "A claim about the story that can be evaluated as passing or failing.",
+            "minLength": 1
+          }
+        }
+      }
+    }
+  }
+}

story_test-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

story_test-1.2.0/src/story_test/__init__.py

@@ -0,0 +1,3 @@
+from .cli import OllamaRunner, exit_code, main, run_tests
+
+__all__ = ["OllamaRunner", "exit_code", "main", "run_tests"]

story_test-1.2.0/src/story_test/cli.py

@@ -0,0 +1,186 @@
+"""Evaluate story assertions with a local Ollama model."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Iterable
+
+from ollama import Client, ResponseError
+import yaml
+from jsonschema import validate
+
+SOURCE_SCHEMA_PATH = (
+    Path(__file__).resolve().parents[2] / "schemas/v1/tests.schema.json"
+)
+INSTALLED_SCHEMA_PATH = (
+    Path(sys.prefix) / "share/story-test/schemas/v1/tests.schema.json"
+)
+DEFAULT_MODEL = "qwen3:8b"
+DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434"
+DEFAULT_CONTEXT_LENGTH = 32768
+
+
+class OllamaRunner:
+    def __init__(self, model: str, host: str, context_length: int) -> None:
+        self.model = model
+        self.context_length = context_length
+        self.client = Client(host=host)
+
+    def predict(
+        self, state: str, questions: dict[str, dict[str, Any]]
+    ) -> dict[str, Any]:
+        answers = {}
+        for question_id in questions:
+            try:
+                response = self.client.chat(
+                    model=self.model,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": (
+                                "Evaluate the assertion against the story. "
+                                "Return true only when the story supports it."
+                            ),
+                        },
+                        {"role": "user", "content": state},
+                    ],
+                    format={
+                        "type": "object",
+                        "properties": {"supported": {"type": "boolean"}},
+                        "required": ["supported"],
+                    },
+                    options={"num_ctx": self.context_length, "temperature": 0},
+                )
+            except ResponseError as error:
+                if error.status_code == 404:
+                    raise RuntimeError(
+                        f"Ollama model {self.model!r} is not installed. "
+                        f"Run `OLLAMA_MODEL={self.model} task environment:ollama:install`."
+                    ) from error
+                raise
+            content = response.message.content
+            parsed = json.loads(content)
+            answers[question_id] = {"supported": parsed["supported"]}
+        return {"answers": answers}
+
+
+def load_tests(path: Path) -> list[dict[str, str]]:
+    with path.open(encoding="utf-8") as file:
+        document = yaml.safe_load(file)
+
+    schema_path = (
+        SOURCE_SCHEMA_PATH if SOURCE_SCHEMA_PATH.exists() else INSTALLED_SCHEMA_PATH
+    )
+    with schema_path.open(encoding="utf-8") as file:
+        schema = yaml.safe_load(file)
+    validate(document, schema)
+    return document["tests"]
+
+
+def load_story(paths: Iterable[Path]) -> str:
+    sections = []
+    for path in paths:
+        sections.append(path.read_text(encoding="utf-8"))
+    return "\n\n".join(sections)
+
+
+def _answer_is_true(result: Any, question_id: str) -> bool:
+    answers = result.get("answers") if isinstance(result, dict) else None
+    if not isinstance(answers, dict) or question_id not in answers:
+        raise ValueError(f"Ollama did not return an answer for {question_id!r}")
+
+    answer = answers[question_id]
+    if isinstance(answer, dict) and "supported" in answer:
+        return answer["supported"] is True
+    if isinstance(answer, dict) and "choice" in answer:
+        return answer["choice"] == "true"
+    if isinstance(answer, dict) and "noul" in answer:
+        answer = answer["noul"]
+    if isinstance(answer, bool):
+        return answer
+    if isinstance(answer, (int, float)):
+        return answer >= 0.5
+    raise ValueError(f"Unexpected Ollama answer for {question_id!r}: {answer!r}")
+
+
+def run_tests(
+    tests_path: Path,
+    story_paths: Iterable[Path],
+    runner: Any | None = None,
+    model: str = DEFAULT_MODEL,
+    ollama_host: str = DEFAULT_OLLAMA_HOST,
+    context_length: int = DEFAULT_CONTEXT_LENGTH,
+) -> list[dict[str, Any]]:
+    tests = load_tests(tests_path)
+    story = load_story(story_paths)
+    runner = runner or OllamaRunner(model, ollama_host, context_length)
+    results = []
+    for test in tests:
+        questions = {
+            test["name"]: {
+                "type": "boolean",
+            }
+        }
+        state = f"Assertion: {test['assertion']}\n\nStory:\n{story}"
+        result = runner.predict(state, questions)
+        results.append(
+            {
+                "name": test["name"],
+                "passed": _answer_is_true(result, test["name"]),
+            }
+        )
+    return results
+
+
+def exit_code(results: list[dict[str, Any]], fail_on_test_failure: bool) -> int:
+    if fail_on_test_failure and any(not result["passed"] for result in results):
+        return 1
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Run Ollama assertions against Markdown stories."
+    )
+    parser.add_argument(
+        "tests", type=Path, help="YAML file matching the story tests schema"
+    )
+    parser.add_argument(
+        "stories", type=Path, nargs="+", help="One or more Markdown story files"
+    )
+    parser.add_argument(
+        "--fail-on-test-failure",
+        action="store_true",
+        help="Exit with status 1 when any story test fails",
+    )
+    parser.add_argument("--model", default=os.getenv("STORY_TEST_MODEL", DEFAULT_MODEL))
+    parser.add_argument(
+        "--ollama-host",
+        default=os.getenv("OLLAMA_HOST", DEFAULT_OLLAMA_HOST),
+    )
+    parser.add_argument(
+        "--context-length",
+        type=int,
+        default=int(os.getenv("STORY_TEST_CONTEXT_LENGTH", DEFAULT_CONTEXT_LENGTH)),
+    )
+    args = parser.parse_args()
+
+    results = run_tests(
+        args.tests,
+        args.stories,
+        model=args.model,
+        ollama_host=args.ollama_host,
+        context_length=args.context_length,
+    )
+    for result in results:
+        status = "PASS" if result["passed"] else "FAIL"
+        print(f"Test [{result['name']}]: {status}")
+    return exit_code(results, args.fail_on_test_failure)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

story_test-1.2.0/src/story_test.egg-info/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: story-test
+Version: 1.2.0
+Summary: Evaluate story assertions with a local Ollama model.
+Author: legomb
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/legomb/story-test
+Project-URL: Issues, https://github.com/legomb/story-test/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: ollama>=0.6
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# Story test
+
+[![Build](https://github.com/legomb/story-test/actions/workflows/build.yml/badge.svg)](https://github.com/legomb/story-test/actions/workflows/build.yml)
+
+CLI tool that runs tests against a story.
+
+Lets you define a list of checks you expect from your story (e.g. "The hero wins in the end"), and determines whether each one passes or fails.
+
+It does not replace a human editor, but it's a great tool to aid in the editing phase, for both writers and editors:
+
+- Make sure your story's main points are addressed while editing your story.
+- Build and grow a repository with standard tests you want to run on manuscripts, and make specific tests for specific genres, etc.
+
+Uses a local [Ollama](https://ollama.com/) model.
+
+## Usage
+
+Create a test file containing assertions about a story:
+
+```yaml
+tests:
+	- name: author
+		assertion: The story was written by Edgar Allan Poe.
+	- name: ending
+		assertion: The narrator confesses at the end of the story.
+```
+
+Run the tests against one or more Markdown files:
+
+```bash
+story-test story.tests.yml story.md
+story-test story.tests.yml chapter-1.md chapter-2.md
+```
+
+Failed assertions are reported without failing the process by default. For CI, use strict mode:
+
+```bash
+story-test story.tests.yml story.md --fail-on-test-failure
+```
+
+## 🚀 Getting Started
+
+This repo uses **direnv**, **Devbox**, **Taskfile**, and **pre-commit** for a reproducible dev environment and automatic schema/YAML validation.
+
+### Setup
+
+```bash
+# Automatically enter devbox via direnv (if available)
+direnv allow
+
+# Enter dev environment
+devbox shell
+
+# Install pre-commit hooks
+task pre-commit:install
+```
+
+### Tasks
+
+Run `task` to see a list of available tasks.
+
+Install the development dependencies with:
+
+```bash
+task environment:dev:install
+```
+
+For a local user installation, run the bootstrap script from this repository:
+
+```bash
+sh install.sh
+```
+
+This creates an isolated Python environment, installs the `story-test` command,
+and pulls the default Ollama model. The installed command can then be used from
+any directory:
+
+```bash
+story-test path/to/story.tests.yml path/to/story.md
+```
+
+Set `STORY_TEST_MODEL` before running the installer to use another model:
+
+```bash
+STORY_TEST_MODEL=qwen3:30b-a3b sh install.sh
+```
+
+Install Ollama separately, then download the default model through Task:
+
+```bash
+task environment:ollama:install
+```
+
+To use a model already installed locally:
+
+```bash
+OLLAMA_MODEL=qwen3:30b-a3b task environment:ollama:install
+```
+
+Run the sample story tests. Failed story assertions are reported but do not
+fail the task by default:
+
+```bash
+task test:example-story
+```
+
+The local model is `qwen3:8b` by default. Set `STORY_TEST_MODEL` to use another
+model already installed in Ollama.
+
+The model can be changed with `STORY_TEST_MODEL`, and the context window can be
+changed with `STORY_TEST_CONTEXT_LENGTH`.
+
+To make failed story assertions fail the task, use the strict variant:
+
+```bash
+task test:example-story:strict
+```
+
+Run the complete local validation suite:
+
+```bash
+task test:all
+```
+
+This runs schema validation, Python unit tests, and the sample story tests.
+
+The GitHub Actions workflow installs Ollama and pulls `qwen3:8b` automatically.
+Qwen open-weight models are Apache 2.0 licensed and Ollama is MIT licensed;
+always review the license for the exact model tag you deploy.
+
+Run formatting and pre-commit checks with:
+
+```bash
+task format:check
+task pre-commit:run
+```
+
+Before publishing a release, build and validate both distribution formats:
+
+```bash
+task package:check
+```
+
+This creates the wheel and source archive under `dist/` and validates them with
+Twine. Increment the version in `pyproject.toml` before building a new release.
+
+## Features
+
+- [x] JSON structure validation using `jq`
+- [x] Schema validation using `check-jsonschema` (temporarily disabled)
+- [x] CI/CD integration with GitHub Actions
+- [x] Versioning schemas with directories like `schemas/v1`, `schemas/v2`
+- [x] Documentation with inline schema descriptions
+- [x] Code formatting using `prettier` or `jq`
+- [ ] Documentation with `README` or extended docs folder (pending)
+- [ ] Schema hosting via `$id` URLs or SchemaStore (pending)

story_test-1.2.0/src/story_test.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+schemas/v1/tests.schema.json
+src/story_test/__init__.py
+src/story_test/cli.py
+src/story_test.egg-info/PKG-INFO
+src/story_test.egg-info/SOURCES.txt
+src/story_test.egg-info/dependency_links.txt
+src/story_test.egg-info/entry_points.txt
+src/story_test.egg-info/requires.txt
+src/story_test.egg-info/top_level.txt
+test/test_story_test.py

story_test-1.2.0/src/story_test.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

story_test-1.2.0/src/story_test.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+story-test = story_test:main

story_test-1.2.0/src/story_test.egg-info/requires.txt

@@ -0,0 +1,3 @@
+jsonschema>=4.0
+ollama>=0.6
+PyYAML>=6.0

story_test-1.2.0/src/story_test.egg-info/top_level.txt

@@ -0,0 +1 @@
+story_test

story_test-1.2.0/test/test_story_test.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+from unittest.mock import Mock
+
+from story_test import OllamaRunner, exit_code, run_tests
+
+ROOT = Path(__file__).resolve().parent.parent
+TESTS = ROOT / "test/the-tell-tale-heart.tests.yml"
+STORY = ROOT / "test/the-tell-tale-heart.md"
+
+
+def test_tell_tale_heart_example() -> None:
+    runner = Mock()
+    runner.predict.side_effect = [
+        {"answers": {"author": {"choice": "true"}}},
+        {"answers": {"narrator-reliability": {"choice": "true"}}},
+        {"answers": {"victim": {"choice": "true"}}},
+        {"answers": {"motive": {"choice": "false"}}},
+        {"answers": {"confession": {"choice": "true"}}},
+        {"answers": {"location": {"choice": "false"}}},
+    ]
+
+    results = run_tests(TESTS, [STORY], runner=runner)
+
+    assert results == [
+        {"name": "author", "passed": True},
+        {"name": "narrator-reliability", "passed": True},
+        {"name": "victim", "passed": True},
+        {"name": "motive", "passed": False},
+        {"name": "confession", "passed": True},
+        {"name": "location", "passed": False},
+    ]
+    assert runner.predict.call_count == 6
+    state, questions = runner.predict.call_args_list[0].args
+    assert "The Tell-Tale Heart" in state
+    assert state.startswith("Assertion: The story was written by Edgar Allan Poe.")
+    assert questions["author"]["type"] == "boolean"
+
+
+def test_failures_do_not_affect_exit_code_by_default() -> None:
+    results = [{"name": "location", "passed": False}]
+
+    assert exit_code(results, fail_on_test_failure=False) == 0
+    assert exit_code(results, fail_on_test_failure=True) == 1
+
+
+def test_ollama_runner_reads_structured_boolean() -> None:
+    class Message:
+        content = '{"supported": true}'
+
+    class Response:
+        message = Message()
+
+    class Client:
+        def chat(self, **kwargs):
+            assert kwargs["model"] == "qwen3:8b"
+            assert kwargs["options"]["num_ctx"] == 32768
+            return Response()
+
+    runner = OllamaRunner("qwen3:8b", "http://localhost:11434", 32768)
+    runner.client = Client()
+
+    result = runner.predict("Story text", {"author": {"type": "boolean"}})
+
+    assert result == {"answers": {"author": {"supported": True}}}