tony-cli 0.4.2__tar.gz → 0.6.0__tar.gz

{tony_cli-0.4.2 → tony_cli-0.6.0}/LICENSE

@@ -12,8 +12,8 @@ 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 ABC Favorit and ABC Favorit Mono font files under src/tony_cli/assets/fonts
-are commercial typefaces by Dinamo and are NOT covered by this license.
+The ABC Favorit and ABC Favorit Mono font files under web/public/fonts are
+commercial typefaces by Dinamo and are NOT covered by this license.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

{tony_cli-0.4.2/src/tony_cli.egg-info → tony_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tony-cli
-Version: 0.4.2
+Version: 0.6.0
 Summary: Explains a git diff to whoever now owns it — annotated changes, blast radius, and steppable runtime walkthroughs.
 Author: Fawwaz Abayomi
 License: MIT License
@@ -17,8 +17,8 @@ License: MIT License
         The above copyright notice and this permission notice shall be included in all
         copies or substantial portions of the Software.
         
-        The ABC Favorit and ABC Favorit Mono font files under src/tony_cli/assets/fonts
-        are commercial typefaces by Dinamo and are NOT covered by this license.
+        The ABC Favorit and ABC Favorit Mono font files under web/public/fonts are
+        commercial typefaces by Dinamo and are NOT covered by this license.
         
         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
@@ -44,10 +44,9 @@ Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: anthropic>=0.40
-Requires-Dist: python-dotenv>=1.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: cryptography>=42
+Requires-Dist: mcp>=1.9
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Dynamic: license-file
@@ -56,9 +55,14 @@ Dynamic: license-file
 
 **Your AI wrote the code. tony explains what now exists.**
 
-tony is a CLI that turns a git diff into a review page for the person who now
-owns the code — often someone who didn't type a line of it. Not a linter, not a
-code-review gate: it builds your mental model of the change, fast.
+tony turns a git diff into a review page for the person who now owns the code —
+often someone who didn't type a line of it. Not a linter, not a code-review
+gate: it builds your mental model of the change, fast.
+
+tony does not call a model. It runs inside the coding agent you already pay for:
+you ask the agent to review a branch, it calls tony over MCP, tony hands it the
+diff and the standard the review has to meet, checks the answer against the
+diff, and publishes the page.
 
 Every review page has three tabs:
 
@@ -87,63 +91,46 @@ uv tool install tony-cli     # or: pipx install tony-cli
 
 Either way you get a `tony` command on your PATH.
 
-## Use
+## Set up
+
+Two commands, once per machine:
 
 ```sh
-cd your-repo
-tony main...my-branch        # review a branch against main
-tony                         # review the default branch...HEAD
+tony connect                 # register tony with Claude Code, Codex, Cursor, Amp
+tony login                   # sign in, so reviews have somewhere to publish
 ```
 
-Reviews stay on your machine. The page is written to `.tony/` inside the repo
-(gitignored automatically) and opens in your browser — one self-contained HTML
-file, fonts and styles and data inlined, so it works offline and forever.
-Nothing is uploaded; the only thing that leaves your machine is the diff tony
-sends to Anthropic to write the review.
-
-tony needs an Anthropic API key (`ANTHROPIC_API_KEY`, or `~/.tony/.env`). The
-first run tells you exactly where to get one and where to put it. tony reviews
-**committed** work: it shows code straight from disk, so the working tree must
-match the revision under review.
-
-Every command and flag is listed under [Commands](#commands).
+Then restart your agent and ask it, in words:
 
-## Commands
-
-`tony --help` prints this list. Everything below works from anywhere inside a
-git repo unless noted.
+> review this branch with tony
 
-### Reviewing
+The agent calls `tony_start`, reads the diff and whatever files it needs,
+writes the review, and calls `tony_publish`. What comes back is a URL. Reviews
+are published to your account; the page is the deliverable, so the agent hands
+you the link rather than pasting the review into the chat.
 
-```sh
-tony                          # default branch...HEAD, in the current repo
-tony main...my-branch         # an explicit range
-tony my-branch                # shorthand for my-branch...HEAD
-tony ../other-repo main...x   # any path inside another repo
-```
+tony reviews **committed** work: the page shows code straight from disk, so the
+working tree has to match the revision under review.
 
-The range is git's own `BASE...HEAD` syntax. With no range, tony diffs against
-`origin/HEAD` — what the remote calls its default branch — falling back to
-`main`, then `master`.
-
-| Flag | What it does |
-|---|---|
-| `--json` | Print the raw review JSON to stdout and exit. Writes no page instead. |
-| `--no-open` | Write the page but don't open a browser. For CI, or over SSH. |
-| `--stale` | Review a revision that isn't checked out, or with a dirty tree. Code is read from disk, so line numbers may not match the diff — tony refuses by default for that reason. |
-| `--replay` | Rebuild the page from the last saved review for this range, without calling the API. Free; use it after a tony upgrade to re-render an old review. |
-| `-v`, `--verbose` | Log every tool call to stderr, so you can see which files the review actually read before it drew conclusions. |
-| `-m`, `--model` | Model to review with. Defaults to `claude-opus-5`. |
-| `--max-tokens` | Response ceiling, default `64000`. Raise it if a review comes back cut off. |
+## Commands
 
-### Managing tony
+`tony --help` prints this list.
 
 | Command | What it does |
 |---|---|
+| `tony connect [host ...]` | Write the MCP config for Claude Code, Codex, Cursor, or Amp. Named hosts only, or all four it finds. |
+| `tony login` / `tony logout` | Your account on the tony site. Publishing needs it; nothing else does. |
+| `tony mcp` | Run the MCP server on stdio. Your agent runs this, not you. |
 | `tony update` | Upgrade to the latest release, using whichever of uv, pipx or pip installed tony. Checks PyPI first and tells you if you're already current. |
+
+Every command asks PyPI whether there is a newer release and says so on the way
+out; the request runs alongside the command, so nothing waits on it, and a
+review started through the MCP server tells the agent instead of a terminal
+nobody is watching. It never installs anything by itself.
+
 | `tony uninstall` | Delete tony and everything it wrote — see [Uninstall](#uninstall). |
 | `tony --version` | The installed version. |
-| `tony --help` | Every command and flag. |
+| `tony --help` | This list. |
 
 `tony uninstall` takes `--yes` (`-y`) to skip the confirmation and `--no-scan` to
 limit it to the current repo instead of searching your home directory.
@@ -157,11 +144,12 @@ pointed at an internal mirror can't decide what `tony-cli` is.
 tony uninstall
 ```
 
-Removing the package by itself would leave the parts worth removing: your
-`ANTHROPIC_API_KEY` in `~/.tony`, and a `.tony/` directory of past reviews
-inside every repository you ran tony in — those hold source code. `tony
-uninstall` lists everything it found, waits for you to type `yes`, deletes it,
-then removes the package with whichever of uv, pipx, or pip installed it.
+Removing the package by itself would leave the parts worth removing: your login
+token in `~/.tony`, and — from versions before tony went agent-native — an API
+key beside it and a `.tony/` directory of past reviews inside every repository
+you ran tony in, which hold source code. `tony uninstall` lists everything it
+found, waits for you to type `yes`, deletes it, then removes the package with
+whichever of uv, pipx, or pip installed it.
 
 It searches your home directory for stray review directories; `--no-scan`
 limits it to the current repository, and `--yes` skips the prompt.
@@ -172,22 +160,13 @@ limits it to the current repository, and `--yes` skips the prompt.
 pip install -e ".[dev]"      # the CLI, with pytest
 python -m pytest             # the deterministic layer's tests
 cd web && npm install
-npm run build:viewer         # rebuild the renderer bundle the CLI embeds
 npm run dev                  # the site; /dev renders src/fixtures/review.json
 ```
 
-Two flags exist only for this loop, and only work from a source checkout:
-
-| Flag | What it does |
-|---|---|
-| `--viewer` | Write the payload straight into the local Astro viewer and reload it there, so you can iterate on the renderer against a real review. |
-| `--payload [PATH]` | Write the upload payload — windowed source, no absolute paths — next to the page, or to `PATH`. |
-
-There is exactly one renderer — `web/src/renderer/render.ts` — used by both
-the local page and the hosted site. The Python side decides all layout facts
-(line numbers, spans, added/changed tags) in `src/tony_cli/layout.py` and ships
-them in the payload; the renderer never re-derives them. `DESIGN.md` is the
-visual contract.
+The renderer is `web/src/renderer/render.ts`, and the site is the only thing
+that runs it. The Python side decides all layout facts (line numbers, spans,
+added/changed tags) in `src/tony_cli/layout.py` and ships them in the payload;
+the renderer never re-derives them. `DESIGN.md` is the visual contract.
 
 The site deploys to Vercel and needs `DATABASE_URL` (Neon Postgres),
 `BLOB_READ_WRITE_TOKEN` (Vercel Blob), and `GITHUB_CLIENT_ID` (an OAuth app

tony_cli-0.6.0/README.md

@@ -0,0 +1,120 @@
+# tony
+
+**Your AI wrote the code. tony explains what now exists.**
+
+tony turns a git diff into a review page for the person who now owns the code —
+often someone who didn't type a line of it. Not a linter, not a code-review
+gate: it builds your mental model of the change, fast.
+
+tony does not call a model. It runs inside the coding agent you already pay for:
+you ask the agent to review a branch, it calls tony over MCP, tony hands it the
+diff and the standard the review has to meet, checks the answer against the
+diff, and publishes the page.
+
+Every review page has three tabs:
+
+1. **File changes** — the diff per file, with plain-language annotations sitting
+   inline above the lines they explain. Modified code gets Prev / New / Changes
+   panes; line numbers are computed from the diff, never trusted to the model.
+2. **Blast radius** — files the change reaches that are *not* in the diff, each
+   consumer classified breaks / behavior-change / compatible, shown at the
+   affected lines.
+3. **How it works** — steppable runtime walkthroughs. One concrete scenario
+   ("you run `export --resume` after a crash") traced step by step, showing the
+   real source lines read from your disk, a small state table, and one plain
+   sentence per step.
+
+## Install
+
+```sh
+curl -fsSL https://tony-cli.com/install.sh | sh
+```
+
+or, if you already use uv or pipx:
+
+```sh
+uv tool install tony-cli     # or: pipx install tony-cli
+```
+
+Either way you get a `tony` command on your PATH.
+
+## Set up
+
+Two commands, once per machine:
+
+```sh
+tony connect                 # register tony with Claude Code, Codex, Cursor, Amp
+tony login                   # sign in, so reviews have somewhere to publish
+```
+
+Then restart your agent and ask it, in words:
+
+> review this branch with tony
+
+The agent calls `tony_start`, reads the diff and whatever files it needs,
+writes the review, and calls `tony_publish`. What comes back is a URL. Reviews
+are published to your account; the page is the deliverable, so the agent hands
+you the link rather than pasting the review into the chat.
+
+tony reviews **committed** work: the page shows code straight from disk, so the
+working tree has to match the revision under review.
+
+## Commands
+
+`tony --help` prints this list.
+
+| Command | What it does |
+|---|---|
+| `tony connect [host ...]` | Write the MCP config for Claude Code, Codex, Cursor, or Amp. Named hosts only, or all four it finds. |
+| `tony login` / `tony logout` | Your account on the tony site. Publishing needs it; nothing else does. |
+| `tony mcp` | Run the MCP server on stdio. Your agent runs this, not you. |
+| `tony update` | Upgrade to the latest release, using whichever of uv, pipx or pip installed tony. Checks PyPI first and tells you if you're already current. |
+
+Every command asks PyPI whether there is a newer release and says so on the way
+out; the request runs alongside the command, so nothing waits on it, and a
+review started through the MCP server tells the agent instead of a terminal
+nobody is watching. It never installs anything by itself.
+
+| `tony uninstall` | Delete tony and everything it wrote — see [Uninstall](#uninstall). |
+| `tony --version` | The installed version. |
+| `tony --help` | This list. |
+
+`tony uninstall` takes `--yes` (`-y`) to skip the confirmation and `--no-scan` to
+limit it to the current repo instead of searching your home directory.
+
+Both `tony update` and the installer resolve from PyPI explicitly, so a machine
+pointed at an internal mirror can't decide what `tony-cli` is.
+
+## Uninstall
+
+```sh
+tony uninstall
+```
+
+Removing the package by itself would leave the parts worth removing: your login
+token in `~/.tony`, and — from versions before tony went agent-native — an API
+key beside it and a `.tony/` directory of past reviews inside every repository
+you ran tony in, which hold source code. `tony uninstall` lists everything it
+found, waits for you to type `yes`, deletes it, then removes the package with
+whichever of uv, pipx, or pip installed it.
+
+It searches your home directory for stray review directories; `--no-scan`
+limits it to the current repository, and `--yes` skips the prompt.
+
+## Development
+
+```sh
+pip install -e ".[dev]"      # the CLI, with pytest
+python -m pytest             # the deterministic layer's tests
+cd web && npm install
+npm run dev                  # the site; /dev renders src/fixtures/review.json
+```
+
+The renderer is `web/src/renderer/render.ts`, and the site is the only thing
+that runs it. The Python side decides all layout facts (line numbers, spans,
+added/changed tags) in `src/tony_cli/layout.py` and ships them in the payload;
+the renderer never re-derives them. `DESIGN.md` is the visual contract.
+
+The site deploys to Vercel and needs `DATABASE_URL` (Neon Postgres),
+`BLOB_READ_WRITE_TOKEN` (Vercel Blob), and `GITHUB_CLIENT_ID` (an OAuth app
+with device flow enabled).

{tony_cli-0.4.2 → tony_cli-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tony-cli"
-version = "0.4.2"
+version = "0.6.0"
 description = "Explains a git diff to whoever now owns it — annotated changes, blast radius, and steppable runtime walkthroughs."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -20,10 +20,9 @@ classifiers = [
     "Topic :: Software Development :: Version Control :: Git",
 ]
 dependencies = [
-    "anthropic>=0.40",
-    "python-dotenv>=1.0",
     "httpx>=0.27",
     "cryptography>=42",
+    "mcp>=1.9",
 ]
 
 [project.optional-dependencies]
@@ -44,8 +43,5 @@ build-backend = "setuptools.build_meta"
 where = ["src"]
 include = ["tony_cli*"]
 
-[tool.setuptools.package-data]
-tony_cli = ["assets/fonts/*.woff2", "assets/viewer.js", "assets/viewer.css"]
-
 [tool.pytest.ini_options]
 testpaths = ["src/tests"]

tony_cli-0.6.0/src/tony_cli/agent.py

@@ -0,0 +1,108 @@
+"""The `tony` command.
+
+tony does not review anything itself. The reviewing happens inside whatever
+coding agent the developer already pays for, over the MCP server in
+`mcp_server.py` — the agent reads the diff, writes the review, and hands it
+back to be validated and published. So this module is a dispatcher: accounts,
+agent wiring, and the installer. Everything a person types.
+
+The old path — tony owning an Anthropic key and driving its own tool loop —
+is gone. See `mcp_server.py` for what replaced it.
+"""
+
+import sys
+
+from tony_cli import hosted, install
+
+USAGE = """\
+tony — explains a git diff to whoever now owns it.
+
+  tony connect [host ...]        connect tony to your coding agent
+  tony login                     sign in, so reviews have somewhere to publish
+  tony logout                    sign out on this machine
+  tony mcp                       run the MCP server on stdio (agents call this)
+  tony update                    update to the latest release
+  tony uninstall                 delete tony, its login, and every saved review
+  tony --version                 what is installed
+
+To review something, ask your agent: "review this branch with tony".
+
+  https://tony-cli.com
+"""
+
+
+# Commands that must not carry the notice. `update` and `uninstall` are about
+# the installed version already and would be talking over themselves; `mcp`
+# speaks a protocol on stdio and has no terminal to say anything to — it tells
+# the agent instead, in `mcp_server.startReview`.
+NO_NOTICE = ("update", "uninstall", "mcp")
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    command = argv[0] if argv else None
+
+    # Started before the command, collected after it: the round trip to PyPI
+    # overlaps whatever the command was going to do anyway, so the only run
+    # that ever waits on it is one that finishes in under half a second.
+    check = None if command in NO_NOTICE else install.startUpdateCheck()
+    code = dispatch(argv, command)
+    if check:
+        notice = install.updateNotice(check)
+        if notice:
+            # stderr, so it never lands in the middle of output being piped
+            # somewhere that expected only the command's own.
+            print(notice, file=sys.stderr)
+    return code
+
+
+def dispatch(argv, command):
+    """Run one command and return its exit code. Everything a person types."""
+    if command in (None, "help", "-h", "--help"):
+        # No arguments is not an error: it is someone who just installed tony
+        # and wants to know what to type next. That is `tony connect`.
+        print(USAGE)
+        return 0
+
+    if command in ("--version", "-V", "version"):
+        print(f"tony {install.installedVersion() or 'unknown'}")
+        return 0
+
+    if command == "login":
+        return hosted.login(argv[1:])
+    if command == "logout":
+        return hosted.logout()
+
+    # Imported here, not at the top: it pulls in the MCP SDK, and `tony` as a
+    # CLI should not pay that import on every run to serve one subcommand.
+    if command == "mcp":
+        from tony_cli.mcp_server import serve
+        return serve(argv[1:])
+    if command == "connect":
+        from tony_cli import mcp_config
+        return mcp_config.connect(argv[1:])
+
+    # The obvious wrong guess, and one worth answering.
+    if command == "install":
+        print("tony: tony is already installed — you want `tony connect`, which\n"
+              "      registers it with your coding agent.", file=sys.stderr)
+        return 2
+    if command == "update":
+        return install.update(argv[1:])
+    if command == "uninstall":
+        from tony_cli.uninstall import uninstall
+        return uninstall(argv[1:])
+
+    # A range or a repository path — what tony used to take directly. Someone
+    # typing it has an older tony's habits, so say where the reviewing went.
+    print(
+        f"tony: unknown command {command!r}.\n\n"
+        "  tony no longer reviews on its own. Run `tony connect` once, then ask\n"
+        "  your coding agent to review the branch and it will call tony for you.\n",
+        file=sys.stderr,
+    )
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())