saga-cli 0.1.0__py3-none-any.whl

saga/model.py

@@ -0,0 +1,253 @@
+"""Data model for PR sagas — the chapter-based review of one change set.
+
+A saga partitions a change set's whole diff into ordered *chapters* that
+tell a coherent story. This module is the pure, side-effect-light core:
+
+* ``parse_hunks`` splits a unified diff into individually addressable ``Hunk``s
+  (stable ``h0, h1, …`` ids in diff order), and ``reconstruct_diff`` rebuilds a
+  valid unified-diff string for any subset of them — so the browser can render a
+  single chapter through diff2html with the *same* file/line anchors the full
+  diff uses.
+* ``Chapter``/``Saga`` are the persisted shape (``to_dict``/``from_dict``).
+* ``validate_coverage`` enforces the hard invariant: every hunk belongs to at
+  least one chapter. It raises ``SagaError`` loudly on any gap.
+
+Stdlib only — this is the standalone core and has no external dependencies.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+CONFIDENCE_LEVELS = ("high", "medium", "low")
+
+
+class SagaError(Exception):
+    """Raised when a saga is malformed or fails the coverage invariant.
+
+    Carries a human-readable message surfaced to the reviewer as a non-blocking
+    notice before falling back to the standard diff.
+    """
+
+
+# ---------------------------------------------------------------------------
+# Hunk parsing / diff reconstruction
+# ---------------------------------------------------------------------------
+
+_DIFF_GIT_RE = re.compile(r"^diff --git ", re.MULTILINE)
+
+
+@dataclass(frozen=True)
+class Hunk:
+    """One ``@@`` hunk of a unified diff, addressable by a stable id.
+
+    ``preamble`` is the file-level header (``diff --git`` … through the ``+++``
+    line) shared by every hunk of that file; ``body`` is the ``@@`` line plus its
+    context/change lines. Reconstructing a file emits the preamble once followed
+    by each of its hunks' bodies — a valid unified diff diff2html can render.
+    """
+
+    id: str
+    file_path: str
+    preamble: str
+    body: str
+
+
+def _file_path_from_preamble(preamble: str) -> str:
+    """The new-side path diff2html shows in its file header (``+++ b/<path>``).
+
+    Falls back to the ``diff --git b/<path>`` side for pure renames/deletes with
+    no ``+++`` line.
+    """
+    for line in preamble.splitlines():
+        if line.startswith("+++ "):
+            target = line[4:].strip()
+            if target and target != "/dev/null":
+                return target[2:] if target.startswith(("a/", "b/")) else target
+    m = re.search(r"^diff --git a/.* b/(.*)$", preamble, re.MULTILINE)
+    return m.group(1).strip() if m else ""
+
+
+def parse_hunks(diff_text: str) -> list[Hunk]:
+    """Split a unified diff into ``Hunk``s with stable ``h0, h1, …`` ids.
+
+    Files with no ``@@`` hunk (pure renames, mode-only changes) contribute no
+    hunks — there is nothing line-addressable to review.
+    """
+    hunks: list[Hunk] = []
+    starts = [m.start() for m in _DIFF_GIT_RE.finditer(diff_text)]
+    for i, start in enumerate(starts):
+        end = starts[i + 1] if i + 1 < len(starts) else len(diff_text)
+        block = diff_text[start:end]
+        at_idx = block.find("\n@@")
+        if at_idx == -1:
+            continue  # no hunks in this file block
+        preamble = block[: at_idx + 1]  # keep the trailing newline
+        rest = block[at_idx + 1 :]
+        file_path = _file_path_from_preamble(preamble)
+        # Each hunk runs from an "@@" line to the next "@@" (or end of block).
+        for m in re.finditer(r"(?m)^@@ ", rest):
+            h_start = m.start()
+            nxt = rest.find("\n@@ ", h_start + 1)
+            h_end = nxt + 1 if nxt != -1 else len(rest)
+            hunks.append(
+                Hunk(
+                    id=f"h{len(hunks)}",
+                    file_path=file_path,
+                    preamble=preamble,
+                    body=rest[h_start:h_end],
+                )
+            )
+    return hunks
+
+
+def reconstruct_diff(hunks: list[Hunk]) -> str:
+    """Rebuild a valid unified diff from an ordered subset of hunks.
+
+    Hunks are grouped by file (first-seen order preserved); each file's preamble
+    is emitted once, then its selected hunk bodies in the given order. The result
+    renders through diff2html exactly like the full view.
+    """
+    out: list[str] = []
+    seen_preamble: set[str] = set()
+    for hunk in hunks:
+        if hunk.preamble not in seen_preamble:
+            out.append(hunk.preamble)
+            seen_preamble.add(hunk.preamble)
+        out.append(hunk.body)
+    return "".join(out)
+
+
+# ---------------------------------------------------------------------------
+# Chapter / Saga model
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Chapter:
+    """One ordered chapter of a saga.
+
+    ``hunks`` lists the hunk ids this chapter covers. ``deviation`` is set (to the
+    agent's explanation) only when the implementation diverged from the stated
+    intent; ``qa`` carries an optional ``{"status": …, "note": str}`` receipt.
+    Both are ``None`` when no intent context was supplied.
+    """
+
+    id: str
+    title: str
+    summary: str
+    narration: str
+    hunks: list[str] = field(default_factory=list)
+    plan_step: str | None = None
+    confidence: str = "medium"
+    deviation: str | None = None
+    qa: dict | None = None
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Chapter:
+        confidence = d.get("confidence", "medium")
+        if confidence not in CONFIDENCE_LEVELS:
+            confidence = "medium"
+        return cls(
+            id=d["id"],
+            title=d.get("title", ""),
+            summary=d.get("summary", ""),
+            narration=d.get("narration", ""),
+            hunks=list(d.get("hunks", [])),
+            plan_step=d.get("plan_step"),
+            confidence=confidence,
+            deviation=d.get("deviation") or None,
+            qa=d.get("qa"),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "summary": self.summary,
+            "narration": self.narration,
+            "hunks": self.hunks,
+            "plan_step": self.plan_step,
+            "confidence": self.confidence,
+            "deviation": self.deviation,
+            "qa": self.qa,
+        }
+
+
+@dataclass
+class Saga:
+    """A change set's saga: ordered chapters + diff context."""
+
+    branch: str
+    base: str
+    commit_sha: str
+    generated_at: str = ""
+    chapters: list[Chapter] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Saga:
+        return cls(
+            branch=d.get("branch", ""),
+            base=d.get("base", ""),
+            commit_sha=d.get("commit_sha", ""),
+            generated_at=d.get("generated_at", ""),
+            chapters=[Chapter.from_dict(c) for c in d.get("chapters", [])],
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "branch": self.branch,
+            "base": self.base,
+            "commit_sha": self.commit_sha,
+            "generated_at": self.generated_at,
+            "chapters": [c.to_dict() for c in self.chapters],
+        }
+
+    def verdict(self, *, qa_state: str) -> dict:
+        """The top-line summary rendered above the table of contents.
+
+        Computed here (not trusted from the LLM) so the counts always match the
+        chapters actually present.
+        """
+        return {
+            "chapters": len(self.chapters),
+            "deviations": sum(1 for c in self.chapters if c.deviation),
+            "low_confidence": sum(1 for c in self.chapters if c.confidence == "low"),
+            "qa": qa_state,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+
+
+def validate_coverage(chapters: list[Chapter], hunks: list[Hunk]) -> None:
+    """Enforce the hard invariant: every hunk belongs to at least one chapter.
+
+    Raises ``SagaError`` if any chapter references an unknown hunk id or
+    if any hunk is left unassigned. Chapters overlapping (a hunk in two chapters)
+    is allowed — coverage, not partition, is the contract.
+    """
+    if not chapters:
+        raise SagaError("Saga has no chapters.")
+
+    all_ids = {h.id for h in hunks}
+    referenced: set[str] = set()
+    for ch in chapters:
+        for hid in ch.hunks:
+            referenced.add(hid)
+
+    unknown = referenced - all_ids
+    if unknown:
+        raise SagaError(
+            f"Chapters reference unknown hunks: {', '.join(sorted(unknown))}."
+        )
+
+    unassigned = all_ids - referenced
+    if unassigned:
+        raise SagaError(
+            f"{len(unassigned)} hunk(s) not assigned to any chapter: "
+            f"{', '.join(sorted(unassigned))}."
+        )

saga/prompts/saga.md

@@ -0,0 +1,50 @@
+You are giving a reviewer a guided tour of a code change — a chapter-by-chapter walkthrough that makes a large diff easy to review without losing focus.
+
+You are handed:
+
+1. **The full diff**, split into labeled hunks. Every hunk has a stable id like `h0`, `h1`, … shown as `### HUNK h3 — path/to/file (new lines 40-55)`.
+2. **The commit messages** on this change, for context on intent and sequencing.
+3. **Optional intent** — a plan, spec, or description of what the change set out to do. This may be absent; if so, infer intent from the diff and commits.
+
+Your job: partition the diff into an **ordered list of chapters** that tell one coherent story, and explain each in your own voice.
+
+## Rules
+
+- **Cover every hunk.** Every hunk id must appear in at least one chapter. This is mandatory — the walkthrough is rejected if any hunk is left out. A hunk may appear in more than one chapter only if it genuinely belongs to both.
+- **Order matters.** Sequence chapters so a reviewer who reads top-to-bottom builds understanding naturally — usually setup/foundation first, then the core change, then wiring and tests.
+- **Group by idea, not by file.** A chapter can interleave hunks from several files when they serve one idea.
+- **Zoom out when it helps.** If a chapter is about how the change fits the wider codebase, say so in the narration.
+- **Zoom in on the hard parts.** For complex or non-obvious changes, explain why it was needed and why it was done this way rather than an alternative.
+
+## What each chapter needs
+
+- `title` — a short, concrete title.
+- `summary` — one line for the table of contents (≤ 12 words).
+- `narration` — **2–4 short sentences, plain language.** The intent, the key decision, and the rationale. The reviewer does not want a wall of text — be brief and concrete. Markdown is allowed but keep it light.
+- `hunks` — the list of hunk ids in this chapter, in reading order.
+- `plan_step` — when an intent document was supplied, the step/section this chapter maps to (e.g. `"PR 1: …"`); otherwise `null`.
+- `confidence` — `"high"`, `"medium"`, or `"low"`. Use `"low"` honestly for anything that deserves close review.
+- `deviation` — `null` unless an intent was supplied _and_ the implementation diverged from it; then a short sentence explaining how and why. Be honest — deviations are highlighted for the reviewer.
+- `qa` — `null`, or `{"status": "green", "note": "…"}` when tests cover this chapter's changes, or `{"status": "none", "note": "…"}` to flag a chapter with no test coverage worth noting.
+
+## Output
+
+Return **only** a single JSON object, no prose before or after, no code fences:
+
+```
+{
+  "chapters": [
+    {
+      "id": "ch1",
+      "title": "…",
+      "summary": "…",
+      "narration": "…",
+      "hunks": ["h0", "h1"],
+      "plan_step": null,
+      "confidence": "high",
+      "deviation": null,
+      "qa": {"status": "green", "note": "Covered by existing tests."}
+    }
+  ]
+}
+```

saga/render.py

@@ -0,0 +1,144 @@
+"""Render a ``Saga`` into one self-contained static HTML file.
+
+Everything is inlined — the design tokens, diff2html's CSS/JS (which bundles
+highlight.js), marked, our saga JS, and the saga data itself — so
+the output is a single file that opens offline and can be emailed, committed, or
+dropped on any static host. The vendored CDN bundles are fetched once and cached
+under ``.assets-cache/`` next to the package.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from urllib.request import urlopen
+
+from .diff import compute_diff
+from .model import Saga, parse_hunks, reconstruct_diff
+
+_ASSETS = Path(__file__).resolve().parent / "assets"
+
+
+def _cache_dir() -> Path:
+    """User-level cache for the vendored CDN bundles.
+
+    Uses ``$XDG_CACHE_HOME`` when set, else ``~/.cache`` — never the install dir,
+    which may be read-only under site-packages.
+    """
+    base = os.environ.get("XDG_CACHE_HOME") or (Path.home() / ".cache")
+    return Path(base) / "saga"
+
+
+_CACHE = _cache_dir()
+
+_CDN = {
+    "diff2html.min.css": "https://cdn.jsdelivr.net/npm/diff2html/bundles/css/diff2html.min.css",
+    "diff2html-ui.min.js": "https://cdn.jsdelivr.net/npm/diff2html/bundles/js/diff2html-ui.min.js",
+    "marked.min.js": "https://cdn.jsdelivr.net/npm/marked/marked.min.js",
+}
+
+
+def _vendored(name: str) -> str:
+    """Return a cached CDN bundle, downloading it once on first use."""
+    cached = _CACHE / name
+    if not cached.exists():
+        _CACHE.mkdir(parents=True, exist_ok=True)
+        cached.write_bytes(urlopen(_CDN[name]).read())  # noqa: S310
+    return cached.read_text()
+
+
+def _asset(name: str) -> str:
+    return (_ASSETS / name).read_text()
+
+
+def build_payload(repo_root: Path, saga: Saga, *, qa_state: str = "n/a") -> dict:
+    """Attach each chapter's reconstructed diff to the saga for the client.
+
+    The hunk map is recomputed from the live diff of the saga's own
+    base...head, so every stored hunk id resolves to its current diff text.
+    """
+    diff = compute_diff(repo_root, saga.base, saga.branch)
+    hmap = {h.id: h for h in parse_hunks(diff.diff_text)}
+    chapters = []
+    for ch in saga.chapters:
+        d = ch.to_dict()
+        d["diff"] = reconstruct_diff([hmap[h] for h in ch.hunks if h in hmap])
+        chapters.append(d)
+    return {
+        "branch": saga.branch,
+        "base": saga.base,
+        "verdict": saga.verdict(qa_state=qa_state),
+        "chapters": chapters,
+    }
+
+
+def _json_for_script(payload: dict) -> str:
+    """JSON-encode *payload* safe to inline in a ``<script>`` tag.
+
+    Escaping ``<`` to ``\\u003c`` means diff content containing ``</script>`` or
+    ``<!--`` cannot break out of the tag.
+    """
+    return json.dumps(payload, ensure_ascii=False).replace("<", "\\u003c")
+
+
+def render(repo_root: Path, saga: Saga, *, qa_state: str = "n/a") -> str:
+    """Build the complete self-contained HTML document for *saga*."""
+    payload = build_payload(repo_root, saga, qa_state=qa_state)
+    title = f"Saga · {saga.branch}"
+    styles = "\n".join(
+        [
+            _asset("tokens.css"),
+            _vendored("diff2html.min.css"),
+            _asset("base.css"),
+            _asset("saga.css"),
+        ]
+    )
+    scripts = "\n".join(
+        [
+            _vendored("diff2html-ui.min.js"),
+            _vendored("marked.min.js"),
+            f"window.__sagaData = {_json_for_script(payload)};",
+            _asset("saga.js"),
+        ]
+    )
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{title}</title>
+<script>
+// Apply the saved theme before first paint so there is no flash.
+try {{
+  var t = localStorage.getItem('saga-theme');
+  if (t === 'light' || t === 'dark') {{
+    document.documentElement.setAttribute('data-theme', t);
+  }}
+}} catch (e) {{}}
+</script>
+<style>
+{styles}
+</style>
+</head>
+<body>
+<div class="saga-rail" id="saga-rail"></div>
+<div class="header">
+  <button id="saga-theme" class="saga-theme-toggle" type="button"
+          aria-label="Toggle light or dark theme" title="Toggle theme"></button>
+  <nav class="saga-crumbs">
+    <span class="saga-crumb-current">Saga</span>
+    <span class="saga-crumb-sep">&rsaquo;</span>
+    <span class="mono">{saga.base}...{saga.branch}</span>
+  </nav>
+  <h1>Saga</h1>
+  <div id="saga-verdict" class="saga-verdict"></div>
+</div>
+<div id="saga-notice"></div>
+<div id="saga-toc" class="saga-toc"></div>
+<div id="saga-reader" class="saga-reader" hidden></div>
+<script>
+{scripts}
+</script>
+</body>
+</html>"""

saga_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: saga-cli
+Version: 0.1.0
+Summary: Generate a self-contained static HTML saga of a git diff — a chapter-by-chapter guided tour of a change.
+Project-URL: Homepage, https://github.com/JakeBeresford/saga
+Project-URL: Repository, https://github.com/JakeBeresford/saga
+Project-URL: Issues, https://github.com/JakeBeresford/saga/issues
+Author: Jake Beresford
+License-Expression: MIT
+License-File: LICENSE
+Keywords: code-review,diff,documentation,git,html,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Requires-Dist: anthropic
+Requires-Dist: instructor
+Requires-Dist: openai
+Requires-Dist: typer>=0.26.8
+Description-Content-Type: text/markdown
+
+# Saga
+
+Generate a **chapter-by-chapter guided tour** of a code change as a single,
+self-contained static HTML page, a _saga_ of your diff. It partitions a diff into
+ordered chapters that tell one coherent story, each with a plain-language narration
+and just the hunks that belong to it. Large PRs become easy to review without
+losing the thread.
+
+The output is one HTML file with everything inlined (diff2html, syntax highlighting,
+the data). Open it offline, email it, commit it, or drop it on any static host.
+
+[**See an example saga**](https://jakeberesford.github.io/saga/example.html).
+
+## Requirements
+
+- Python 3.11+
+- `git`
+- An API key for your chosen provider, in the standard environment variable:
+  `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or `OPENROUTER_API_KEY`
+
+Generation is one structured LLM call made through [`instructor`](https://python.useinstructor.com).
+
+## Install
+
+Install once and the `saga` command is available from any repo:
+
+```sh
+uv tool install saga-cli     # recommended
+# or
+pipx install saga-cli
+# or, into the current environment
+pip install saga-cli
+```
+
+Installing from a local checkout instead? Point the installer at this directory,
+e.g. `uv tool install /path/to/saga`. To upgrade: `uv tool install --force saga-cli`.
+
+## Usage
+
+From inside the repo you want to review:
+
+```sh
+saga --base main --head my-feature -o saga.html --open
+```
+
+Run it from anywhere with `--repo`:
+
+```sh
+saga --repo ~/src/some-project --base main --head my-feature -o out.html
+```
+
+| Flag                   | Default                     | Meaning                                                                                            |
+| ---------------------- | --------------------------- | -------------------------------------------------------------------------------------------------- |
+| `--base`               | `main`                      | Base ref to diff against                                                                           |
+| `--head`               | current branch              | Head ref to walk through                                                                           |
+| `--intent PATH`        | —                           | Optional plan/spec describing the change's intent, for plan-aware narration and deviation flagging |
+| `--model`              | `anthropic/claude-opus-4-8` | `provider/model` string (see [Providers](#providers)); also `$SAGA_MODEL`                          |
+| `-o, --output`         | `saga.html`                 | Output file                                                                                        |
+| `--repo`               | cwd                         | A path inside the target git repo                                                                  |
+| `--open` / `--no-open` | on                          | Open the result in a browser (on by default; `--no-open` to disable)                               |
+
+## Providers
+
+The model is a single `provider/model` string, dispatched through `instructor`.
+Choose it with `--model` or the `SAGA_MODEL` environment variable, and set
+the matching API key:
+
+| Provider   | `--model` example                        | API key env var      |
+| ---------- | ---------------------------------------- | -------------------- |
+| Anthropic  | `anthropic/claude-opus-4-8`              | `ANTHROPIC_API_KEY`  |
+| OpenAI     | `openai/gpt-4o`                          | `OPENAI_API_KEY`     |
+| OpenRouter | `openrouter/anthropic/claude-3.5-sonnet` | `OPENROUTER_API_KEY` |
+
+```sh
+export SAGA_MODEL=openai/gpt-4o
+export OPENAI_API_KEY=sk-…
+saga --base main --head my-feature -o saga.html
+```
+
+## As a Claude Code skill
+
+The `skills/` directory contains two Claude Code skills. To install both:
+
+```sh
+cp -R "$(pwd)/skills" ~/.claude/skills/saga
+```
+
+- **`saga`** — say **"/saga"** (or "give me a walkthrough of this branch") to generate a
+  saga. It resolves the base/head refs and runs the tool for you.
+- **`saga-comments`** — say **"/saga-comments"** (or "address the saga comments") to read an
+  exported `saga.comments.json` and act on the reviewer's feedback in code.
+
+## Reviewing: comments
+
+The saga page is also a lightweight review surface. Open `saga.html` and leave three
+kinds of comments — **inline** (click a line's number in any chapter's diff), **per-file**
+(the "💬 File comment" control in each file header), and one **overall** review comment
+(the box at the top of the Chapters list). Comments are drafted in your browser's
+`localStorage`, so they survive a reload.
+
+When you're done, click **Export comments** to download a `saga.comments.json` sidecar next
+to the HTML. (Export is disabled in the [hosted example](https://jakeberesford.github.io/saga/example.html)
+so it never writes a file — every other part of the review UX works.) Two commands consume it:
+
+```sh
+# Post everything as a single PENDING review on the PR (you submit it on GitHub).
+saga comments push --comments saga.comments.json
+
+# Emit the comments as JSON on stdout — for a coding agent to act on.
+saga comments read --comments saga.comments.json
+```
+
+`push` uses the `gh` CLI: it finds the open PR for the sidecar's branch and creates one
+pending review (inline → line comments, per-file → a note anchored to the file's first
+changed line, overall → the review body). Nothing is submitted until you review and submit
+it on GitHub. Requires the [`gh`](https://cli.github.com) CLI, authenticated.
+
+## How it works
+
+1. `diff.py` computes `git diff base...head` (no checkout) and the commit list.
+2. `model.py` splits the diff into stable-id hunks (`h0, h1, …`).
+3. `generate.py` sends the labeled diff + commits (+ optional intent) to the chosen
+   model via `instructor`, which returns chapters as schema-validated JSON. Coverage
+   is **re-validated in code** — every hunk must belong to a chapter or generation fails.
+4. `render.py` reconstructs each chapter's diff and inlines everything into one
+   self-contained HTML file.
+
+## Not included (yet)
+
+- Support for Local LLMs via ollama / LM Studio
+- A GitHub Action to auto-generate saga on PRs.

saga_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+saga/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saga/__main__.py,sha256=Qd-f8z2Q2vpiEP2x6PBFsJrpACWDVxFKQk820MhFmHo,59
+saga/cli.py,sha256=ICexToy2Tl-Ja4-Jc9mTQz-R5YwLP1PUyDmbyF2Xpnc,3328
+saga/comments.py,sha256=FrsUpyYTB8lkO0RiXq-0_TPdb1NI_FpJeylG3jqkrk0,8924
+saga/diff.py,sha256=FG0fo_394cQerfEgah45qj1Xvbd83ekfMVDRAS-0cEc,2508
+saga/generate.py,sha256=KvNRbCoIfp8WbLmFlAWNbGZ5T9worFSFmgRv_rwXxQU,5714
+saga/model.py,sha256=tyF-dwIWsPiTVwXbEMggHdrpDX9ViiPqgcPi2_q8sek,8784
+saga/render.py,sha256=NLG-wVp2VmgHnK5KHgSfss4XWupdrwckdwrAZx_pluA,4588
+saga/assets/base.css,sha256=Yv8XCzevdQwRKpivTXcB8SxD6WKP2Iyhd9SqgHyICUE,2453
+saga/assets/saga.css,sha256=XWSsrhjVejY0yXKF2qBDNGbhiKEhD1iXnTn4Klnzfno,9482
+saga/assets/saga.js,sha256=4CLnx7D6Dyqe4penPch5ccdIul4xf5W5bM6Bz7yXSGU,17658
+saga/assets/tokens.css,sha256=H34kFxqonmbAnd4ibyUQj2ECfd1Xdu6JbTugwDej8Zw,5978
+saga/prompts/saga.md,sha256=tzFW4DI0kAaESWgrTvXqyg7DbRTBZq7Ljb0dqsjN7eg,2982
+saga_cli-0.1.0.dist-info/METADATA,sha256=eVOOlEh18K4uo08tufmwvbFeTunQ1i4wbC7EJB89-LI,7211
+saga_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+saga_cli-0.1.0.dist-info/entry_points.txt,sha256=THvRLIVVZE2hhRHNRbrv7pdZ64afQfO_jYhR7bkkavY,38
+saga_cli-0.1.0.dist-info/licenses/LICENSE,sha256=pARUeoUO0rxQdvv3Xz-VYrogjxss-G7JU3epAQn27AQ,1071
+saga_cli-0.1.0.dist-info/RECORD,,

saga_cli-0.1.0.dist-info/WHEEL

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

saga_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+saga = saga.cli:app

saga_cli-0.1.0.dist-info/licenses/LICENSE

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