stata-code 0.6.1__tar.gz → 0.6.3__tar.gz

{stata_code-0.6.1 → stata_code-0.6.3}/CHANGELOG.md

@@ -6,6 +6,147 @@ to semver-major.minor for the result schema (see `SCHEMA.md` §6).
 
 ## Unreleased
 
+## 0.6.3 — 2026-05-10
+
+### Added
+
+- **`RefNotFound` exception** — `get_log` / `get_graph` / `get_matrix` now
+  raise a typed `RefNotFound` (subclass of `KeyError`) carrying the bad
+  ref and a stable `kind` token (`unknown_log_ref` / `unknown_graph_ref` /
+  `unknown_matrix_ref`). MCP dispatch maps it to a typed error response
+  without string-parsing.
+- **`NotebookError.kind` / `RunIndexError.kind`** — both classes now
+  expose a `kind` property so callers don't have to slice the message
+  prefix manually.
+- **`SessionPool.list_session_info_detailed`** — partial-failure-aware
+  variant of `list_session_info()` that surfaces per-worker `warnings`
+  alongside the aggregated `sessions` list. The MCP `list_sessions`
+  tool's output schema now includes the optional `warnings` field.
+- **`list_runs.requested_limit`** — echoes the original requested limit
+  when the server clamps it to `_LIMIT_MAX`, so a caller asking for
+  `limit=1000` can distinguish "scan was capped at 500 rows" from "the
+  manifest dir really has more than 500 rows".
+- **Server capabilities resource now includes prompts.** Reading
+  `stata://server/capabilities` returns tools, resource templates, AND
+  prompts in a single document — clients no longer need a follow-up
+  `list_prompts` round-trip just to enumerate the full surface.
+
+### Changed
+
+- **Test hygiene** — a `tests/conftest.py` snapshot/restores `_refs._store`
+  per test and shuts the default subprocess pool down at session end.
+  Closes a class of intermittent cross-test failures caused by ref-store
+  pollution from earlier MCP / pool tests.
+- **Subprocess cancellation race** — `SessionPool.execute()` now
+  re-checks `_cancel_pending` after `_get_or_spawn` so a `request_cancel`
+  that lands during worker spawn fires on the in-flight call instead of
+  the next one.
+- **`stata_info` edition casing is now consistent** — the top-level
+  `edition` field mirrors `stata.edition` (the enum value, e.g. `MP`)
+  verbatim. Previously the pool path lowercased it to `mp` while the
+  in-process path emitted `MP`, so the same payload could disagree with
+  itself.
+- **All MCP tool input schemas now declare `additionalProperties: false`.**
+  Typos like `originPath` (camelCase) or misspelled `log_lin_head` are
+  now rejected up-front with a typed validation error instead of silently
+  producing a wrong run.
+- **`cancel_session` and `reset_session` output schemas split.** Each
+  tool now advertises only the fields it actually returns; the previous
+  shared schema overpromised on one side and underpromised on the other.
+- **`list_resources` caps ref-backed entries at 256.** Long-lived
+  servers no longer return thousands of stale ref resources from
+  forgotten sessions — the most recently used 256 win.
+- **Pystata edition init now preserves the full error trail.** When all
+  three editions (MP / SE / BE) fail, the `PystataNotAvailable` message
+  lists each attempt's error rather than collapsing to the last one.
+
+### Fixed
+
+- **Jupyter kernel `implementation_version`** is now derived from
+  `stata_code.__version__` rather than a separate `0.2.0` literal.
+- **Jupyter kernel mypy `Invalid base class`** error — the dynamic
+  `Kernel if _HAS_IPYKERNEL else object` base class confused mypy.
+  Hidden behind a `TYPE_CHECKING` gate now; runtime behavior unchanged.
+- **`do_execute` / `do_inspect` signatures** are now LSP-compatible
+  with the latest `ipykernel.kernelbase.Kernel` (accepts `cell_meta`,
+  `cell_id`, `omit_sections`).
+- **Schema `$id` URL** corrected from `stata_code` to `stata-code`
+  (matches the actual GitHub repository name).
+- **VS Code MCP handshake** version is now read from `package.json`
+  via `resolveJsonModule`, removing the former fifth sync site.
+  `check_versions.py` still validates the literal form
+  when present, so reverting to a hardcoded string fails CI.
+- **Release tag glob tightened** — `v[0-9]*.[0-9]*.[0-9]*` instead of
+  `v[0-9]*` so stray tags without semver-style dot separators no longer
+  trigger the release workflow.
+- **Release pipeline now gates on ruff** so a direct push to `main`
+  cannot ship un-linted code.
+- **Mypy CI now covers `stata_code/mcp` and `stata_code/kernel`** in
+  addition to `core`, with the optional `mcp` / `kernel` extras
+  installed so `Server`, `Tool`, and `Kernel` symbols resolve.
+- **`COMMON_STATA_COMMANDS` deduplicated** — dropped the short forms
+  (`cap` / `qui` / `noi` / `mat` / `di`) that were producing
+  near-duplicate "did you mean" hits from `difflib`. The long forms
+  cover the same fuzzy-match neighbourhood.
+- **`_unique_dir` / `_unique_file`** fall back to a UUID suffix after
+  998 collisions instead of raising `FileExistsError`. The original
+  behaviour blocked the run on conditions that almost always indicate a
+  filesystem issue rather than a name clash.
+- **Dead code removed** — `_info_payload` (orphaned helper) in the MCP
+  server, `_truncate` in `notebook.py`, and the unused `index` / `source`
+  parameters on `_ensure_native_id`.
+
+## 0.6.2 — 2026-05-08
+
+Aggregated from the prior `Unreleased` section; covers 0.6.1 and 0.6.2.
+
+### Added
+
+- **Release version guard.** `scripts/check_versions.py` and the CI /
+  release workflows now verify that the Python package, MCP server, VS Code
+  package, VS Code MCP handshake, and release tag all use the same version.
+- **VS Code MCP launch tests.** The extension's server-launch candidate
+  builder is now a pure tested module covering local `.venv` / `venv`
+  discovery, configured Python interpreters, inline command parsing, and
+  environment construction.
+- **VS Code packaging smoke test.** The default CI now builds a VSIX artifact
+  with the same local `vsce` package command used by release packaging, so
+  package-manifest and `.vscodeignore` mistakes fail before release day.
+- **VS Code extension bundling.** The extension now bundles its TypeScript
+  entrypoint with `esbuild`, excluding `node_modules` and test/build support
+  files from the shipped VSIX.
+- **VS Code bundled dependency notices.** `THIRD_PARTY_NOTICES.md` now lists
+  the npm packages included in the bundled extension output and their license
+  terms.
+- **PyPI publish verification.** The release workflow now polls PyPI's
+  per-version JSON endpoint after the official publish job, so trusted
+  publisher failures surface as a failed release run instead of being hidden
+  by `continue-on-error`.
+
+### Changed
+
+- **Package-level Python API is subprocess-backed.** `stata_code.run()`,
+  `execute()`, and `is_available()` now go through the same worker pool as
+  the MCP server, preserving hard timeout behavior and avoiding caller-process
+  stdout redirection by `pystata`.
+- **CI treats core type errors as blocking.** `mypy stata_code/core` is now a
+  hard failure, and the default test workflow also compiles and tests the VS
+  Code extension.
+- **VS Code npm installs are locked.** The extension now ships
+  `package-lock.json`, and CI / release workflows use `npm ci` for reproducible
+  dependency installs.
+- **VS Code bundle target matches the extension host floor.** The esbuild
+  target is `node18`, keeping the published bundle aligned with the current
+  `engines.vscode` lower bound.
+- **Python 3.13 is in the support matrix.** CI now runs the no-Stata test
+  suite on Python 3.13, and package metadata advertises the 3.13 classifier.
+
+### Fixed
+
+- **Cancelled in-flight runs report incomplete logs.** If a live worker is
+  killed by `cancel_session`, the synthetic cancelled result now marks
+  `log.complete=false`, matching timeout and adapter-crash behavior.
+
 ## [0.6.0] — 2026-05-08
 
 ### Added

