lastorders 0.4.0__py3-none-any.whl

lastorders-0.4.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: lastorders
+Version: 0.4.0
+Summary: Free scanner for retiring AI model IDs (OpenAI, Anthropic, ...) in your code, with CI support.
+Author: Burnt & Toast Studios
+Project-URL: Homepage, https://burntandtoast.com
+Keywords: openai,anthropic,llm,deprecation,migration,gpt-4o,scanner,github-action
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6
+Requires-Dist: jsonschema>=4
+Requires-Dist: libcst>=1.1
+Requires-Dist: cryptography>=41
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+
+# Last Orders (working name)
+
+**Find retiring AI model IDs in your code before they break.** One command scans your repo for OpenAI
+(and, as a preview, Anthropic) model IDs that are being shut down. For each one it tells you the
+shutdown date, the replacement the provider recommends, and the code changes the new model needs.
+
+> **Heads-up:** OpenAI removes **GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini** from the API on
+> **14 January 2027** and recommends `gpt-6-luna`. In our tests, `gpt-6-luna` rejects `max_tokens`, and it
+> rejects tool calls on Chat Completions unless `reasoning_effort` is `"none"`. So changing the model name
+> isn't enough. The scan flags both.
+
+The scan is free. You don't need an account, a licence or an API key, and your code never leaves your machine.
+
+## Install
+
+```bash
+pipx install lastorders        # or: pip install lastorders
+```
+
+You need Python 3.10 or later.
+
+## Scan
+
+```bash
+lastorders scan .              # scan the current repo
+lastorders scan path/to/repo --out scan-results
+lastorders scan . --offline    # no network at all (uses the bundled migration pack)
+```
+
+You get `scan.md`, a readable report, and `scan.json`, the same data for tools. They go in `lastorders-out/`, or wherever `--out` points. Each finding includes:
+
+- **File, line and model ID**, from code (Python, JS, TS), `.env` files, YAML, JSON, TOML and docs
+- **Shutdown date and recommended replacement**, from the provider's published deprecations
+- **Risk level**. High means the date is close or has passed, or the new model needs a code change your
+  code doesn't have yet, such as `max_tokens` becoming `max_completion_tokens`, `reasoning_effort` for tools
+  and `temperature`, or an unsupported endpoint
+- **Fine-tuned models** (`ft:...`), listed separately. They shut down with their base model and can't be
+  swapped automatically.
+- **Models chosen by environment variable** (`os.getenv("OPENAI_MODEL")`), so you can check the
+  values you have deployed
+- **SDKs detected**: the official `openai` and `anthropic` clients, LangChain and plain HTTP
+
+Useful flags:
+
+| Flag | What it does |
+|---|---|
+| `--fail-on-high` | exit code 2 if anything is high risk (for CI) |
+| `--no-docs` | skip `.md` / `.txt` files |
+| `--pack openai` | only use some providers' packs (default: all) |
+| `--offline` | use the bundled pack only; makes no network calls |
+| `--format json` | print the summary as JSON |
+| `--summary-file F` / `--annotations` | CI outputs (used by the GitHub Action) |
+
+## Fix (patch preview)
+
+```bash
+lastorders fix .                 # writes lastorders-out/fix.diff + fix-plan.md; changes nothing on disk
+lastorders fix . --verify        # also checks the patch on a scratch copy (see below)
+git apply lastorders-out/fix.diff
+```
+
+`fix` swaps the retiring model IDs and then makes the code changes the new model needs at each API call:
+
+- **Renames `max_tokens`**, to `max_completion_tokens` on Chat Completions or `max_output_tokens` on Responses.
+- **Adds `reasoning_effort: "none"`** where gpt-6-luna needs it: Chat Completions calls with tools, and
+  calls that set `temperature`, `top_p` or `logprobs`. On Responses it adds `reasoning.effort`.
+- **Flags anything it can't decide safely** in `fix-plan.md`: legacy `functions` calls, Assistants and legacy
+  Completions calls (these stay on their current model in the patch), fine-tunes and fine-tuning jobs,
+  LangChain wrappers, calls that pass `**kwargs` or a spread object, conflicting values, and calls whose model
+  isn't visible in the code (use `--assume-model`).
+
+Every change comes from the migration pack's rules. Python is edited with
+[libcst](https://github.com/Instagram/LibCST), so your formatting and comments are kept. JS and TS are edited
+with a built-in parser. Rules the pack marks `inferred` are only suggested unless you pass `--include-inferred`.
+
+**Old models reject `reasoning_effort`.** We tested gpt-4o and gpt-4.1 against the live API, and both return
+HTTP 400. Any fix that adds it has to ship together with the model switch. When the model comes from an
+environment variable, the plan marks the fix "ship with the model switch". `--no-model-swap` applies only
+the changes that are safe on the old model.
+
+`--verify` applies the patch to a temporary copy of your repo, then:
+
+1. checks the changed files still parse;
+2. re-runs the fixer and checks it changes nothing more;
+3. replays each fixed call twice: once as it was (old model, old arguments) and once as patched (new model,
+   new arguments).
+
+Without `--live`, the replay uses simulated responses. With `--live` and your own `OPENAI_API_KEY` (licence),
+the calls go straight to OpenAI. A control run also sends the unpatched arguments to the new model, to show
+each fix was needed. `--evals evals/regression.yaml` reruns your own suite with the fixed arguments.
+
+## GitHub Action
+
+Add `.github/workflows/model-scan.yml`:
+
+```yaml
+name: Model retirement scan
+on:
+  pull_request:
+  schedule: [{ cron: "0 7 * * 1" }]   # weekly, so new deprecations show up without code changes
+permissions:
+  contents: read
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: burntandtoast/lastorders@v0     # available once the repo is published
+        with:
+          fail-on-high: "true"
+```
+
+The Action posts a summary table to the job page, marks findings inline on the PR and uploads `scan.json`
+as an artifact. Inputs:
+
+| Input | Default | |
+|---|---|---|
+| `path` | `.` | folder to scan |
+| `fail-on-high` | `false` | fail the job on high-risk findings |
+| `include-docs` | `true` | scan `.md`/`.txt` |
+| `annotations` | `true` | inline PR annotations |
+| `packs` | all | e.g. `openai,anthropic` |
+| `offline` | `false` | bundled pack only, no network |
+| `packs-url` | built-in | override the pack URL |
+| `version` | action source | install this version from PyPI instead |
+| `python-version` | `3.12` | |
+| `fix-preview` | `false` | also attach the automatic-fix patch + plan (simulated verify, no key) |
+| `artifact-name` | `lastorders-scan` | |
+
+Outputs: `total`, `high` and `report-dir`.
+
+## Migration packs: where the data comes from
+
+What the scanner knows lives in **migration packs**, versioned JSON files with one pack per provider. Each pack
+holds the model IDs and aliases, shutdown dates, replacements, call-site patterns, and parameter and endpoint
+rules. Every fact links to the provider's documentation and the date we checked it. Rules we confirmed
+against the live API are marked `live-tested`, and anything we assumed is marked `inferred`.
+
+- **OpenAI**: full pack
+- **Anthropic**: preview (stub). It covers Claude API retirement dates from Anthropic's deprecations page.
+  Amazon Bedrock and Google Cloud dates are not covered yet.
+- Gemini, Azure OpenAI and Bedrock: planned
+
+The tool checks for a newer pack once a day and falls back to the copy bundled with the package.
+`lastorders packs list` shows which version and source you're using. The format is documented in
+[docs/PACKS.md](docs/PACKS.md), with a JSON Schema in `migration_kit/pack_data/pack.schema.json`.
+
+## Privacy and network use
+
+- The scan runs **entirely on your machine**. Your code and prompts are never uploaded.
+- **The tool has no telemetry, analytics or tracking.** (Our website counts visits anonymously with Cloudflare Web Analytics: no cookies, no ads, no tracking across sites.)
+- The tool only ever contacts us to **download the latest migration pack** (a plain GET of a static JSON file,
+  with no identifiers) and, for paid features, to **check a licence key**. That check sends only the key and the
+  repo name (`github.com/owner/repo`), and the signed answer is cached for a week, with a 14-day offline grace period after that.
+- `--offline` (or `LASTORDERS_OFFLINE=1`) turns off all network access and uses the bundled pack.
+- The paid `eval` command calls the AI provider directly **with your own API key**. Nothing goes through us.
+
+## Paid features
+
+| | Free | Licence (per repo) | Done for you |
+|---|---|---|---|
+| `scan`, GitHub Action, patch preview (`fix` / `swap` write a `.diff`), `fix --verify` (simulated replay) | ✓ | ✓ | ✓ |
+| `fix --apply` / `swap --apply`, `fix --verify --live`, `init-evals` + `eval` regression testing, client-ready `report` | | ✓ | ✓ |
+| We do the migration, evals and handoff | | | ✓ |
+
+One licence covers **one GitHub repository, monorepos included**. It's bound to the repo the first time
+you use it. Buy one with `lastorders licence buy` (it prints a Stripe Checkout link for this repo), then pass the key
+with `LASTORDERS_LICENCE` (a repository secret in Actions) or `--licence`. `lastorders licence status` shows
+whether it's verified. Paid commands work `--offline` from the cached check. Repos without an `origin` remote
+can set `LASTORDERS_REPO=github.com/owner/repo`. The licence server lives in `server/`; see
+[docs/LICENCE-SERVER.md](docs/LICENCE-SERVER.md).
+
+`init-evals` reads the call sites the scan found, including prompts, JSON schemas and tool definitions where
+they can be read from the code, and writes a starter `evals/regression.yaml`. You then edit it into 10 to 20
+real examples. `eval` runs them against the old and new model with your own key.
+
+## Limitations
+
+- Detection uses pattern matching. Model names built at runtime or stored in a database won't be found;
+  env-var lookups are listed so you can check them.
+- A pack is only as current as its `updated` date. Always check the provider's documentation before acting.
+- The scan suggests changes; it doesn't decide them for you. Review every patch.
+
+---
+
+Made by [Burnt & Toast Studios](https://burntandtoast.com). Not affiliated with OpenAI or Anthropic.

lastorders-0.4.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+migration_kit/__init__.py,sha256=U9qijUvUFRPgvdGkwjck75q-QM0oETBGjERmkjihLb4,116
+migration_kit/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+migration_kit/brand.py,sha256=glaklNIcsom1wu4P4LDsJMd_FJaVAFljKsZBMZ0pKjo,1400
+migration_kit/cli.py,sha256=mp3ygiiz20TsTl3ILiFIzcOdER5a5BV4pKfcdrd8PN0,17437
+migration_kit/evaluator.py,sha256=1X-fAsqhlq0la12EQM8PzALbs0SZBxohBdNrlxdHFd8,23767
+migration_kit/initevals.py,sha256=inm4tkQRzCfF6JIL8buU-dXz0vi3MyQQSyKQ-ZBglEE,12757
+migration_kit/licence.py,sha256=YvdrUOrP9GJM1KOvsEDa-6Xo7uH6eKw7TM0wPS5glq4,14864
+migration_kit/packs.py,sha256=cd9QhUyTXlxdogWv-yoPgWVLKjXmR6jJjbaDT6_HE0U,11641
+migration_kit/report.py,sha256=8ZVUnnW3ZQnVTWO33x5lXW58Uv_YLawPLgqq9izSgi0,21751
+migration_kit/scanner.py,sha256=PnPwSgkb9YnsI7Va6jbRb2qt-iu1AmqP5vfDVwdEcRY,16846
+migration_kit/site.py,sha256=ujeU2xvlwvMcCBIDEgJMc7-PqgPnuYAiNJHS8qeq8AA,3025
+migration_kit/swapper.py,sha256=j5ad_fdztKfWOWGaSeJZyLViDjDze-n0rKZU3AZEfPs,4616
+migration_kit/fixer/__init__.py,sha256=fYzn1CHJJ5d7qnvNlL5PxNHpcdlwu8ey-cuWxIQ8e6o,710
+migration_kit/fixer/callsite.py,sha256=xe2UIB5mt10jSyMTKaDWtFbUwMvXUY3Mvl-TAM1NPzo,2040
+migration_kit/fixer/engine.py,sha256=T0aP6W2rjL6h1Pt_6ZV1okh0K1lTSszyXxQXF6B2Bw8,23958
+migration_kit/fixer/jsfix.py,sha256=iu1pvLMJlSH7DQgmCQzIb5lCJy45M1bPZYaoEgio7Qo,14444
+migration_kit/fixer/pyfix.py,sha256=dq2fB5THHVyEK0SNdc72aGgN-t6ANeTVpoBiN1E8UcI,11090
+migration_kit/fixer/verify.py,sha256=_aYYoZiLg0febNduxVghpvYqrH28dRGeOGVVf0UfWGA,14796
+migration_kit/pack_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+migration_kit/pack_data/anthropic.json,sha256=0c_BV0EnIhcUx-8PYKZAwZm1PTZZimj7ftUBr3xAZGs,8491
+migration_kit/pack_data/openai.json,sha256=oLhW80Qg3h-bwry0ZJKteiiB_acUMK8XYoypS76NfMY,43013
+migration_kit/pack_data/pack.schema.json,sha256=AYPeyGGAHE-yYTZROdOfaJ3W8VnhgxobS7ZxxEfh5FE,15465
+lastorders-0.4.0.dist-info/METADATA,sha256=onlkFizEQfN1G_ZO43zjAdlTgZPxV5nsxohs_V-_29w,10747
+lastorders-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lastorders-0.4.0.dist-info/entry_points.txt,sha256=eayw4lQfz_JEGDcxa1Fn3PckPf2LtXOPTRncNCc_Zpo,54
+lastorders-0.4.0.dist-info/top_level.txt,sha256=53GEur-LGzO74ESgMu4tb9PHtiQl3r1eMopbHxMK5Hk,14
+lastorders-0.4.0.dist-info/RECORD,,

lastorders-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lastorders-0.4.0.dist-info/entry_points.txt

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

lastorders-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+migration_kit

migration_kit/__init__.py

@@ -0,0 +1,2 @@
+"""Find and fix retiring AI model IDs (Burnt & Toast Studios). Product name: see brand.py."""
+__version__ = "0.4.0"

migration_kit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

migration_kit/brand.py

@@ -0,0 +1,27 @@
+"""Product naming in ONE place: everything user-visible reads from here.
+
+The product is "Last Orders" (CLI, package and PyPI name `lastorders`, env prefix LASTORDERS_),
+chosen 15 Oct 2026. To rename again, run `python scripts/rename_product.py "New Name" newcli`, which
+updates this file plus every static place Python can't read at build time (pyproject.toml,
+action.yml, workflows, docs, tests, examples, site/ and server/)."""
+import os
+
+PRODUCT_NAME = "Last Orders"
+CLI_NAME = "lastorders"                # console command, package and PyPI distribution name
+ENV_PREFIX = "LASTORDERS"              # env vars: LASTORDERS_OFFLINE, LASTORDERS_LICENCE, ...
+COMPANY = "Burnt & Toast Studios"
+SERVICE_URL = "https://packs.burntandtoast.com"    # CLI-facing: licence API, pack files (server/)
+SITE_URL = "https://lastorders.burntandtoast.com"  # customer-facing: landing page, buy, terms
+PACKS_URL = f"{SERVICE_URL}/v1"
+LICENCE_URL = f"{SERVICE_URL}/api/licence/verify"   # override: $LASTORDERS_LICENCE_URL
+BUY_URL = f"{SITE_URL}/buy"                         # Stripe Checkout (append ?repo=github.com/owner/name to prefill)
+TERMS_URL = f"{SITE_URL}/terms"                     # licence terms and refund policy
+CACHE_DIR_NAME = CLI_NAME
+
+
+def env_name(key: str) -> str:
+    return f"{ENV_PREFIX}_{key}"
+
+
+def env(key: str, default: str = "") -> str:
+    return os.environ.get(env_name(key), default)

migration_kit/cli.py

@@ -0,0 +1,365 @@
+"""CLI: scan | swap | fix | init-evals | eval | report | packs | mapping | licence | demo"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__, brand, licence, scanner
+from .packs import load_packs
+
+HERE = Path(__file__).resolve().parent.parent
+
+
+def _packs(a):
+    provs = [p.strip() for x in (a.pack or []) for p in x.split(",") if p.strip()] or None
+    return load_packs(provs, offline=a.offline or None, url=a.packs_url, extra_files=a.pack_file)
+
+
+def _off(a):
+    """--offline if given, else None so <PREFIX>_OFFLINE decides."""
+    return True if getattr(a, "offline", False) else None
+
+
+def cmd_licence(a) -> int:
+    if a.action == "buy":
+        print(licence.buy_url(licence.repo_identity(a.repo)))
+        print(f"Terms and refunds: {brand.TERMS_URL}", file=sys.stderr)
+        return 0
+    lic = licence.resolve(a.licence, a.repo)
+    if a.action == "forget":
+        if lic.key and lic.repo_id:
+            licence.clear_cache(lic.key, lic.repo_id)
+        print("Cleared the cached licence verification for this repo." if lic.key else "No licence key set.")
+        return 0
+    lic = licence.require("licence check", a.licence, a.repo, offline=_off(a))
+    print(licence.describe(lic))
+    return 0
+
+
+def cmd_scan(a) -> int:
+    packs = _packs(a)
+    res = scanner.scan(a.repo, include_docs=not a.no_docs, packs=packs)
+    j, m = scanner.write_reports(res, a.out)
+    s = scanner.summarise(res)
+    if a.summary_file:
+        Path(a.summary_file).parent.mkdir(parents=True, exist_ok=True)
+        with open(a.summary_file, "a", encoding="utf-8") as fh:
+            fh.write(scanner.to_summary_markdown(res) + "\n")
+    if a.annotations:
+        for line in scanner.github_annotations(res):
+            print(line)
+    if a.format == "json":
+        print(json.dumps(res.to_dict()["summary"], indent=2))
+    else:
+        packs_s = ", ".join(f"{p['provider']} v{p['version']} ({p['source']}"
+                            + (f"; {p['detail']}" if p["detail"] else "") + ")" for p in res.packs)
+        print(f"Scanned {res.files_scanned} files: {s['total_findings']} model references {s['by_risk']}. "
+              f"Fine-tunes: {len(s['fine_tuned_models'])}.\n  packs: {packs_s}\n  {m}\n  {j}")
+    return 2 if a.fail_on_high and s["by_risk"].get("high") else 0
+
+
+def cmd_swap(a) -> int:
+    from . import swapper
+    if a.apply or licence.GATE_SWAP_PATCH:
+        print(licence.describe(licence.require("swap-apply", a.licence, a.repo, offline=_off(a))), file=sys.stderr)
+    packs = _packs(a)
+    mapping = swapper.load_mapping(a.mapping) if a.mapping else swapper.mapping_from_packs(packs)
+    if a.include_docs:
+        mapping.include_docs = True
+    res = swapper.plan(a.repo, mapping, packs)
+    p, s = swapper.write(res, a.out)
+    print(f"{len(res.changes)} replacements in {len(res.new_contents)} files; "
+          f"{len(res.skipped_fine_tunes)} fine-tuned references left alone. Mapping: {mapping.source or a.mapping}")
+    print(f"  patch:   {p}\n  summary: {s}")
+    if a.apply:
+        n = swapper.apply_in_place(a.repo, res)
+        print(f"Applied in place to {n} files (--apply).")
+    else:
+        print(f"Nothing changed on disk. Review, then: git -C {a.repo} apply {Path(p).resolve()}")
+    return 0
+
+
+def _dirty(repo: str, files: list[str]) -> list[str]:
+    """Touched files with uncommitted changes (only when the repo is a git checkout)."""
+    import shutil
+    import subprocess
+    git = shutil.which("git")
+    if not git or not files:
+        return []
+    r = subprocess.run([git, "-C", repo, "status", "--porcelain", "--", *files], capture_output=True, text=True)
+    return [ln[3:] for ln in r.stdout.splitlines()] if r.returncode == 0 else []
+
+
+def cmd_fix(a) -> int:
+    from . import fixer, swapper
+    from .fixer import verify as fverify
+    if a.apply or licence.GATE_FIX_PATCH:
+        print(licence.describe(licence.require("fix-apply", a.licence, a.repo, offline=_off(a))), file=sys.stderr)
+    if a.verify and a.live and not a._demo:
+        print(licence.describe(licence.require("eval", a.licence, a.repo, offline=_off(a))), file=sys.stderr)
+    packs = _packs(a)
+    mapping = swapper.load_mapping(a.mapping) if a.mapping else None
+    res = fixer.plan_fixes(a.repo, packs, mapping=mapping, model_swap=not a.no_model_swap,
+                           assume_model=a.assume_model, include_inferred=a.include_inferred)
+    paths = fixer.write(res, a.out)
+    c = res.counts()
+    print(f"{len(res.new_contents)} files changed ({res.swap_changes} model ID replacements). "
+          + ", ".join(f"{k}: {v}" for k, v in sorted(c.items())))
+    print(f"  patch: {paths['diff']}\n  plan:  {paths['md']}")
+    ok = True
+    if a.verify:
+        rep = fverify.verify(a.repo, res, packs, Path(a.out) / "verify", live=a.live, suite_path=a.evals,
+                             assume_model=a.assume_model, include_inferred=a.include_inferred)
+        ok = rep["ok"]
+        print(f"  verify: {'PASS' if ok else 'FAIL'} ({'live' if a.live else 'mock'} eval) -> {Path(a.out) / 'verify' / 'verify.md'}")
+    if a.apply:
+        if not ok:
+            print("Not applied: verification failed (see verify.md).", file=sys.stderr)
+            return 6
+        dirty = _dirty(a.repo, sorted(res.new_contents))
+        if dirty and not a.force:
+            print("Not applied: these files have uncommitted changes (commit or stash them, or pass --force): "
+                  + ", ".join(dirty), file=sys.stderr)
+            return 7
+        n = fixer.engine.apply_in_place(a.repo, res)
+        print(f"Applied in place to {n} files (--apply).")
+    else:
+        print(f"Nothing changed on disk. Review, then: git -C {a.repo} apply {Path(paths['diff']).resolve()}")
+    return 0 if ok else 6
+
+
+def cmd_init_evals(a) -> int:
+    from . import initevals
+    if not a._demo:
+        print(licence.describe(licence.require("init-evals", a.licence, a.repo, offline=_off(a))), file=sys.stderr)
+    packs = _packs(a)
+    suite, skipped = initevals.build_suite(a.repo, packs=packs)
+    out = initevals.write_suite(suite, skipped, a.out)
+    todos = sum(1 for c in suite["cases"] if "todo" in c or "TODO" in str(c.get("prompt", "")))
+    print(f"Wrote {out}: {len(suite['cases'])} case(s) from call sites ({todos} need your input). "
+          f"Old {suite['models']['old']} -> new {suite['models']['new']}.")
+    for s in skipped:
+        print(f"  not covered: {s}")
+    return 0
+
+
+def cmd_eval(a) -> int:
+    from . import evaluator
+    if not a._demo:
+        print(licence.describe(licence.require("eval", a.licence, ".", offline=_off(a))), file=sys.stderr)
+    suite = evaluator.load_suite(a.suite)
+    if a.api:
+        suite["api"] = a.api
+    todo = [c["id"] for c in suite["cases"] if "TODO" in str(c.get("prompt", "")) and not c.get("skip")]
+    provider, warn = evaluator.make_provider(suite, a.dry_run)
+    if todo and provider.name != "mock":
+        print(f"{len(todo)} case(s) still have TODO prompts ({', '.join(todo[:5])}). Replace them with real inputs "
+              "(or set `skip: true`) before a live run; nothing was sent.", file=sys.stderr)
+        return 5
+    if warn:
+        print(warn, file=sys.stderr)
+    res = evaluator.run_suite(suite, provider, a.old, a.new)
+    j, m = evaluator.write(res, a.out)
+    print(f"{res['mode']} run of {len(res['cases'])} cases: {res['summary']}\n  {m}\n  {j}")
+    bad = res["summary"].get("fail", 0) + res["summary"].get("error", 0)
+    return 3 if a.fail_on_regression and bad else 0
+
+
+def cmd_report(a) -> int:
+    from . import report
+    if not a._demo:
+        root = json.loads(Path(a.scan).read_text()).get("root", ".")
+        print(licence.describe(licence.require("report", a.licence, root if Path(root).exists() else ".", offline=_off(a))), file=sys.stderr)
+    md, ht = report.generate(a.client, a.scan, a.out, a.swap_summary, a.diff, a.eval, label=a.label, packs=_packs(a),
+                             fix_plan_path=a.fix_plan, fix_verify_path=a.fix_verify)
+    print(f"  {ht}\n  {md}")
+    return 0
+
+
+def cmd_packs(a) -> int:
+    from . import packs as pk
+    if a.action == "list":
+        for i in _packs(a).info():
+            print(f"{i['provider']:<10} v{i['version']:<12} {i['status']:<7} {i['source']}"
+                  + (f" ({i['detail']})" if i["detail"] else "") + f"  {i['name']}")
+    elif a.action == "validate":
+        for f in a.files:
+            if Path(f).name == "pack.schema.json":
+                continue
+            pk.validate(json.loads(Path(f).read_text()))
+            print(f"OK  {f}")
+    elif a.action == "build-site":
+        from .site import build_site
+        out = build_site(Path(a.out))
+        print(f"Static site written to {out}")
+    return 0
+
+
+def cmd_mapping(a) -> int:
+    from . import swapper
+    import yaml
+    m = swapper.mapping_from_packs(_packs(a), a.migration or None)
+    text = (f"# {m.source}\n" + yaml.safe_dump({"source": m.source, "mappings": m.replacements,
+                                                "fine_tuned": {}, "include_docs": False}, sort_keys=False))
+    if a.out:
+        Path(a.out).write_text(text)
+        print(f"Wrote {a.out}")
+    else:
+        print(text)
+    return 0
+
+
+def cmd_demo(a) -> int:
+    """Run the whole pipeline on examples/ offline (source checkout only; no licence needed)."""
+    ex = HERE / "examples"
+    if not ex.exists():
+        print("demo needs a source checkout (examples/ not found)", file=sys.stderr)
+        return 1
+    out = Path(a.out)
+    repo = ex / "sample-app"
+    steps = [["scan", str(repo), "--out", str(out), "--offline"],
+             ["swap", str(repo), "--mapping", str(HERE / "mappings" / "gpt4-series-to-gpt-6-luna.yaml"), "--out", str(out), "--offline"],
+             ["fix", str(repo), "--out", str(out), "--verify", "--offline"],
+             ["eval", str(ex / "evals" / "sample-suite.yaml"), "--dry-run", "--out", str(out)],
+             ["report", "--client", "Acme Widgets Ltd (sample)", "--scan", str(out / "scan.json"),
+              "--swap-summary", str(out / "swap-summary.json"), "--diff", str(out / "fix.diff"),
+              "--fix-plan", str(out / "fix-plan.json"), "--fix-verify", str(out / "verify" / "verify.json"),
+              "--eval", str(out / "eval.json"), "--out", str(out), "--offline",
+              "--label", "Demo: simulated eval outputs on a fictional sample repo"]]
+    for args in steps:
+        print(f"$ {brand.CLI_NAME} {' '.join(args)}")
+        rc = main(args, _demo=True)
+        if rc:
+            return rc
+    return 0
+
+
+def _pack_opts(p):
+    g = p.add_argument_group("migration packs")
+    g.add_argument("--pack", action="append", help="provider pack(s) to use, e.g. openai,anthropic (default: all)")
+    g.add_argument("--pack-file", action="append", help="load a local pack JSON (overrides same provider)")
+    g.add_argument("--offline", action="store_true",
+                   help=f"no network at all: use the bundled pack (or ${brand.env_name('OFFLINE')}=1)")
+    g.add_argument("--packs-url", help=f"base URL for hosted packs (default: ${brand.env_name('PACKS_URL')} or built-in)")
+
+
+def _lic_opt(p):
+    p.add_argument("--licence", "--license", dest="licence", help=f"licence key (or set ${licence.ENV_VAR})")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog=brand.CLI_NAME, description=f"{brand.PRODUCT_NAME}: find and fix retiring AI model IDs in your code.")
+    p.add_argument("--version", action="version", version=f"{brand.CLI_NAME} {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("scan", help="free: find retiring model IDs in a repo")
+    s.add_argument("repo", nargs="?", default=".")
+    s.add_argument("--out", default=f"{brand.CLI_NAME}-out")
+    s.add_argument("--no-docs", action="store_true", help="skip .md/.txt files")
+    s.add_argument("--fail-on-high", action="store_true", help="exit 2 if any high-risk finding (for CI)")
+    s.add_argument("--summary-file", help="append a compact markdown summary (e.g. $GITHUB_STEP_SUMMARY)")
+    s.add_argument("--annotations", action="store_true", help="print GitHub Actions annotations")
+    s.add_argument("--format", choices=["text", "json"], default="text", help="stdout format")
+    _pack_opts(s)
+    s.set_defaults(fn=cmd_scan)
+
+    w = sub.add_parser("swap", help="write a reviewable patch (--apply needs a licence)")
+    w.add_argument("repo")
+    w.add_argument("--mapping", help="mapping YAML (default: generated from the packs' headline migrations)")
+    w.add_argument("--out", default=f"{brand.CLI_NAME}-out")
+    w.add_argument("--include-docs", action="store_true")
+    w.add_argument("--apply", action="store_true", help="ALSO edit files in place [licence]")
+    _lic_opt(w)
+    _pack_opts(w)
+    w.set_defaults(fn=cmd_swap)
+
+    fx = sub.add_parser("fix", help="automatic fixes from the pack rules, as a reviewable patch (--apply needs a licence)")
+    fx.add_argument("repo", nargs="?", default=".")
+    fx.add_argument("--out", default=f"{brand.CLI_NAME}-out")
+    fx.add_argument("--mapping", help="mapping YAML for the model swap (default: generated from the packs)")
+    fx.add_argument("--no-model-swap", action="store_true",
+                    help="only fix arguments; fixes that need the new model are then listed, not applied")
+    fx.add_argument("--assume-model", help="model to assume for calls whose model isn't visible in the code")
+    fx.add_argument("--include-inferred", action="store_true", help="also apply rules marked 'inferred' in the pack")
+    fx.add_argument("--verify", action="store_true",
+                    help="apply to a scratch copy, check syntax + idempotence, and replay each fixed call old vs new")
+    fx.add_argument("--live", action="store_true", help="with --verify: real API calls with YOUR key [licence]")
+    fx.add_argument("--evals", help="with --verify: also run your eval suite, with the fixed arguments on matching cases")
+    fx.add_argument("--apply", action="store_true", help="ALSO edit files in place [licence]")
+    fx.add_argument("--force", action="store_true", help="with --apply: allow files with uncommitted changes")
+    _lic_opt(fx)
+    _pack_opts(fx)
+    fx.set_defaults(fn=cmd_fix)
+
+    ie = sub.add_parser("init-evals", help="[licence] generate a starter eval suite from the scan's call sites")
+    ie.add_argument("repo", nargs="?", default=".")
+    ie.add_argument("--out", default="evals/regression.yaml")
+    _lic_opt(ie)
+    _pack_opts(ie)
+    ie.set_defaults(fn=cmd_init_evals)
+
+    e = sub.add_parser("eval", help="[licence] regression-test old vs new model (uses YOUR provider key)")
+    e.add_argument("suite")
+    e.add_argument("--old")
+    e.add_argument("--new")
+    e.add_argument("--api", choices=["chat", "responses"])
+    e.add_argument("--dry-run", "--mock", dest="dry_run", action="store_true", help="no API calls; simulated outputs")
+    e.add_argument("--out", default=f"{brand.CLI_NAME}-out")
+    e.add_argument("--fail-on-regression", action="store_true", help="exit 3 on any fail/error")
+    _lic_opt(e)
+    e.set_defaults(fn=cmd_eval)
+
+    r = sub.add_parser("report", help="[licence] client report (HTML + Markdown)")
+    r.add_argument("--client", required=True)
+    r.add_argument("--scan", required=True)
+    r.add_argument("--swap-summary")
+    r.add_argument("--diff")
+    r.add_argument("--eval")
+    r.add_argument("--label", help="banner at the top of the report")
+    r.add_argument("--fix-plan", help="fix-plan.json from `fix` (adds the automatic-fixes section)")
+    r.add_argument("--fix-verify", help="verify/verify.json from `fix --verify`")
+    r.add_argument("--out", default=f"{brand.CLI_NAME}-out")
+    _lic_opt(r)
+    _pack_opts(r)
+    r.set_defaults(fn=cmd_report)
+
+    k = sub.add_parser("packs", help="list / validate migration packs, or build the static hosting site")
+    k.add_argument("action", choices=["list", "validate", "build-site"])
+    k.add_argument("files", nargs="*", help="pack files (validate)")
+    k.add_argument("--out", default="site", help="output folder (build-site)")
+    _pack_opts(k)
+    k.set_defaults(fn=cmd_packs)
+
+    mp = sub.add_parser("mapping", help="print the default swap mapping generated from the packs")
+    mp.add_argument("--migration", action="append", help="migration id(s) (default: headline migrations)")
+    mp.add_argument("--out")
+    _pack_opts(mp)
+    mp.set_defaults(fn=cmd_mapping)
+
+    li = sub.add_parser("licence", aliases=["license"], help="check this repo's licence, print the buy link, or forget the cached check")
+    li.add_argument("action", choices=["status", "buy", "forget"])
+    li.add_argument("repo", nargs="?", default=".")
+    li.add_argument("--offline", action="store_true", help="use only the cached verification")
+    _lic_opt(li)
+    li.set_defaults(fn=cmd_licence)
+
+    d = sub.add_parser("demo", help="run everything on examples/ offline (source checkout)")
+    d.add_argument("--out", default=str(HERE / "examples" / "demo-output"))
+    d.set_defaults(fn=cmd_demo)
+    return p
+
+
+def main(argv: list[str] | None = None, _demo: bool = False) -> int:
+    a = build_parser().parse_args(argv)
+    a._demo = _demo
+    try:
+        return a.fn(a)
+    except licence.LicenceError as e:
+        print(f"{brand.CLI_NAME}: {e}", file=sys.stderr)
+        return 4
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())