@witchpot/gmc 0.8.0 → 0.9.0

package/src/requests.test.js

@@ -4,6 +4,7 @@ import test from "node:test";
 import { parseArgs } from "./args.js";
 import { buildRequest } from "./requests.js";
 import { printHelp } from "./help.js";
+import { PROVISIONAL_BETA_COMMANDS } from "./constants.js";
 
 function buildRequestFromArgv(argv) {
   const { command, options, positional } = parseArgs(argv);
@@ -402,6 +403,117 @@ test("games more-like-this forwards an explicit country, normalized", () => {
   assert.deepEqual(request.query, { country: "jp" });
 });
 
+// --- gmc games ai-disclosure (NAK-804) ------------------------------------
+//
+// A different route shape from every other `games` sub-path tested above:
+// there is no --source flag (the endpoint is keyed on the plain numeric
+// appid, not a --source-qualified externalId) and no query parameters at
+// all, the review-history sibling's shape.
+
+test("games ai-disclosure targets the canonical route", () => {
+  const request = buildRequestFromArgv(["games", "ai-disclosure", "730", "--json"]);
+
+  assert.equal(request.path, "/api/v1/games/730/ai-disclosure");
+  assert.deepEqual(request.query, {});
+});
+
+test("games ai-disclosure rejects a missing appid", () => {
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "ai-disclosure", "--json"])
+  );
+
+  assert.equal(exitCode, 2);
+  assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  assert.match(output.error.message, /gmc games ai-disclosure <appid> --json/);
+});
+
+/**
+ * The appid is a plain positive decimal integer, matching the strict
+ * path-parameter check the app applies to every `/api/v1/.../games/{appid}`
+ * route. Each rejected spelling is asserted individually: a string like
+ * "7e2" or "0x2da" round-trips through `Number()` into a valid-looking
+ * integer, so a looser check here would let a value through that the API
+ * answers 400 for.
+ */
+test("games ai-disclosure rejects non-numeric and malformed appid spellings", () => {
+  for (const badAppid of ["not-an-appid", "7e2", "0x2da", "730.5", "-730", "0", " 730", "730 "]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "ai-disclosure", badAppid, "--json"])
+    );
+
+    assert.equal(exitCode, 2, `expected "${badAppid}" to be rejected`);
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+    assert.match(output.error.message, /Missing or invalid appid/);
+  }
+});
+
+test("games ai-disclosure rejects request-shaping flags the endpoint does not have", () => {
+  for (const [flag, value] of [
+    ["--source", "steam"],
+    ["--locale", "ja"],
+    ["--limit", "50"]
+  ]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "ai-disclosure", "730", flag, value, "--json"])
+    );
+
+    assert.equal(exitCode, 2, `expected ${flag} to be rejected`);
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+    assert.match(
+      output.error.message,
+      new RegExp(`\\${flag} is not supported by gmc games ai-disclosure`)
+    );
+  }
+});
+
+/**
+ * Output shaping never reaches the wire, so it must not trip the allowlist.
+ */
+test("games ai-disclosure still accepts the global output flags", () => {
+  const request = buildRequestFromArgv(["games", "ai-disclosure", "730", "--fields", "state", "--json"]);
+
+  assert.equal(request.path, "/api/v1/games/730/ai-disclosure");
+  assert.deepEqual(request.query, {});
+});
+
+test("games ai-disclosure rejects an extra positional argument", () => {
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "ai-disclosure", "730", "440", "--json"])
+  );
+
+  assert.equal(exitCode, 2);
+  assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  assert.match(output.error.message, /Unexpected extra argument "440"/);
+});
+
+test("help documents gmc games ai-disclosure (NAK-804)", () => {
+  const chunks = [];
+  const original = process.stdout.write;
+  process.stdout.write = (chunk) => {
+    chunks.push(String(chunk));
+    return true;
+  };
+  try {
+    printHelp();
+  } finally {
+    process.stdout.write = original;
+  }
+  const help = chunks.join("");
+
+  assert.ok(help.includes("gmc games ai-disclosure <appid> --json"));
+  assert.ok(help.includes("never that the title\n  uses no generative AI"));
+});
+
+test("games ai-disclosure is listed as Provisional (NAK-804)", () => {
+  // CHANGELOG, api.md and cli-use-cases.md all state that this command is
+  // Provisional in the beta command set. The help-output substring check
+  // above cannot pin this: "gmc games ai-disclosure <appid> --json" also
+  // appears verbatim in the Usage section on its own, so deleting this entry
+  // from PROVISIONAL_BETA_COMMANDS would leave every existing test green
+  // while the docs and reality diverge silently.
+  assert.ok(PROVISIONAL_BETA_COMMANDS.includes("gmc games ai-disclosure <appid> --json"));
+});
+
 // --- gmc games language-topics (NAK-455) ---------------------------------
 
 test("games language-topics targets the canonical route and sends no invented parameters", () => {
@@ -480,7 +592,7 @@ test("games language-topics rejects an out-of-range min_reviews before any reque
 /**
  * `Number("1e2")` and `Number("0x64")` are both 100, so a `Number`-based bounds
  * check would forward these spellings to an endpoint that rejects them:
- * `parseIntParam` (src/server/gmc/api/validation.ts) tests `/^-?\d+$/` and
+ * `parseIntParam` (in the app's API validation module) tests `/^-?\d+$/` and
  * answers 400 `min_reviews must be an integer`. The CLI must not turn a string
  * the API refuses into a successful request.
  */
@@ -921,8 +1033,8 @@ test("(NAK-587) an omitted --catalog-as-of leaves the query untouched", () => {
  * NAK-773. `--ai-disclosure` reaches games search/count/aggregate through the
  * SAME shared query builder as every other filter, and is forwarded verbatim
  * (kebab-case flag to camelCase query param) as the three literal values the
- * server matches case-sensitively (assertAiDisclosureFilterValue,
- * src/server/gmc/repositories/ai-disclosure.ts) -- the CLI does not
+ * server matches case-sensitively (assertAiDisclosureFilterValue, in the
+ * app's AI-disclosure repository module) -- the CLI does not
  * lower-case or trim a typo into a value the caller did not send.
  */
 test("(NAK-773) games search/count/aggregate forward --ai-disclosure as the aiDisclosure query param", () => {
@@ -1022,6 +1134,89 @@ test("(NAK-773) --ai-disclosure composes with the release_month,ai_disclosure cr
   assert.equal(request.query.aiDisclosure, "unconfirmed");
 });
 
+/**
+ * NAK-803. `--release-status` closes the CLI/REST divergence the
+ * AI-disclosure chart-ready recipe documented: `releaseStatus` was reachable
+ * on the REST endpoint but had no CLI mapping, so the CLI variant of a
+ * "released games only" question had to rely on the release window alone.
+ * The three values are the closed set the server enforces
+ * (RELEASE_STATUS_FILTER_VALUES in the app's games repository module, and
+ * the same literal triple the market RPCs re-check), so the CLI rejects
+ * anything outside it locally rather than normalizing a typo into a value
+ * the caller did not send.
+ */
+test("(NAK-803) games search/count/aggregate forward --release-status as the releaseStatus query param", () => {
+  const search = buildRequestFromArgv([
+    "games", "search", "--source", "steam", "--release-status", "released", "--json"
+  ]);
+  assert.equal(search.query.releaseStatus, "released");
+
+  const count = buildRequestFromArgv([
+    "games", "count", "--source", "steam", "--release-status", "upcoming", "--json"
+  ]);
+  assert.equal(count.query.releaseStatus, "upcoming");
+
+  const aggregate = buildRequestFromArgv([
+    "games", "aggregate", "--source", "steam", "--metric", "count",
+    "--release-status", "tba", "--json"
+  ]);
+  assert.equal(aggregate.query.releaseStatus, "tba");
+});
+
+test("(NAK-803) --release-status accepts each of the three enum values", () => {
+  for (const value of ["released", "upcoming", "tba"]) {
+    const request = buildRequestFromArgv(["games", "count", "--source", "steam", "--release-status", value, "--json"]);
+    assert.equal(request.query.releaseStatus, value);
+  }
+});
+
+test("(NAK-803) --release-status composes with the other filters instead of replacing them", () => {
+  const request = buildRequestFromArgv([
+    "games", "count", "--source", "steam",
+    "--release-status", "released",
+    "--ai-disclosure", "disclosed",
+    "--tags", "roguelite",
+    "--rating-min", "80",
+    "--json"
+  ]);
+  assert.equal(request.query.releaseStatus, "released");
+  assert.equal(request.query.aiDisclosure, "disclosed");
+  assert.equal(request.query.tags, "roguelite");
+  assert.equal(request.query.ratingMin, "80");
+});
+
+test("(NAK-803) an invalid --release-status value is a usage error, not a silently unfiltered request", () => {
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "count", "--source", "steam", "--release-status", "launched", "--json"])
+  );
+  assert.equal(exitCode, 2);
+  assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  assert.match(output.error.message, /--release-status must be one of: released, upcoming, tba/);
+});
+
+test("(NAK-803) --release-status is case-sensitive: a differently-cased value is rejected, not normalized", () => {
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "count", "--source", "steam", "--release-status", "Released", "--json"])
+  );
+  assert.equal(exitCode, 2);
+  assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  assert.match(output.error.message, /--release-status must be one of: released, upcoming, tba/);
+});
+
+test("(NAK-803) a blank --release-status is a usage error, not a silently unfiltered request", () => {
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "count", "--source", "steam", "--release-status", "   ", "--json"])
+  );
+  assert.equal(exitCode, 2);
+  assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  assert.match(output.error.message, /--release-status must be one of: released, upcoming, tba/);
+});
+
+test("(NAK-803) an omitted --release-status leaves the query untouched", () => {
+  const request = buildRequestFromArgv(["games", "count", "--source", "steam", "--json"]);
+  assert.equal("releaseStatus" in request.query, false);
+});
+
 /**
  * NAK-706: `gmc steam tag-trends`.
  *

package/scripts/check-release-readiness.mjs

@@ -1,177 +0,0 @@
-#!/usr/bin/env node
-
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-
-const packageDir = path.resolve(new URL("..", import.meta.url).pathname);
-const packageJsonPath = path.join(packageDir, "package.json");
-const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-
-const requiredFiles = [
-  "bin/gmc.mjs",
-  "src/index.js",
-  "src/main.js",
-  "src/requests.js",
-  "src/workflows.js",
-  "skill/gmc-analysis/SKILL.md",
-  "skill/gmc-analysis/references/recipes.md",
-  "skill/gmc-analysis/references/pitfalls.md",
-  "skill/gmc-analysis/references/validity.md",
-  "skill/gmc-analysis/references/quota.md",
-  "skill/gmc-analysis/references/charts.md",
-  "skill/gmc-analysis/CHANGELOG.md",
-  "README.md",
-  "CHANGELOG.md"
-];
-
-const requiredFileGlobs = ["bin", "src", "scripts", "skill", "README.md", "CHANGELOG.md"];
-const forbiddenPatterns = [
-  { pattern: /@supabase\//, message: "CLI package must not import Supabase SDKs." },
-  { pattern: /@clerk\//, message: "CLI package must not import Clerk SDKs." },
-  { pattern: /src\/server|server\/gmc|server-only/, message: "CLI package must not import server-only app code." },
-  { pattern: /SUPABASE_[A-Z0-9_]*|CLERK_[A-Z0-9_]*|STRIPE_[A-Z0-9_]*/, message: "CLI package must not reference server secret environment variables." }
-];
-
-const sourceFiles = [
-  "bin/gmc.mjs",
-  "src/index.js",
-  "src/args.js",
-  "src/browser-login.js",
-  "src/config.js",
-  "src/constants.js",
-  "src/help.js",
-  "src/main.js",
-  "src/output.js",
-  "src/projection.js",
-  "src/requests.js",
-  "src/workflows.js"
-];
-
-const failures = [];
-
-if (packageJson.private === true) {
-  failures.push("packages/gmc-cli/package.json must not have private:true for beta publishing.");
-}
-
-if (packageJson.name !== "@witchpot/gmc") {
-  failures.push(`Unexpected package name: ${packageJson.name}`);
-}
-
-if (packageJson.publishConfig?.access !== "public") {
-  failures.push("publishConfig.access must be public for npm beta-tag publishing.");
-}
-
-for (const binName of ["gmc", "gmcp", "game-market-copilot"]) {
-  if (packageJson.bin?.[binName] !== "bin/gmc.mjs") {
-    failures.push(`bin.${binName} must point to bin/gmc.mjs.`);
-  }
-}
-
-if (packageJson.main !== "./src/index.js") {
-  failures.push("main must point to ./src/index.js.");
-}
-
-if (packageJson.exports?.["."] !== "./src/index.js") {
-  failures.push("exports['.'] must point to ./src/index.js.");
-}
-
-for (const required of requiredFileGlobs) {
-  if (!packageJson.files?.includes(required)) {
-    failures.push(`package.json files must include ${required}.`);
-  }
-}
-
-for (const file of requiredFiles) {
-  if (!existsSync(path.join(packageDir, file))) {
-    failures.push(`Missing required package file: ${file}`);
-  }
-}
-
-const constantsPath = path.join(packageDir, "src/constants.js");
-const constantsSource = readFileSync(constantsPath, "utf8");
-const versionMatch = constantsSource.match(/CLI_VERSION\s*=\s*"([^"]+)"/);
-if (!versionMatch) {
-  failures.push("src/constants.js must export a string CLI_VERSION.");
-} else if (versionMatch[1] !== packageJson.version) {
-  failures.push(`CLI_VERSION (${versionMatch[1]}) must match package version (${packageJson.version}).`);
-}
-
-const changelog = readFileSync(path.join(packageDir, "CHANGELOG.md"), "utf8");
-if (!changelog.includes(`## ${packageJson.version} -`)) {
-  failures.push(`CHANGELOG.md must include a section for ${packageJson.version}.`);
-}
-
-const skillSource = readFileSync(path.join(packageDir, "skill/gmc-analysis/SKILL.md"), "utf8");
-const skillVersionMatch = skillSource.match(/^\s*version:\s*"?([0-9][0-9A-Za-z.\-]*)"?\s*$/m);
-if (!skillVersionMatch) {
-  failures.push("skill/gmc-analysis/SKILL.md must declare metadata.version in its frontmatter.");
-} else {
-  const skillChangelog = readFileSync(path.join(packageDir, "skill/gmc-analysis/CHANGELOG.md"), "utf8");
-  if (!skillChangelog.includes(`## ${skillVersionMatch[1]} -`)) {
-    failures.push(`skill CHANGELOG.md must include a section for skill version ${skillVersionMatch[1]}.`);
-  }
-}
-
-for (const file of sourceFiles) {
-  const source = readFileSync(path.join(packageDir, file), "utf8");
-  for (const forbidden of forbiddenPatterns) {
-    if (forbidden.pattern.test(source)) {
-      failures.push(`${file}: ${forbidden.message}`);
-    }
-  }
-}
-
-// The skill content-hash manifest (NAK-190) is also enforced by
-// src/skill-manifest.test.js, but release:check/prepublishOnly run WITHOUT
-// the test suite — recheck here so a stale manifest can never reach npm.
-const { buildSkillManifest, MANIFEST_PATH } = await import("./gen-skill-manifest.mjs");
-if (!existsSync(MANIFEST_PATH)) {
-  failures.push("skill/gmc-analysis.manifest.json is missing — run npm run skill:manifest.");
-} else {
-  const committedManifest = JSON.parse(readFileSync(MANIFEST_PATH, "utf8"));
-  const currentManifest = buildSkillManifest();
-  if (
-    committedManifest.contentHash !== currentManifest.contentHash ||
-    committedManifest.version !== currentManifest.version
-  ) {
-    failures.push(
-      "skill/gmc-analysis.manifest.json is stale: bump metadata.version in SKILL.md, run npm run skill:manifest, and re-sync the gmc-agent-skills distribution repo."
-    );
-  }
-}
-
-// The public distribution repo (github.com/witchpot-studio/gmc-agent-skills)
-// mirrors skill/gmc-analysis. When it is checked out as a workspace sibling,
-// a drift between the two is a release blocker — MCP-only users install the
-// skill from that repo and must get the same content the npm package ships.
-const explicitAgentSkillsDir = process.env.GMC_AGENT_SKILLS_DIR;
-const agentSkillsRepo =
-  explicitAgentSkillsDir ?? path.join(packageDir, "..", "..", "..", "gmc-agent-skills");
-const agentSkillsSyncScript = path.join(agentSkillsRepo, "scripts", "sync-from-cli.mjs");
-if (explicitAgentSkillsDir && !existsSync(agentSkillsSyncScript)) {
-  failures.push(
-    `GMC_AGENT_SKILLS_DIR is set but ${agentSkillsSyncScript} does not exist — fix the path or unset the variable.`
-  );
-} else if (existsSync(agentSkillsSyncScript)) {
-  const drift = spawnSync(process.execPath, ["scripts/sync-from-cli.mjs", "--check"], {
-    cwd: agentSkillsRepo,
-    encoding: "utf8",
-    // Pin the canonical source to THIS checkout — the sync script's own
-    // default (../GMC relative to the skills repo) could silently compare
-    // against a different GMC checkout.
-    env: { ...process.env, GMC_REPO_DIR: path.join(packageDir, "..", "..") }
-  });
-  if (drift.status !== 0) {
-    failures.push(
-      `gmc-agent-skills repo has drifted from skill/gmc-analysis — run node scripts/sync-from-cli.mjs there.\n${(drift.stderr || "").trim()}`
-    );
-  }
-}
-
-if (failures.length > 0) {
-  process.stderr.write(`GMC CLI release readiness failed:\n${failures.map((failure) => `- ${failure}`).join("\n")}\n`);
-  process.exit(1);
-}
-
-process.stdout.write(`GMC CLI release readiness ok: ${packageJson.name}@${packageJson.version}\n`);