{stata_code-0.6.1 → stata_code-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stata-code
-Version: 0.6.1
+Version: 0.6.3
 Summary: Agent-native Stata bridge — one core, multiple frontends (MCP, Jupyter, VSCode)
 Project-URL: Homepage, https://github.com/brycewang-stanford/stata-code
 Project-URL: Repository, https://github.com/brycewang-stanford/stata-code
@@ -18,6 +18,7 @@ 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 :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
@@ -37,7 +38,7 @@ Requires-Dist: mcp>=1.27; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 <p align="center">
-  <img src="branding/logo/horizontal@1024.png" alt="stata-code logo" width="520" />
+  <img src="https://raw.githubusercontent.com/brycewang-stanford/stata-code/main/branding/logo/horizontal@1024.png" alt="stata-code logo" width="520" />
 </p>
 
 <p align="center">
@@ -59,7 +60,7 @@ Description-Content-Type: text/markdown
 [![GitHub stars](https://img.shields.io/github/stars/brycewang-stanford/stata-code?style=social)](https://github.com/brycewang-stanford/stata-code)
 
 <p align="center">
-  <img src="branding/github-instructions.png" alt="stata-code: agent-native Stata bridge — one Python core, multiple frontends (Jupyter kernel, MCP server, VS Code extension)" width="720" />
+  <img src="https://raw.githubusercontent.com/brycewang-stanford/stata-code/main/branding/github-instructions.png" alt="stata-code: agent-native Stata bridge — one Python core, multiple frontends (Jupyter kernel, MCP server, VS Code extension)" width="720" />
 </p>
 
 > Agent-native Stata bridge — **one Python core, multiple frontends**.
@@ -83,7 +84,7 @@ Description-Content-Type: text/markdown
               └─────────────┘  └────────────┘  └─────────────────┘
 ```
 
-**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. Current test suite: 310 passing tests across schema, runner, MCP, kernel, notebook, and run-index modules. License: **MIT**.
+**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. Current test suite: 329 passing tests across schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules. License: **MIT**.
 
 Two workflows v0.6 explicitly supports for end users:
 
@@ -145,6 +146,10 @@ See [`examples/`](examples/) for end-to-end cookbook entries: basic regression,
 
 ### As a Python Library
 
+The package-level `run()` / `execute()` API uses the same subprocess-backed
+runner as the MCP server, so long calls honor `timeout_ms` and `pystata`
+stdout redirection stays isolated from the caller process.
+
 ```python
 from stata_code import run
 
@@ -348,14 +353,15 @@ stata_code/
 │   ├── _refs.py       # LRU ref store for log/graph/matrix payloads
 │   ├── schema.py      # Pydantic v2 models for the v1.0 result schema
 │   ├── errors.py      # rc → ErrorKind mapping + suggestion seeds
-│   └── runner.py      # the one execute(); collects everything via sfi
+│   ├── runner.py      # in-process execute(); collects everything via sfi
+│   └── _pool.py       # subprocess workers for public API / MCP hard timeouts
 ├── mcp/
 │   └── server.py      # MCP server (15 tools)
 └── kernel/
     └── kernel.py      # Jupyter kernel
 ```
 
-`runner.py` is the only place that touches Stata. The Jupyter kernel and MCP server both import from it and only translate results into their own transports.
+`runner.py` is the only place that directly talks to `pystata`. The public Python API and MCP server route calls through `_pool.py`, whose workers call `runner.execute()` in an isolated subprocess; the Jupyter kernel uses the in-process runner for notebook interactivity.
 
 ---
 

{stata_code-0.6.1 → stata_code-0.6.3}/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="branding/logo/horizontal@1024.png" alt="stata-code logo" width="520" />
+  <img src="https://raw.githubusercontent.com/brycewang-stanford/stata-code/main/branding/logo/horizontal@1024.png" alt="stata-code logo" width="520" />
 </p>
 
 <p align="center">
@@ -21,7 +21,7 @@
 [![GitHub stars](https://img.shields.io/github/stars/brycewang-stanford/stata-code?style=social)](https://github.com/brycewang-stanford/stata-code)
 
 <p align="center">
-  <img src="branding/github-instructions.png" alt="stata-code: agent-native Stata bridge — one Python core, multiple frontends (Jupyter kernel, MCP server, VS Code extension)" width="720" />
+  <img src="https://raw.githubusercontent.com/brycewang-stanford/stata-code/main/branding/github-instructions.png" alt="stata-code: agent-native Stata bridge — one Python core, multiple frontends (Jupyter kernel, MCP server, VS Code extension)" width="720" />
 </p>
 
 > Agent-native Stata bridge — **one Python core, multiple frontends**.
@@ -45,7 +45,7 @@
               └─────────────┘  └────────────┘  └─────────────────┘
 ```
 
-**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. Current test suite: 310 passing tests across schema, runner, MCP, kernel, notebook, and run-index modules. License: **MIT**.
+**Status: v0.6 (May 2026)** — the core, MCP server, Jupyter kernel, and VS Code extension work end-to-end against Stata 18 MP. Current test suite: 329 passing tests across schema, runner, MCP, kernel, notebook, run-index, subprocess-pool, and VS Code modules. License: **MIT**.
 
 Two workflows v0.6 explicitly supports for end users:
 
@@ -107,6 +107,10 @@ See [`examples/`](examples/) for end-to-end cookbook entries: basic regression,
 
 ### As a Python Library
 
+The package-level `run()` / `execute()` API uses the same subprocess-backed
+runner as the MCP server, so long calls honor `timeout_ms` and `pystata`
+stdout redirection stays isolated from the caller process.
+
 ```python
 from stata_code import run
 
@@ -310,14 +314,15 @@ stata_code/
 │   ├── _refs.py       # LRU ref store for log/graph/matrix payloads
 │   ├── schema.py      # Pydantic v2 models for the v1.0 result schema
 │   ├── errors.py      # rc → ErrorKind mapping + suggestion seeds
-│   └── runner.py      # the one execute(); collects everything via sfi
+│   ├── runner.py      # in-process execute(); collects everything via sfi
+│   └── _pool.py       # subprocess workers for public API / MCP hard timeouts
 ├── mcp/
 │   └── server.py      # MCP server (15 tools)
 └── kernel/
     └── kernel.py      # Jupyter kernel
 ```
 
-`runner.py` is the only place that touches Stata. The Jupyter kernel and MCP server both import from it and only translate results into their own transports.
+`runner.py` is the only place that directly talks to `pystata`. The public Python API and MCP server route calls through `_pool.py`, whose workers call `runner.execute()` in an isolated subprocess; the Jupyter kernel uses the in-process runner for notebook interactivity.
 
 ---
 

{stata_code-0.6.1 → stata_code-0.6.3}/SCHEMA.md

@@ -580,7 +580,6 @@ When v2 ships, v1 is supported by frontends for at least 6 months. Servers MAY e
 Explicitly *not* in this version, to keep the surface small:
 
 - **Streaming logs.** All output is batched at end-of-call. `log.complete: false` is reserved for this in v2. Streams (Stata vs Python vs Mata) may be separated under a future `log.streams` field.
-- **Hard timeout enforcement / mid-Stata interrupt.** `cancel(session_id)` is implemented as a *cooperative* signal that short-circuits the next `execute()` call before pystata is invoked; it does not interrupt code that is already mid-`stata.run()`. Hard interruption requires a subprocess-based runtime (post-v0.2).
 - **Distributed / remote sessions.** Sessions are per-process. `session_id` reserves `:` for future host-prefixing.
 - **Authentication / authorization.** Local trusted environment is assumed.
 - **Mata internals.** Mata code runs (`stata.run("mata: ...")`) but Mata-specific return values aren't surfaced beyond what `r()` carries.
@@ -596,7 +595,7 @@ Explicitly *not* in this version, to keep the surface small:
 This section tracks how much of the schema is wired up in code. Not normative
 — the contract above is the contract — but useful as a release checklist.
 
-### Implemented in v0.2 (2026-05)
+### Implemented through v0.6 (2026-05)
 
 - Log `head` / `tail` / `truncated` / `complete` / `error_window` / `ref`
   with an in-memory ref store backing `get_log`.
@@ -634,23 +633,21 @@ This section tracks how much of the schema is wired up in code. Not normative
 - LRU eviction on the ref store (default cap 256) keeps long-running
   producers from growing unboundedly.
 
-- **Cooperative cancellation** via `cancel(session_id)` /
-  `clear_cancel(session_id)` / `is_cancel_pending(session_id)`,
-  exposed as a Python API and as the MCP `cancel_session` tool.
-  Short-circuits the next `execute()` call for the named session and
-  returns a `RunResult` with `ok=false`, `rc=-3`,
-  `error.kind="cancelled"`. Cooperative semantics — does not
-  interrupt code that is already mid-`stata.run()`.
-
-### Still deferred (post-v0.2)
-
-- **Hard timeout / mid-Stata interrupt.** `timeout_ms` is accepted by
-  `execute()` but not yet enforced; cancellation is cooperative-only
-  (does not interrupt code already in-flight). pystata's in-process
-  model has no clean cancel primitive — v0.3 will move long calls
-  into a subprocess pool with signal-based cancellation. Design
-  constraints, options considered, and an effort estimate are
-  written up in [`docs/design/hard_timeout.md`](docs/design/hard_timeout.md).
+- **Subprocess-backed hard timeout and cancellation** via the public
+  package API, MCP `stata_run`, and the subprocess session pool.
+  `timeout_ms` returns `ok=false`, `rc=-2`, `error.kind="timeout"`
+  after terminating the worker. `cancel(session_id)` /
+  `clear_cancel(session_id)` / `is_cancel_pending(session_id)` and
+  MCP `cancel_session` return `ok=false`, `rc=-3`,
+  `error.kind="cancelled"`; an in-flight pool worker is terminated and a
+  not-yet-started run is short-circuited before Stata receives code.
+
+### Still deferred
+
+- **In-process hard timeout.** `stata_code.core.runner.execute()` still
+  runs inside the caller process and cannot preempt code already inside
+  `pystata`. Use the package-level `stata_code.run()` / `execute()` or
+  MCP server for subprocess-backed timeouts and cancellation.
 - **Console fallback for Stata 11–16.** Earlier scaffold's
   `ConsoleFallback` was deleted in v0.2 (it produced legacy
   `StataResult` and didn't fit the new pipeline). v0.3 will reintroduce

{stata_code-0.6.1 → stata_code-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stata-code"
-version = "0.6.1"
+version = "0.6.3"
 description = "Agent-native Stata bridge — one core, multiple frontends (MCP, Jupyter, VSCode)"
 readme = "README.md"
 license = "MIT"
@@ -21,6 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Mathematics",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]

{stata_code-0.6.1 → stata_code-0.6.3}/schema/run_result.schema.json

@@ -802,7 +802,7 @@
       "type": "object"
     }
   },
-  "$id": "https://github.com/brycewang-stanford/stata_code/schema/run_result.schema.json",
+  "$id": "https://raw.githubusercontent.com/brycewang-stanford/stata-code/main/schema/run_result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": true,
   "description": "Machine-readable JSON Schema for the v1.0 result envelope returned by stata_code.run(). The normative contract is SCHEMA.md; this file is auto-generated from stata_code.core.schema.RunResult and kept in sync by tests/test_schema_artifact.py.",

stata_code-0.6.3/scripts/check_versions.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Verify that every release version literal is aligned."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _read(rel: str) -> str:
+    return ROOT.joinpath(rel).read_text(encoding="utf-8")
+
+
+def _extract(rel: str, pattern: str) -> str:
+    match = re.search(pattern, _read(rel), re.MULTILINE)
+    if match is None:
+        raise RuntimeError(f"could not find version in {rel}")
+    return match.group(1)
+
+
+def _tag_version(tag: str) -> str:
+    for prefix in ("vscode-v", "v"):
+        if tag.startswith(prefix):
+            return tag[len(prefix):]
+    raise RuntimeError(f"tag must start with v or vscode-v, got {tag!r}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Check pyproject/Python/MCP/VS Code version literals."
+    )
+    parser.add_argument(
+        "--tag",
+        help="Optional Git tag to compare against, e.g. vX.Y.Z or vscode-vX.Y.Z.",
+    )
+    args = parser.parse_args()
+
+    versions = {
+        "pyproject.toml": _extract(
+            "pyproject.toml", r'(?m)^\s*version\s*=\s*"([^"]+)"'
+        ),
+        "stata_code/__init__.py": _extract(
+            "stata_code/__init__.py", r'(?m)^__version__\s*=\s*"([^"]+)"'
+        ),
+        "stata_code/mcp/server.py": _extract(
+            "stata_code/mcp/server.py", r'(?m)^__version__\s*=\s*"([^"]+)"'
+        ),
+        "vscode/package.json": json.loads(_read("vscode/package.json"))["version"],
+    }
+
+    # mcpClient.ts used to carry a literal version; we now resolve it at
+    # build time via ``import { version } from "../package.json"``. If the
+    # import is present, there is no separate sync site. If someone later
+    # reverts to a literal, parse it back so the alignment check still
+    # catches drift.
+    #
+    # KNOWN LIMITATION: when the import is present this script does NOT
+    # also scan the file for a stray hardcoded literal alongside the
+    # import (e.g. a merge-conflict artifact). The check is import-OR-
+    # literal, not import-AND-no-stray-literal. The Python sync sites
+    # don't have that escape hatch — they're always literal-checked.
+    # If this asymmetry ever causes a bad release, tighten by failing
+    # whenever BOTH the import and a literal handshake string co-exist.
+    mcp_client_src = _read("vscode/src/mcpClient.ts")
+    if 'from "../package.json"' not in mcp_client_src:
+        match = re.search(
+            r'\{\s*name:\s*"stata-code-vscode",\s*version:\s*"([^"]+)"\s*\}',
+            mcp_client_src,
+        )
+        if match is None:
+            raise RuntimeError(
+                "vscode/src/mcpClient.ts no longer imports the version from "
+                "../package.json AND does not declare a literal — restore "
+                "either form."
+            )
+        versions["vscode/src/mcpClient.ts"] = match.group(1)
+
+    unique = sorted(set(versions.values()))
+    ok = len(unique) == 1
+    expected = unique[0] if ok else None
+
+    if args.tag:
+        tag_version = _tag_version(args.tag)
+        if expected != tag_version:
+            ok = False
+            versions[f"tag:{args.tag}"] = tag_version
+
+    if ok:
+        print(f"ok: all release versions are {expected}")
+        return 0
+
+    print("version mismatch:", file=sys.stderr)
+    for source, version in versions.items():
+        print(f"  {source}: {version}", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{stata_code-0.6.1 → stata_code-0.6.3}/scripts/export_schema.py

@@ -31,7 +31,10 @@ def build_schema() -> dict:
     schema = RunResult.model_json_schema()
     # Stable, human-friendly framing for downstream consumers.
     schema["$schema"] = "https://json-schema.org/draft/2020-12/schema"
-    schema["$id"] = "https://github.com/brycewang-stanford/stata_code/schema/run_result.schema.json"
+    schema["$id"] = (
+        "https://raw.githubusercontent.com/brycewang-stanford/stata-code/"
+        "main/schema/run_result.schema.json"
+    )
     schema["title"] = "stata_code RunResult (v1.0)"
     schema["description"] = (
         "Machine-readable JSON Schema for the v1.0 result envelope returned by "