@4da/mcp-server 6.1.0 → 6.2.0

package/dist/tools/upgrade-impact-changelog.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Which changelog `upgrade_impact` reports, and what it says when there is none.
+ *
+ * Order: the changelog inside the target version's registry archive (always;
+ * Decision 1 option A), then, only when the user opted in with
+ * FOURDA_GITHUB_CHANGELOG and the archive does not cover the range, the
+ * GitHub fallback (a changelog file the project links, then its releases;
+ * Decision 1 option B). The GitHub result replaces the archive's only when it
+ * covers the range or has more of its releases.
+ *
+ * With the fallback off and no usable changelog, the answer says the
+ * changelog is unavailable and exactly how to enable the fallback, or that
+ * enabling it would not help (no GitHub repository). It never fills the gap
+ * with a guess.
+ */
+import { type ChangelogSection, type VersionOrder } from "../live/changelog.js";
+import { type ChangelogResult, type PublishedVersion, type RegistryIndex, type UpgradeNet } from "../live/upgrade-sources.js";
+export interface ResolvedChangelog {
+    changelog: ChangelogResult;
+    range: {
+        sections: ChangelogSection[];
+        coversRange: boolean;
+    };
+    /** Present when the archive did not cover the range: what the fallback did, or how to turn it on. */
+    github_fallback?: Record<string, unknown>;
+}
+export interface ChangelogRequest {
+    net: UpgradeNet;
+    index: RegistryIndex;
+    target: PublishedVersion;
+    from: string;
+    to: string;
+    firstInRange: string;
+    order: VersionOrder;
+    githubEnabled: boolean;
+    /** Repository to read releases from (Go: the proxy's VCS origin when known). */
+    repository: string | null;
+    /** Go: the module's tag prefix in its repository. */
+    tagPrefix?: string | null;
+}
+export declare function resolveChangelog(req: ChangelogRequest): Promise<ResolvedChangelog>;

