@agentproto/catalog-sync 0.5.6 → 0.5.9

package/README.md

@@ -49,6 +49,76 @@ pnpm --filter @agentproto/catalog-sync generate --check  # diff vs committed; ex
 pnpm --filter @agentproto/catalog-sync generate --refresh  # re-fetch pinned sources
 ```
 
+## `addedAt` convention
+
+Some generators (currently `llm:openrouter` and `llm:requesty` — the two
+producing `LLMPricing` entries) stamp an `addedAt?: string` field (ISO
+`YYYY-MM-DD`) on each catalog entry: the date that model id was first seen
+by a sync run.
+
+- **Backfill rule.** When the provider source itself carries a creation
+  timestamp for the id (OpenRouter's and Requesty's `/v1/models` both carry
+  a Unix-seconds `created` field), a brand-new id is backfilled with that
+  date, converted to `YYYY-MM-DD`. When the source has no such field, the
+  id is stamped with the sync run's own date instead.
+- **Never-mutated invariant.** Once an id has an `addedAt` stamp, it is
+  never overwritten by a later run — not even if the source's own `created`
+  value for that id later resolves to something different. A model id
+  disappearing and later reappearing keeps its ORIGINAL stamp rather than
+  looking newly added.
+- **Mechanism: a per-generator ledger file**, committed at
+  `packages/catalog-sync/ledger/<generator-id>.json` (e.g.
+  `ledger/llm-openrouter.json`) — a flat `{ "model/id": "YYYY-MM-DD", ... }`
+  map, sorted keys, deterministic serialization. Each generator reads its
+  own ledger directly off disk (a plain `node:fs` read — `GeneratorContext`
+  intentionally has no general repo-read capability; the ledger is a
+  generator-internal concern, not part of the frozen `types.ts` contract),
+  merges in the current run's ids via `computeAddedAtLedger` (see
+  `src/added-at.ts`), and returns the updated ledger as a second entry in
+  its `GeneratedFiles` — so `runner.ts`'s existing diff/write logic (and
+  `--check`'s drift detection) covers the ledger file for free, same as any
+  other generated file.
+- Ledger entries are **never dropped**, even for ids no longer present in a
+  run — the ledger records "first ever seen", not "currently present".
+
+See `src/added-at.ts` for the implementation and `src/generators/llm-openrouter.ts` /
+`src/generators/llm-requesty.ts` for how a generator wires it in.
+
+## `CATALOG-CHANGELOG.md`
+
+`packages/model-catalog/CATALOG-CHANGELOG.md` is a human-readable "what
+models changed" log — NOT the changesets-driven `CHANGELOG.md` next to it
+(that one is package-version history, one entry per publish). It answers
+"what did catalog-sync add or remove, and when" by reading top to bottom.
+
+- **Written automatically** by `runGenerators` (`src/runner.ts`), not by
+  hand. After collecting every generator's output, the runner diffs each
+  changed `*.generated.ts` file's top-level id keys (before vs after —
+  see `src/changelog.ts`'s `extractRecordIds` / `diffModelIds`) and, when at
+  least one generator actually added or removed a model id, appends one
+  dated section:
+
+  ```
+  ## 2026-08-31
+
+  ### llm:requesty
+  - Added: alibaba/qwen3.8-flash, alibaba/qwen3.8-max, ...
+  - Removed: anthropic/claude-opus-4-1, ...
+  ```
+
+- **Sections are appended at the END of the file (newest last)** — a plain,
+  non-destructive `+=`. This is a deliberate choice over "newest first";
+  it means the writer never has to parse and re-emit prior history, only
+  concatenate.
+- **A run with no id-level drift emits nothing** — no empty section, no
+  touched file, no diff. Pricing-only changes (a model's price moved but no
+  id was added/removed) are NOT logged here; they're visible in the
+  generated file's own git history.
+- addedAt ledger files (`ledger/*.json`) are deliberately excluded from this
+  diff — they never lose an id (see above), so they carry no "removed"
+  signal, and every "added" id they'd report is already covered by the
+  owning generator's own `*.generated.ts` diff.
+
 ## Generators
 
 ### `llm:openrouter`
@@ -66,6 +136,8 @@ Source: `https://openrouter.ai/api/v1/models` (pinned snapshot:
   (P3 spec: "plus cache fields if the source has them") — additive and
   `LLMPricing`-compatible.
 - Unpriced routes (`openrouter/auto`) are skipped.
+- `addedAt` (ISO date, first-seen, never mutated) is stamped per id via the
+  `ledger/llm-openrouter.json` ledger — see "`addedAt` convention" above.
 
 ### `llm:requesty`
 
@@ -81,6 +153,8 @@ Source: `https://router.requesty.ai/v1/models` (pinned snapshot:
   `cacheWriteMultiplier` is never emitted.
 - Live refresh requires `REQUESTY_API_KEY` to be set; without it the generator
   reuses the committed snapshot.
+- `addedAt` (ISO date, first-seen, never mutated) is stamped per id via the
+  `ledger/llm-requesty.json` ledger — see "`addedAt` convention" above.
 
 ### `llm:context-windows`
 

package/dist/bin.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { z } from 'zod';
-import { ElevenLabsVoicesSnapshotSchema, mapElevenLabsVoices, MinimaxVoicesSnapshotSchema, mapMinimaxVoices } from '@agentproto/model-catalog/providers';
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { ElevenLabsVoicesSnapshotSchema, mapElevenLabsVoices, MinimaxVoicesSnapshotSchema, mapMinimaxVoices } from '@agentproto/model-catalog/providers';
 
 /**
  * @agentproto/catalog-sync v0.1.0
@@ -16,6 +16,47 @@ import { fileURLToPath } from 'url';
 function defineGenerator(g) {
   return g;
 }
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+function catalogSyncDir() {
+  return resolve(__dirname$1, "..");
+}
+function ledgerAbsPath(ledgerId) {
+  return join(catalogSyncDir(), "ledger", `${ledgerId}.json`);
+}
+function ledgerRelPath(ledgerId) {
+  return `packages/catalog-sync/ledger/${ledgerId}.json`;
+}
+function readLedger(ledgerId) {
+  const path = ledgerAbsPath(ledgerId);
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function serializeLedger(ledger) {
+  const sorted = {};
+  for (const id of Object.keys(ledger).sort()) sorted[id] = ledger[id];
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+function computeAddedAtLedger(currentIds, previous, createdAt, today) {
+  const next = { ...previous };
+  for (const id of currentIds) {
+    if (next[id] !== void 0) continue;
+    next[id] = createdAt[id] ?? today;
+  }
+  return next;
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function isoDateFromUnixSeconds(seconds) {
+  return new Date(seconds * 1e3).toISOString().slice(0, 10);
+}
 
 // src/generators/llm-openrouter.ts
 var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
@@ -28,7 +69,8 @@ var PricingSchema = z.object({
 }).passthrough();
 var ModelSchema = z.object({
   id: z.string(),
-  pricing: PricingSchema.optional()
+  pricing: PricingSchema.optional(),
+  created: z.number().optional()
 }).passthrough();
 var SnapshotSchema = z.object({
   data: z.array(ModelSchema)
@@ -61,6 +103,9 @@ function serializeEntry(e) {
   if (e.cacheWriteMultiplier !== void 0) {
     fields.push(`cacheWriteMultiplier: ${fmt(e.cacheWriteMultiplier)}`);
   }
+  if (e.addedAt !== void 0) {
+    fields.push(`addedAt: ${JSON.stringify(e.addedAt)}`);
+  }
   fields.push(`vendor: ${JSON.stringify(e.vendor)}`);
   fields.push(`provider: ${JSON.stringify(e.provider)}`);
   return `{
@@ -77,6 +122,9 @@ function serializeFile(entries) {
     "// Pricing carries provider USD (inputPer1M / outputPer1M) plus cache",
     "// multipliers (cacheReadMultiplier / cacheWriteMultiplier) derived from the",
     "// source's input_cache_read / input_cache_write per-token fields when present.",
+    "// addedAt is the ISO date this id was first seen by a sync run \u2014 backfilled",
+    "// from the source's own `created` timestamp, then NEVER mutated; see",
+    "// packages/catalog-sync/src/added-at.ts and the package README.",
     "",
     'import type { LLMPricing } from "./catalog.js"',
     "",
@@ -96,11 +144,13 @@ function serializeFile(entries) {
   lines.push("");
   return lines.join("\n");
 }
+var LEDGER_ID = "llm-openrouter";
 async function generate(ctx) {
   const src = sources[0];
   if (!src) throw new Error("llm:openrouter: no source configured");
   const parsed = SnapshotSchema.parse(await ctx.fetchSource(src));
   const entries = {};
+  const createdAt = {};
   for (const model of parsed.data) {
     const pricing = model.pricing;
     if (!pricing) continue;
@@ -123,8 +173,19 @@ async function generate(ctx) {
       entry.cacheWriteMultiplier = round6(cacheWritePer1M / inputPer1M);
     }
     entries[model.id] = entry;
+    if (model.created !== void 0) createdAt[model.id] = isoDateFromUnixSeconds(model.created);
   }
-  return { [OUTPUT_PATH]: serializeFile(entries) };
+  const ledger = computeAddedAtLedger(
+    Object.keys(entries),
+    readLedger(LEDGER_ID),
+    createdAt,
+    todayIso()
+  );
+  for (const [id, entry] of Object.entries(entries)) entry.addedAt = ledger[id];
+  return {
+    [OUTPUT_PATH]: serializeFile(entries),
+    [ledgerRelPath(LEDGER_ID)]: serializeLedger(ledger)
+  };
 }
 var sources = [{ id: "llm-openrouter", url: OPENROUTER_MODELS_URL }];
 var llmOpenRouterGenerator = defineGenerator({
@@ -140,7 +201,8 @@ var ModelSchema2 = z.object({
   input_price: z.number().optional(),
   output_price: z.number().optional(),
   cached_price: z.number().optional(),
-  supports_caching: z.boolean().optional()
+  supports_caching: z.boolean().optional(),
+  created: z.number().optional()
 }).passthrough();
 var SnapshotSchema2 = z.object({
   data: z.array(ModelSchema2)
@@ -169,6 +231,9 @@ function serializeEntry2(e) {
   if (e.cacheReadMultiplier !== void 0) {
     fields.push(`cacheReadMultiplier: ${fmt2(e.cacheReadMultiplier)}`);
   }
+  if (e.addedAt !== void 0) {
+    fields.push(`addedAt: ${JSON.stringify(e.addedAt)}`);
+  }
   fields.push(`vendor: ${JSON.stringify(e.vendor)}`);
   fields.push(`provider: ${JSON.stringify(e.provider)}`);
   return `{
@@ -186,6 +251,9 @@ function serializeFile2(entries) {
     "// multiplier (cacheReadMultiplier) derived from the source's cached_price",
     "// per-token field when `supports_caching` is true. Requesty has no",
     "// cache-write price, so cacheWriteMultiplier is never emitted.",
+    "// addedAt is the ISO date this id was first seen by a sync run \u2014 backfilled",
+    "// from the source's own `created` timestamp, then NEVER mutated; see",
+    "// packages/catalog-sync/src/added-at.ts and the package README.",
     "",
     'import type { LLMPricing } from "./catalog.js"',
     "",
@@ -205,11 +273,13 @@ function serializeFile2(entries) {
   lines.push("");
   return lines.join("\n");
 }
+var LEDGER_ID2 = "llm-requesty";
 async function generate2(ctx) {
   const src = sources2[0];
   if (!src) throw new Error("llm:requesty: no source configured");
   const parsed = SnapshotSchema2.parse(await ctx.fetchSource(src));
   const entries = {};
+  const createdAt = {};
   for (const model of parsed.data) {
     const inputPer1M = per1m2(model.input_price);
     const outputPer1M = per1m2(model.output_price);
@@ -228,8 +298,19 @@ async function generate2(ctx) {
       }
     }
     entries[model.id] = entry;
+    if (model.created !== void 0) createdAt[model.id] = isoDateFromUnixSeconds(model.created);
   }
-  return { [OUTPUT_PATH2]: serializeFile2(entries) };
+  const ledger = computeAddedAtLedger(
+    Object.keys(entries),
+    readLedger(LEDGER_ID2),
+    createdAt,
+    todayIso()
+  );
+  for (const [id, entry] of Object.entries(entries)) entry.addedAt = ledger[id];
+  return {
+    [OUTPUT_PATH2]: serializeFile2(entries),
+    [ledgerRelPath(LEDGER_ID2)]: serializeLedger(ledger)
+  };
 }
 var sources2 = [
   {
@@ -373,6 +454,19 @@ var llmHuggingfaceGenerator = defineGenerator({
   sources: sources3,
   generate: generate3
 });
+
+// src/generators/google-native-model-ids.mjs
+var GOOGLE_NATIVE_MODEL_IDS = /* @__PURE__ */ new Set([
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite",
+  "gemini-3.5-flash",
+  "gemini-3.1-pro-preview",
+  "gemini-3-flash-preview",
+  "gemini-3.1-flash-lite"
+]);
+
+// src/generators/llm-context-windows.ts
 var OUTPUT_PATH4 = "packages/model-catalog/src/llm/context-windows.generated.ts";
 var AnthropicModelSchema = z.object({
   id: z.string(),
@@ -397,6 +491,17 @@ var MoonshotModelSchema = z.object({
   context_length: z.number().optional()
 }).passthrough();
 var MoonshotSnapshotSchema = z.object({ data: z.array(MoonshotModelSchema) });
+var MistralModelSchema = z.object({
+  id: z.string(),
+  max_context_length: z.number().optional()
+}).passthrough();
+var MistralSnapshotSchema = z.object({ data: z.array(MistralModelSchema) });
+var OpenRouterModelSchema = z.object({
+  id: z.string(),
+  context_length: z.number().nullable().optional(),
+  top_provider: z.object({ max_completion_tokens: z.number().nullable().optional() }).passthrough().optional()
+}).passthrough();
+var OpenRouterSnapshotSchema = z.object({ data: z.array(OpenRouterModelSchema) });
 function serializeEntry4(e) {
   const fields = [`contextWindow: ${e.contextWindow}`];
   if (e.maxOutput !== void 0) fields.push(`maxOutput: ${e.maxOutput}`);
@@ -410,7 +515,12 @@ function serializeFile4(entries) {
     "// AUTO-GENERATED by @agentproto/catalog-sync (llm:context-windows).",
     "// Do not edit by hand \u2014 re-run `pnpm --filter @agentproto/catalog-sync generate --refresh`.",
     "// Sources: api.anthropic.com/v1/models, api.groq.com/openai/v1/models,",
-    "//         api.x.ai/v1/models, api.moonshot.ai/v1/models",
+    "//         api.x.ai/v1/models, api.moonshot.ai/v1/models,",
+    "//         api.mistral.ai/v1/models",
+    "// google entries: SOURCED FROM OPENROUTER (openrouter.ai/api/v1/models),",
+    "//         Google's native API is billing-blocked \u2014 ids remapped from",
+    "//         google/<id> to the bare native id; see the generator's module",
+    "//         doc comment for the exact remap + skip rules.",
     "// Context window (max input tokens) + max output tokens per live model id.",
     "// NOT pricing \u2014 see LLM_PRICING_CATALOG / OPENROUTER_ROUTES in catalog.ts.",
     "",
@@ -418,7 +528,7 @@ function serializeFile4(entries) {
     "  contextWindow: number",
     "  maxOutput?: number",
     "  displayName?: string",
-    '  provider: "anthropic" | "groq" | "xai" | "moonshot"',
+    '  provider: "anthropic" | "groq" | "xai" | "moonshot" | "mistral" | "google"',
     "}",
     "",
     "export const CONTEXT_WINDOWS: Record<string, ContextWindowEntry> = {"
@@ -444,6 +554,13 @@ async function generate4(ctx) {
         provider: "anthropic"
       };
     }
+    for (const [id, entry] of Object.entries(entries)) {
+      if (entry.provider !== "anthropic") continue;
+      const bare = id.replace(/-\d{8}$/, "");
+      if (bare === id) continue;
+      if (bare in entries) continue;
+      entries[bare] = { ...entry };
+    }
   }
   const groqSrc = sources4.find((s) => s.id === "llm-groq");
   if (groqSrc) {
@@ -473,6 +590,40 @@ async function generate4(ctx) {
       entries[m.id] = { contextWindow: m.context_length, provider: "moonshot" };
     }
   }
+  const mistralSrc = sources4.find((s) => s.id === "llm-mistral");
+  if (mistralSrc) {
+    const parsed = MistralSnapshotSchema.parse(await ctx.fetchSource(mistralSrc));
+    for (const m of parsed.data) {
+      if (!m.max_context_length) continue;
+      entries[m.id] = { contextWindow: m.max_context_length, provider: "mistral" };
+    }
+  }
+  const googleSrc = sources4.find((s) => s.id === "llm-openrouter");
+  if (googleSrc) {
+    const parsed = OpenRouterSnapshotSchema.parse(await ctx.fetchSource(googleSrc));
+    for (const m of parsed.data) {
+      if (!m.id.startsWith("google/")) continue;
+      const nativeId = m.id.slice("google/".length);
+      if (m.id.includes(":")) {
+        console.error(
+          `llm:context-windows: skipping "${m.id}" \u2014 ":"-suffixed batch route, not the same billing surface as the base model.`
+        );
+        continue;
+      }
+      if (!GOOGLE_NATIVE_MODEL_IDS.has(nativeId)) {
+        console.error(
+          `llm:context-windows: skipping "${m.id}" \u2014 no confirmed native Gemini id "${nativeId}" (see GOOGLE_NATIVE_MODEL_IDS); not guessing the remap.`
+        );
+        continue;
+      }
+      if (!m.context_length) continue;
+      entries[nativeId] = {
+        contextWindow: m.context_length,
+        ...m.top_provider?.max_completion_tokens ? { maxOutput: m.top_provider.max_completion_tokens } : {},
+        provider: "google"
+      };
+    }
+  }
   return { [OUTPUT_PATH4]: serializeFile4(entries) };
 }
 var sources4 = [
@@ -498,6 +649,18 @@ var sources4 = [
     id: "llm-moonshot",
     url: "https://api.moonshot.ai/v1/models",
     headers: { Authorization: "Bearer env:MOONSHOT_API_KEY" }
+  },
+  {
+    id: "llm-mistral",
+    url: "https://api.mistral.ai/v1/models",
+    headers: { Authorization: "Bearer env:MISTRAL_API_KEY" }
+  },
+  // Google via OpenRouter (no Google key needed — see module doc comment).
+  // Same source id/url as `llm-openrouter.ts`'s own generator, so both share
+  // the one pinned `snapshots/llm-openrouter.json` instead of fetching twice.
+  {
+    id: "llm-openrouter",
+    url: "https://openrouter.ai/api/v1/models"
   }
 ];
 var llmContextWindowsGenerator = defineGenerator({
@@ -879,22 +1042,70 @@ var imageReplicate = defineGenerator({
     return { [outputPath]: lines.join("\n") };
   }
 });
-var __dirname$1 = dirname(fileURLToPath(import.meta.url));
-function catalogSyncDir() {
-  return resolve(__dirname$1, "..");
+
+// src/changelog.ts
+var RECORD_KEY_RE = /^ {2}"([^"]+)":\s*\{/gm;
+function extractRecordIds(source) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const m of source.matchAll(RECORD_KEY_RE)) {
+    if (m[1] !== void 0) ids.add(m[1]);
+  }
+  return ids;
+}
+function diffModelIds(before, after) {
+  const beforeIds = before !== void 0 ? extractRecordIds(before) : /* @__PURE__ */ new Set();
+  const afterIds = extractRecordIds(after);
+  const added = [...afterIds].filter((id) => !beforeIds.has(id)).sort();
+  const removed = [...beforeIds].filter((id) => !afterIds.has(id)).sort();
+  return { added, removed };
+}
+function renderChangelogSection(date, entries) {
+  const nonEmpty = entries.filter((e) => e.added.length > 0 || e.removed.length > 0);
+  if (nonEmpty.length === 0) return "";
+  const lines = [`## ${date}`, ""];
+  for (const e of nonEmpty) {
+    lines.push(`### ${e.generator}`);
+    if (e.added.length > 0) lines.push(`- Added: ${e.added.join(", ")}`);
+    if (e.removed.length > 0) lines.push(`- Removed: ${e.removed.join(", ")}`);
+    lines.push("");
+  }
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+var CATALOG_CHANGELOG_HEADER = `# Catalog Changelog
+
+Human-readable log of model additions/removals detected by
+\`@agentproto/catalog-sync\` runs \u2014 NOT \`CHANGELOG.md\` next to it (that one is
+changesets-driven package-version history). A dated section is appended
+automatically here whenever a sync run adds or removes model ids; sections
+are appended at the END of the file (newest last). Pricing-only drift (no id
+added/removed) is not logged here \u2014 see the generated files' own git history
+for that.
+`;
+function appendChangelog(existing, date, entries) {
+  const section = renderChangelogSection(date, entries);
+  if (section === "") return void 0;
+  const base = existing !== void 0 && existing.length > 0 ? existing.replace(/\n+$/, "\n") : CATALOG_CHANGELOG_HEADER;
+  return `${base}
+${section}`;
+}
+
+// src/runner.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+function catalogSyncDir2() {
+  return resolve(__dirname2, "..");
 }
 function snapshotPath(id) {
-  return join(catalogSyncDir(), "snapshots", `${id}.json`);
+  return join(catalogSyncDir2(), "snapshots", `${id}.json`);
 }
 function repoRoot() {
-  let dir = catalogSyncDir();
+  let dir = catalogSyncDir2();
   for (let i = 0; i < 12; i++) {
     if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return dirname(dirname(catalogSyncDir()));
+  return dirname(dirname(catalogSyncDir2()));
 }
 function readIfExists(absPath) {
   if (!existsSync(absPath)) return void 0;
@@ -916,8 +1127,13 @@ function resolveHeaders(headers) {
   }
   return { headers: out, missing };
 }
+var CATALOG_CHANGELOG_PATH = "packages/model-catalog/CATALOG-CHANGELOG.md";
+function isChangelogEligible(relPath) {
+  return relPath.endsWith(".generated.ts");
+}
 async function runGenerators(gens, opts) {
   const files2 = {};
+  const pathToGenerator = {};
   for (const gen of gens) {
     const ctx = {
       refresh: opts.refresh,
@@ -964,10 +1180,12 @@ async function runGenerators(gens, opts) {
     const out = await gen.generate(ctx);
     for (const [path, content] of Object.entries(out)) {
       files2[path] = content;
+      pathToGenerator[path] = gen.name;
     }
   }
   const root = repoRoot();
   const changed2 = [];
+  const changelogEntries = [];
   for (const [relPath, content] of Object.entries(files2)) {
     const abs = join(root, relPath);
     const existing = readIfExists(abs);
@@ -978,6 +1196,23 @@ async function runGenerators(gens, opts) {
         writeFileSync(abs, content, "utf8");
       }
     }
+    if (isChangelogEligible(relPath)) {
+      const { added, removed } = diffModelIds(existing, content);
+      if (added.length > 0 || removed.length > 0) {
+        changelogEntries.push({ generator: pathToGenerator[relPath] ?? relPath, added, removed });
+      }
+    }
+  }
+  const changelogAbs = join(root, CATALOG_CHANGELOG_PATH);
+  const changelogExisting = readIfExists(changelogAbs);
+  const newChangelog = appendChangelog(changelogExisting, todayIso(), changelogEntries);
+  if (newChangelog !== void 0) {
+    files2[CATALOG_CHANGELOG_PATH] = newChangelog;
+    changed2.push(CATALOG_CHANGELOG_PATH);
+    if (opts.write) {
+      mkdirSync(dirname(changelogAbs), { recursive: true });
+      writeFileSync(changelogAbs, newChangelog, "utf8");
+    }
   }
   return { files: files2, changed: changed2 };
 }