package/scripts/gen-skill-manifest.mjs

@@ -1,151 +0,0 @@
-#!/usr/bin/env node
-
-// Regenerates skill/gmc-analysis.manifest.json — a content-hash fingerprint
-// of the packaged gmc-analysis skill (SKILL.md + references/ + CHANGELOG.md).
-//
-// Maintainer rule: any time skill/gmc-analysis/** content changes, bump
-// metadata.version in SKILL.md, then run `npm run skill:manifest` (in
-// packages/gmc-cli) to regenerate this manifest, and re-sync the
-// gmc-agent-skills distribution repo (node scripts/sync-from-cli.mjs there).
-// src/skill-manifest.test.js recomputes the same hash on every
-// `npm run test:cli` / `npm run verify` and fails loudly if it no longer
-// matches the committed manifest — this is the drift guard that would have
-// caught the unversioned charts.md changes in PR #18 / PR #43 (NAK-190).
-//
-// The manifest is written OUTSIDE skill/gmc-analysis/ on purpose: that
-// directory is mirrored byte-for-byte into the public gmc-agent-skills
-// distribution repo, and the manifest must never be part of (or affect the
-// hash of) the content it describes.
-
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const packageDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-export const SKILL_DIR = path.join(packageDir, "skill", "gmc-analysis");
-export const MANIFEST_PATH = path.join(packageDir, "skill", "gmc-analysis.manifest.json");
-
-/** List every file under `dir`, as sorted relative POSIX paths. */
-export function listSkillFiles(dir = SKILL_DIR) {
-  const results = [];
-  walk(dir, dir, results);
-  return results.sort();
-}
-
-function walk(root, current, results) {
-  const entries = readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries) {
-    const abs = path.join(current, entry.name);
-    if (entry.isDirectory()) {
-      walk(root, abs, results);
-    } else if (entry.isFile()) {
-      results.push(path.relative(root, abs).split(path.sep).join("/"));
-    }
-  }
-}
-
-function sha256Hex(buffer) {
-  return createHash("sha256").update(buffer).digest("hex");
-}
-
-/**
- * Hash every file under `dir` and fold the per-file hashes into one
- * top-level sha256 over `relpath\nfilehash\n` lines (sorted, deterministic).
- */
-export function computeSkillContentHash(dir = SKILL_DIR) {
-  const files = listSkillFiles(dir);
-  const digest = createHash("sha256");
-  for (const relPath of files) {
-    const fileHash = sha256Hex(readFileSync(path.join(dir, relPath)));
-    digest.update(`${relPath}\n${fileHash}\n`);
-  }
-  return { contentHash: digest.digest("hex"), files: files.length };
-}
-
-/** Parse metadata.version out of SKILL.md source text; undefined when absent. */
-export function parseSkillVersion(source) {
-  const frontmatter = source.match(/^---\n([\s\S]*?)\n---/);
-  return frontmatter?.[1].match(/^\s*version:\s*"?([0-9][0-9A-Za-z.\-]*)"?\s*$/m)?.[1];
-}
-
-/** Read metadata.version from SKILL.md's YAML frontmatter. */
-export function readSkillManifestVersion(dir = SKILL_DIR) {
-  const version = parseSkillVersion(readFileSync(path.join(dir, "SKILL.md"), "utf8"));
-  if (!version) {
-    throw new Error(`${path.join(dir, "SKILL.md")} must declare metadata.version in its frontmatter.`);
-  }
-  return version;
-}
-
-/** Build the manifest object (version + contentHash + files) for `dir`. */
-export function buildSkillManifest(dir = SKILL_DIR) {
-  const { contentHash, files } = computeSkillContentHash(dir);
-  return { version: readSkillManifestVersion(dir), contentHash, files };
-}
-
-/**
- * Baseline manifest for the version-bump rule. The authoritative baseline is
- * the manifest COMMITTED ON origin/main (read via `git show`, so deleting or
- * hand-editing the local file cannot dodge the rule); the local file is only
- * a fallback for environments where the git baseline is unreadable.
- */
-function baselineSkillManifest() {
-  const result = spawnSync("git", ["show", "origin/main:packages/gmc-cli/skill/gmc-analysis.manifest.json"], {
-    cwd: packageDir,
-    encoding: "utf8"
-  });
-  if (result.status === 0 && typeof result.stdout === "string") {
-    try {
-      return JSON.parse(result.stdout);
-    } catch {
-      // fall through to the local file
-    }
-  }
-  if (existsSync(MANIFEST_PATH)) {
-    try {
-      return JSON.parse(readFileSync(MANIFEST_PATH, "utf8"));
-    } catch {
-      return undefined;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Pure regen-permission rule (unit-tested in src/skill-manifest.test.js).
- * Content that differs from the baseline while keeping the baseline's
- * version is refused: once a version's content is on origin/main, changing
- * content under that version always requires a bump. A differing version
- * (the in-flight bump case, iterated freely within one branch) and a
- * missing baseline (true first generation) are allowed. There is
- * deliberately NO force escape hatch: an override flag would let
- * unversioned content changes reach npm and the public skills repo.
- */
-export function assertRegenAllowed({ baseline, next }) {
-  if (!baseline) return;
-  if (baseline.contentHash === next.contentHash) return;
-  if (baseline.version !== next.version) return;
-  throw new Error(
-    `skill content changed but metadata.version is still ${next.version}, whose content is already fixed by the baseline manifest (origin/main) — bump the version in SKILL.md, then rerun npm run skill:manifest.`
-  );
-}
-
-function main() {
-  const manifest = buildSkillManifest();
-  try {
-    assertRegenAllowed({ baseline: baselineSkillManifest(), next: manifest });
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-  writeFileSync(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}\n`);
-  process.stdout.write(
-    `Wrote ${path.relative(packageDir, MANIFEST_PATH)}: version ${manifest.version}, ${manifest.files} files, contentHash ${manifest.contentHash}\n`
-  );
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  main();
-}