package/dist/tools/upgrade-impact-changelog.js

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Which changelog `upgrade_impact` reports, and what it says when there is none.
+ *
+ * Order: the changelog inside the target version's registry archive (always;
+ * Decision 1 option A), then, only when the user opted in with
+ * FOURDA_GITHUB_CHANGELOG and the archive does not cover the range, the
+ * GitHub fallback (a changelog file the project links, then its releases;
+ * Decision 1 option B). The GitHub result replaces the archive's only when it
+ * covers the range or has more of its releases.
+ *
+ * With the fallback off and no usable changelog, the answer says the
+ * changelog is unavailable and exactly how to enable the fallback, or that
+ * enabling it would not help (no GitHub repository). It never fills the gap
+ * with a guess.
+ */
+import { selectRange } from "../live/changelog.js";
+import { GITHUB_CHANGELOG_ENV, getGithubChangelog, parseGithubRepo } from "../live/github-releases.js";
+import { getChangelog } from "../live/upgrade-sources.js";
+function rangeOf(result, req) {
+    return result.found && result.sections
+        ? selectRange(result.sections, req.from, req.to, req.firstInRange, req.order)
+        : { sections: [], coversRange: false };
+}
+export async function resolveChangelog(req) {
+    const archive = await getChangelog(req.net, req.index, req.target);
+    const archiveRange = rangeOf(archive, req);
+    if (archiveRange.coversRange)
+        return { changelog: archive, range: archiveRange };
+    const repo = parseGithubRepo(req.repository);
+    const pyLinks = (req.index.changelogLinks ?? []).filter((l) => /^https:\/\/(?:github\.com|raw\.githubusercontent\.com)\//i.test(l));
+    const archiveState = !archive.found
+        ? archive.reason ?? "no changelog in the archive"
+        : archiveRange.sections.length === 0
+            ? `${archive.file} has no section for these releases`
+            : `${archive.file} covers only part of the range`;
+    if (!req.githubEnabled) {
+        const where = repo ? `github.com/${repo.owner}/${repo.repo}` : null;
+        return {
+            changelog: archive,
+            range: archiveRange,
+            github_fallback: where || pyLinks.length > 0
+                ? {
+                    enabled: false,
+                    how_to_enable: `Set ${GITHUB_CHANGELOG_ENV}=true in this MCP server's environment to read the release notes ${where ? `on ${where}` : "the project links on GitHub"} when the archive has none. GitHub then receives the repository name and the version range only; GITHUB_TOKEN, if set, raises its rate limit.`,
+                }
+                : {
+                    enabled: false,
+                    note: `The package names no GitHub repository, so ${GITHUB_CHANGELOG_ENV} would not find release notes either; see release_notes_url.`,
+                },
+        };
+    }
+    const gh = await getGithubChangelog(req.net, {
+        pkg: req.index.name,
+        ecosystem: req.index.ecosystem,
+        repository: req.repository,
+        changelogLinks: req.index.changelogLinks,
+        from: req.from,
+        to: req.to,
+        tagPrefix: req.tagPrefix ?? null,
+        order: req.order,
+    });
+    if (!gh.found) {
+        return { changelog: archive, range: archiveRange, github_fallback: { enabled: true, used: false, reason: gh.reason } };
+    }
+    const ghRange = rangeOf(gh, req);
+    if (ghRange.coversRange || ghRange.sections.length > archiveRange.sections.length) {
+        return {
+            changelog: gh,
+            range: ghRange,
+            github_fallback: { enabled: true, used: true, source: gh.source, url: gh.url, archive: archiveState },
+        };
+    }
+    return {
+        changelog: archive,
+        range: archiveRange,
+        github_fallback: { enabled: true, used: false, reason: "the GitHub release notes cover no more of the range than the archive's changelog" },
+    };
+}

package/dist/tools/upgrade-impact-imports.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Python and Go import sites for `upgrade_impact`.
+ *
+ * Go is exact: a file imports a module by its path (`"github.com/jackc/pgx/v5"`
+ * or a package below it), and the identifiers it reaches through the package
+ * name (`pgx.Connect`) are the symbols a changelog entry can name.
+ *
+ * Python is not: a file imports a MODULE (`import yaml`), while an upgrade names
+ * a DISTRIBUTION (`PyYAML`), and nothing in the source links the two. The
+ * mapping comes, in order of trust, from:
+ *   1. the installed distribution's own metadata in this project's virtualenv
+ *      (`*.dist-info/top_level.txt`, else the top-level names in `RECORD`);
+ *   2. a short table of well-known distributions whose import name differs
+ *      (beautifulsoup4 -> bs4, Pillow -> PIL, PyYAML -> yaml, ...);
+ *   3. the distribution name itself with `-` and `.` read as `_`, which is
+ *      right for most packages and is reported as an ASSUMPTION every time,
+ *      so a count of zero files is never mistaken for "not used".
+ */
+export type ImportNameSource = "installed-metadata" | "known-mapping" | "assumed";
+export interface PythonImportNames {
+    names: string[];
+    source: ImportNameSource;
+    /** Where the installed metadata was read, relative to the project root. */
+    evidence?: string;
+}
+/** The module name(s) a distribution is imported as, and how that was established. */
+export declare function pythonImportNames(root: string | null, dist: string): PythonImportNames;
+/**
+ * Count imports of any of `names` in one Python file and collect the names it
+ * reaches: `from x import A, B` gives A and B; `import x` / `import x as y`
+ * gives the attributes used as `x.attr` / `y.attr`.
+ */
+export declare function scanPythonSource(source: string, names: string[], symbols: Set<string>): number;
+/** True when import path `imp` is module `mod` or a package inside it, not a different major (`mod/v2`). */
+export declare function goImportInModule(imp: string, mod: string): boolean;
+/** The package name an import path is used through: its last element, skipping a `/vN` suffix and gopkg.in's `.vN`. */
+export declare function goPackageName(imp: string): string;
+/**
+ * Count imports of a Go module (or packages inside it) in one file and collect
+ * the exported identifiers reached through each import's package name.
+ */
+export declare function scanGoSource(source: string, mod: string, symbols: Set<string>): number;

package/dist/tools/upgrade-impact-imports.js

@@ -0,0 +1,260 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Python and Go import sites for `upgrade_impact`.
+ *
+ * Go is exact: a file imports a module by its path (`"github.com/jackc/pgx/v5"`
+ * or a package below it), and the identifiers it reaches through the package
+ * name (`pgx.Connect`) are the symbols a changelog entry can name.
+ *
+ * Python is not: a file imports a MODULE (`import yaml`), while an upgrade names
+ * a DISTRIBUTION (`PyYAML`), and nothing in the source links the two. The
+ * mapping comes, in order of trust, from:
+ *   1. the installed distribution's own metadata in this project's virtualenv
+ *      (`*.dist-info/top_level.txt`, else the top-level names in `RECORD`);
+ *   2. a short table of well-known distributions whose import name differs
+ *      (beautifulsoup4 -> bs4, Pillow -> PIL, PyYAML -> yaml, ...);
+ *   3. the distribution name itself with `-` and `.` read as `_`, which is
+ *      right for most packages and is reported as an ASSUMPTION every time,
+ *      so a count of zero files is never mistaken for "not used".
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { normalizePypiName } from "../live/upgrade-pypi.js";
+import { goBasePath, goPathMajor } from "../live/upgrade-go.js";
+/**
+ * Distributions whose import name is not their normalised name. Each is the
+ * package's documented import (PyPI page or the project's own docs); a
+ * distribution that installs several top-level modules lists them all.
+ */
+const KNOWN_IMPORT_NAMES = {
+    "beautifulsoup4": ["bs4"],
+    "pillow": ["PIL"],
+    "pyyaml": ["yaml"],
+    "scikit-learn": ["sklearn"],
+    "scikit-image": ["skimage"],
+    "opencv-python": ["cv2"],
+    "opencv-python-headless": ["cv2"],
+    "opencv-contrib-python": ["cv2"],
+    "opencv-contrib-python-headless": ["cv2"],
+    "python-dateutil": ["dateutil"],
+    "pyjwt": ["jwt"],
+    "python-dotenv": ["dotenv"],
+    "protobuf": ["google.protobuf"],
+    "attrs": ["attr", "attrs"],
+    "psycopg2-binary": ["psycopg2"],
+    "mysqlclient": ["MySQLdb"],
+    "pyserial": ["serial"],
+    "pyopenssl": ["OpenSSL"],
+    "pycryptodome": ["Crypto"],
+    "pycryptodomex": ["Cryptodome"],
+    "setuptools": ["setuptools", "pkg_resources"],
+    "python-multipart": ["multipart", "python_multipart"],
+    "djangorestframework": ["rest_framework"],
+    "django-cors-headers": ["corsheaders"],
+    "python-jose": ["jose"],
+    "ruamel.yaml": ["ruamel.yaml"],
+    "grpcio": ["grpc"],
+    "google-api-python-client": ["googleapiclient"],
+    "pymupdf": ["fitz", "pymupdf"],
+    "python-docx": ["docx"],
+    "python-pptx": ["pptx"],
+    "websocket-client": ["websocket"],
+    "pyzmq": ["zmq"],
+    "faiss-cpu": ["faiss"],
+    "faiss-gpu": ["faiss"],
+    "discord.py": ["discord"],
+    "py-cpuinfo": ["cpuinfo"],
+    "pygobject": ["gi"],
+    "pycairo": ["cairo"],
+    "pyqt5": ["PyQt5"],
+    "pyqt6": ["PyQt6"],
+    "pyside6": ["PySide6"],
+    "python-ldap": ["ldap"],
+    "pyusb": ["usb"],
+    "msgpack-python": ["msgpack"],
+    "markdown-it-py": ["markdown_it"],
+    "typing-extensions": ["typing_extensions"],
+    "google-cloud-storage": ["google.cloud.storage"],
+    "google-cloud-bigquery": ["google.cloud.bigquery"],
+    "google-cloud-pubsub": ["google.cloud.pubsub", "google.cloud.pubsub_v1"],
+    "apache-airflow": ["airflow"],
+    "pywin32": ["win32api", "win32con", "win32com", "pythoncom", "pywintypes"],
+};
+const VENV_DIRS = [".venv", "venv", "env", ".env", "virtualenv"];
+/** site-packages directories of virtualenvs at the project root (POSIX and Windows layouts). */
+function sitePackagesDirs(root) {
+    const out = [];
+    for (const v of VENV_DIRS) {
+        const venv = path.join(root, v);
+        const win = path.join(venv, "Lib", "site-packages");
+        if (fs.existsSync(win))
+            out.push(win);
+        const lib = path.join(venv, "lib");
+        let entries = [];
+        try {
+            entries = fs.readdirSync(lib);
+        }
+        catch {
+            continue;
+        }
+        for (const py of entries) {
+            const sp = path.join(lib, py, "site-packages");
+            if (/^python\d/.test(py) && fs.existsSync(sp))
+                out.push(sp);
+        }
+    }
+    return out;
+}
+/** Top-level importable names a RECORD lists: `pkg/__init__.py` -> pkg, `mod.py` -> mod. */
+function namesFromRecord(record) {
+    const names = new Set();
+    for (const line of record.split(/\r?\n/)) {
+        const file = line.split(",")[0]?.trim();
+        if (!file || file.startsWith("..") || file.startsWith("/"))
+            continue;
+        const first = file.split("/")[0];
+        if (/\.(?:dist-info|egg-info|data)$/.test(first) || first === "__pycache__" || /\.pth$/.test(first))
+            continue;
+        if (file.includes("/")) {
+            if (/^[A-Za-z_]\w*$/.test(first))
+                names.add(first);
+        }
+        else {
+            const mod = /^([A-Za-z_]\w*)(?:\.[\w-]+)?\.(?:py|pyd|so)$/.exec(first)?.[1];
+            if (mod)
+                names.add(mod);
+        }
+    }
+    return [...names];
+}
+function readInstalledNames(root, dist) {
+    const want = normalizePypiName(dist);
+    for (const sp of sitePackagesDirs(root)) {
+        let entries;
+        try {
+            entries = fs.readdirSync(sp);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const m = /^(.+?)-[^-]+\.(?:dist-info|egg-info)$/.exec(entry);
+            if (!m || normalizePypiName(m[1]) !== want)
+                continue;
+            const meta = path.join(sp, entry);
+            const rel = path.relative(root, meta).split(path.sep).join("/");
+            for (const [file, read] of [
+                ["top_level.txt", (t) => t.split(/\r?\n/).map((l) => l.trim()).filter((l) => /^[A-Za-z_][\w.]*$/.test(l))],
+                ["RECORD", namesFromRecord],
+            ]) {
+                try {
+                    const names = read(fs.readFileSync(path.join(meta, file), "utf8"));
+                    if (names.length > 0)
+                        return { names: [...new Set(names)].sort(), source: "installed-metadata", evidence: `${rel}/${file}` };
+                }
+                catch {
+                    // no such file: try the next
+                }
+            }
+        }
+    }
+    return null;
+}
+/** The module name(s) a distribution is imported as, and how that was established. */
+export function pythonImportNames(root, dist) {
+    const installed = root ? readInstalledNames(root, dist) : null;
+    if (installed)
+        return installed;
+    const known = KNOWN_IMPORT_NAMES[normalizePypiName(dist)];
+    if (known)
+        return { names: known, source: "known-mapping" };
+    return { names: [normalizePypiName(dist).replace(/-/g, "_")], source: "assumed" };
+}
+/** True when module `mod` is `name` or inside it (`yaml.loader` for `yaml`). */
+const underModule = (mod, name) => mod === name || mod.startsWith(`${name}.`);
+/**
+ * Count imports of any of `names` in one Python file and collect the names it
+ * reaches: `from x import A, B` gives A and B; `import x` / `import x as y`
+ * gives the attributes used as `x.attr` / `y.attr`.
+ */
+export function scanPythonSource(source, names, symbols) {
+    let matches = 0;
+    const text = source.replace(/\\\r?\n/g, " ");
+    const bindings = [];
+    // `from x import (a, b,\n c)` and `from x import a, b as c`
+    const fromRe = /^[ \t]*from[ \t]+([\w.]+)[ \t]+import[ \t]+(\([^)]*\)|[^\n#]+)/gm;
+    for (const m of text.matchAll(fromRe)) {
+        if (!names.some((n) => underModule(m[1], n)))
+            continue;
+        matches++;
+        for (const part of m[2].replace(/[()]/g, "").split(",")) {
+            const name = part.trim().split(/\s+as\s+/)[0].trim();
+            if (/^[A-Za-z_]\w*$/.test(name))
+                symbols.add(name);
+        }
+    }
+    const importRe = /^[ \t]*import[ \t]+([^\n#]+)/gm;
+    for (const m of text.matchAll(importRe)) {
+        for (const part of m[1].split(",")) {
+            const [mod, alias] = part.trim().split(/\s+as\s+/).map((s) => s.trim());
+            if (!mod || !names.some((n) => underModule(mod, n)))
+                continue;
+            matches++;
+            bindings.push(alias ?? mod);
+        }
+    }
+    // Attribute uses outside the import statements themselves (`from yaml.loader import` names a module, not an attribute).
+    const body = text.replace(fromRe, "").replace(importRe, "");
+    for (const binding of bindings) {
+        const re = new RegExp(String.raw `(?<![\w.])${binding.replace(/\./g, "\\.")}\.([A-Za-z_]\w*)`, "g");
+        for (const m of body.matchAll(re))
+            symbols.add(m[1]);
+    }
+    return matches;
+}
+// ---------------------------------------------------------------- Go
+/** True when import path `imp` is module `mod` or a package inside it, not a different major (`mod/v2`). */
+export function goImportInModule(imp, mod) {
+    if (imp === mod)
+        return true;
+    if (!imp.startsWith(`${mod}/`))
+        return false;
+    const next = imp.slice(mod.length + 1).split("/")[0];
+    return !/^v\d+$/.test(next) || goPathMajor(mod) !== null;
+}
+/** The package name an import path is used through: its last element, skipping a `/vN` suffix and gopkg.in's `.vN`. */
+export function goPackageName(imp) {
+    const parts = goBasePath(imp).split("/");
+    const last = parts[parts.length - 1] ?? imp;
+    return last.replace(/\.v\d+$/, "").replace(/^go-/, "").replace(/[-.]/g, "_");
+}
+/**
+ * Count imports of a Go module (or packages inside it) in one file and collect
+ * the exported identifiers reached through each import's package name.
+ */
+export function scanGoSource(source, mod, symbols) {
+    const specs = [];
+    const spec = /^\s*(?:([A-Za-z_]\w*|\.|_)\s+)?"([^"]+)"/;
+    for (const m of source.matchAll(/^\s*import\s*\(([\s\S]*?)\)/gm)) {
+        for (const line of m[1].split("\n")) {
+            const s = spec.exec(line.replace(/\/\/.*$/, ""));
+            if (s)
+                specs.push({ alias: s[1] ?? null, path: s[2] });
+        }
+    }
+    for (const m of source.matchAll(/^\s*import\s+(?:([A-Za-z_]\w*|\.|_)\s+)?"([^"]+)"/gm)) {
+        specs.push({ alias: m[1] ?? null, path: m[2] });
+    }
+    let matches = 0;
+    for (const s of specs) {
+        if (!goImportInModule(s.path, mod))
+            continue;
+        matches++;
+        const local = s.alias ?? goPackageName(s.path);
+        if (local === "_" || local === ".")
+            continue;
+        for (const m of source.matchAll(new RegExp(String.raw `(?<![\w.])${local}\.([A-Z]\w*)`, "g")))
+            symbols.add(m[1]);
+    }
+    return matches;
+}

package/dist/tools/upgrade-impact-report.d.ts

@@ -85,6 +85,19 @@ export interface SummaryInput {
     /** missing = no changelog file; no_entries = a file with no section for these releases; partial = some of them. */
     changelog: "missing" | "no_entries" | "partial" | "complete";
     advisoriesFixed: number | null;
+    /** Versions as the ecosystem writes them (`v1.2.3`, `3.0rc1`); `from`/`to` are their semver reading. */
+    fromLabel?: string;
+    toLabel?: string;
+    /** Where the entries came from when not the archive ("GitHub release notes"). */
+    changelogFrom?: string | null;
+    /** How to get a changelog that is missing (the opt-in GitHub fallback), when it would help. */
+    githubHint?: string | null;
+    /** Go: the upgrade moves to another module path. */
+    pathChange?: {
+        from: string;
+        to: string;
+        files: number;
+    } | null;
 }
 /** The one sentence a human or agent reads first. */
 export declare function summarize(input: SummaryInput): string;

package/dist/tools/upgrade-impact-report.js

@@ -84,7 +84,10 @@ export function shapeChangelog(sections, symbols, format) {
         if (format === "concise") {
             const important = entries.filter((e) => e.kind !== "change");
             const others = entries.filter((e) => e.kind === "change");
-            const additive = (e) => (e.under ? classifyHeading(e.under) === "additive" : false);
+            const additive = (e) => {
+                const ctx = e.under ? classifyHeading(e.under) : null;
+                return ctx === "additive" || ctx === "fixes";
+            };
             const neutral = others.filter((e) => !additive(e)).slice(0, CONCISE_NEUTRAL_PER_VERSION);
             const minor = others.filter(additive).slice(0, CONCISE_ADDITIVE_PER_VERSION);
             // Keep document order among the kept plain changes.
@@ -186,10 +189,11 @@ export function summarize(input) {
     ].filter(Boolean);
     let breaking;
     const atLeast = input.changelog === "partial" ? "at least " : "";
+    const hint = input.githubHint ? `; ${input.githubHint}` : "";
     if (input.changelog === "missing")
-        breaking = "no changelog in the package archive (see release_notes_url)";
+        breaking = `no changelog in the package archive, so breaking changes are unknown (see release_notes_url${hint})`;
     else if (input.changelog === "no_entries") {
-        breaking = "the package's changelog has no entries for these releases, so breaking changes are unknown (see release_notes_url)";
+        breaking = `the package's changelog has no entries for these releases, so breaking changes are unknown (see release_notes_url${hint})`;
     }
     else {
         // "flagged", not "N breaking changes": the flags come from headings and
@@ -202,7 +206,12 @@ export function summarize(input) {
         }
         else
             breaking = flagged;
+        if (input.changelogFrom)
+            breaking += ` (from ${input.changelogFrom})`;
     }
     const advisories = input.advisoriesFixed === null ? "advisories unknown (OSV unreachable)" : `${input.advisoriesFixed} advisories fixed`;
-    return `${input.pkg} ${input.from} -> ${input.to}: ${parts.join(", ")}, ${breaking}, ${advisories}.`;
+    const path = input.pathChange
+        ? `, module path changes to ${input.pathChange.to} (${input.pathChange.files} ${input.pathChange.files === 1 ? "file imports" : "files import"} ${input.pathChange.from})`
+        : "";
+    return `${input.pkg} ${input.fromLabel ?? input.from} -> ${input.toLabel ?? input.to}: ${parts.join(", ")}${path}, ${breaking}, ${advisories}.`;
 }

package/dist/tools/upgrade-impact.d.ts

@@ -8,12 +8,19 @@
  * (breaking / deprecation / security), and cross-references the breaking
  * ones against the symbols this project actually imports from the package.
  *
- * Why the changelog comes from the archive and nowhere else: an agent asked
- * to bump fastembed 5 -> 7 otherwise reads GitHub release pages one by one, or
+ * Why the changelog comes from the archive first: an agent asked to bump
+ * fastembed 5 -> 7 otherwise reads GitHub release pages one by one, or
  * guesses from the version number. The archive is on the registry the
  * package manager already trusts, so reading it discloses nothing new
- * (Decision 1, option A). When the archive has no changelog the report says
- * so and gives `release_notes_url`; it never fetches that page itself.
+ * (Decision 1, option A). When the archive has no changelog for the range,
+ * GitHub release notes are read only if the user opted in
+ * (FOURDA_GITHUB_CHANGELOG, Decision 1 option B); otherwise the report says
+ * the changelog is unavailable, how to enable the fallback, and gives
+ * `release_notes_url`. It never fetches a docs page itself.
+ *
+ * Ecosystems: npm, crates.io, PyPI (PEP 440 versions, sdist changelogs,
+ * distribution -> import-name mapping) and Go (module proxy, module-zip
+ * changelogs, major versions as separate module paths).
  *
  * Changelog text is third-party input: entries are sanitised (control and
  * bidi characters stripped, 400-char cap) and `_meta.untrusted_text` tells
@@ -46,6 +53,8 @@ export interface UpgradeImpactContext {
     projectRoot: string | null;
     installed: InstalledDep[];
     offline: boolean;
+    /** FOURDA_GITHUB_CHANGELOG: read GitHub release notes when the archive has none (opt-in, default off). */
+    githubChangelog?: boolean;
 }
 export declare const upgradeImpactTool: {
     name: string;