fimo 0.7.0-experimental.1 → 0.7.0-experimental.2

package/scripts/bundle-cli.mjs

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-// Bundles the Fimo CLI binary into a single self-contained ESM file at
-// `dist/cli/index.js`, overwriting the per-file tsc output.
-//
-// Scope:
-//  - Only the `bin` entry (`src/cli/index.ts`) is bundled. The subpath
-//    exports (`fimo/ui`, `fimo/seo`, `fimo/app`, `fimo/vite`,
-//    `fimo/config/react-router`) keep their multi-file tsc output under
-//    `dist/runtime/` and `dist/build/`.
-//  - Native deps are kept external (`oxc-parser` has a Rust addon) so they
-//    resolve at runtime from the published `dependencies`.
-//  - All other deps reachable from `src/cli/index.ts` are inlined.
-//
-// This script assumes `tsc -b` has already produced the rest of `dist/`. Run
-// `pnpm -F fimo build` first, or use the `prepublishOnly` chain.
-//
-// Usage:
-//   node scripts/bundle-cli.mjs
-
-import { readFileSync, rmSync, writeFileSync, statSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { build } from 'esbuild';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(HERE, '..');
-const ENTRY = resolve(CLI_ROOT, 'src/cli/index.ts');
-const OUTFILE = resolve(CLI_ROOT, 'dist/cli/index.js');
-
-// Native or otherwise non-bundlable runtime deps. Keep them in the published
-// `dependencies` so `npm install -g fimo` pulls them in transitively.
-const EXTERNAL = [
-  'oxc-parser', // Rust-backed native parser
-  'fsevents', // macOS-only native .node addon; chokidar require()s it behind a try/catch
-];
-
-const pkg = JSON.parse(readFileSync(resolve(CLI_ROOT, 'package.json'), 'utf8'));
-
-console.log(`[cli/bundle] entry:   ${ENTRY}`);
-console.log(`[cli/bundle] outfile: ${OUTFILE}`);
-console.log(`[cli/bundle] external: ${EXTERNAL.join(', ')}`);
-
-const result = await build({
-  entryPoints: [ENTRY],
-  outfile: OUTFILE,
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  // Esbuild promotes the source's `#!/usr/bin/env node` shebang to line 1 of
-  // the output, then prepends this banner. Some bundled deps (notably
-  // `commander`) are CJS and call `require('node:events')` etc. internally;
-  // esbuild wraps those with its own `__require` helper which doesn't know
-  // about Node built-ins. Injecting `createRequire` here gives the bundled
-  // CJS a working `require()` against the real Node resolver.
-  banner: {
-    js: "import { createRequire as __fimoCreateRequire } from 'node:module';\nconst require = __fimoCreateRequire(import.meta.url);",
-  },
-  // Mark native runtime deps as external; everything else inlines.
-  external: EXTERNAL,
-  // Inline node_modules deps reachable from the entry. Built-ins
-  // (node:fs, etc.) are externalized automatically by `platform=node`.
-  packages: 'bundle',
-  // Resolve .ts / .tsx during the bundling pass (we're reading source, not
-  // the tsc output).
-  resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],
-  // ESM emit requires ESM-style imports for built-ins.
-  mainFields: ['module', 'main'],
-  conditions: ['node', 'import', 'default'],
-  // Keep file names stable in the bundled output for clearer stack traces.
-  keepNames: true,
-  // Source map is overkill in the published tarball; skip for v1.
-  sourcemap: false,
-  // Minification trades readability for ~30% size; skip - the bundle stays
-  // human-grep-able which helps debugging field issues. Revisit if size
-  // becomes a problem.
-  minify: false,
-  // Surface every warning so we don't silently produce a broken bundle.
-  logLevel: 'info',
-  metafile: true,
-});
-
-// Stamp the version + bundled marker into a sidecar so `release.json` /
-// future tooling can detect bundled artifacts without re-parsing the bundle.
-const meta = {
-  bundled: true,
-  bundler: 'esbuild',
-  bundledAt: new Date().toISOString(),
-  cliVersion: pkg.version,
-  external: EXTERNAL,
-};
-writeFileSync(resolve(CLI_ROOT, 'dist/cli/bundle.json'), JSON.stringify(meta, null, 2) + '\n');
-
-// Clean up the per-file tsc artifacts under `dist/cli/` that the bundle has
-// now subsumed - anything except `index.js` and the sidecar. Subpath exports
-// live under `dist/runtime/` and `dist/build/`, which stay untouched.
-const inputs = Object.keys(result.metafile.inputs);
-console.log(`[cli/bundle] inlined ${inputs.length} modules`);
-
-const distCli = resolve(CLI_ROOT, 'dist/cli');
-const { readdirSync } = await import('node:fs');
-function rmExceptIndex(dir) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = resolve(dir, entry.name);
-    if (dir === distCli && (entry.name === 'index.js' || entry.name === 'bundle.json')) {
-      continue;
-    }
-    rmSync(full, { recursive: true, force: true });
-  }
-}
-rmExceptIndex(distCli);
-
-// Make the bin executable. npm chmods bin files on `npm install -g`
-// regardless, but a properly-permissioned tarball is the right hygiene
-// AND it makes the local-link flow (where the user's checkout is
-// symlinked into ~/.fimovm/linked/<alias>) work without a follow-up
-// chmod step.
-import { chmodSync } from 'node:fs';
-chmodSync(OUTFILE, 0o755);
-
-const bytes = statSync(OUTFILE).size;
-console.log(`[cli/bundle] done. ${(bytes / 1024).toFixed(1)} KB written to ${OUTFILE}`);

package/scripts/install-cli.mjs

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-// Creates a `fimo` symlink in ~/.local/bin/ pointing at the built CLI entry
-// so `fimo <command>` works from any directory on the machine.
-import { chmodSync, existsSync, mkdirSync, symlinkSync, unlinkSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(HERE, '..');
-const ENTRY = resolve(CLI_ROOT, 'dist', 'cli', 'index.js');
-
-if (!existsSync(ENTRY)) {
-  console.error(`[cli/install] Built entry not found at ${ENTRY}. Run \`pnpm -F cli build\` first.`);
-  process.exit(1);
-}
-
-const BIN_DIR = resolve(homedir(), '.local', 'bin');
-const LINK = resolve(BIN_DIR, 'fimo');
-
-mkdirSync(BIN_DIR, { recursive: true });
-chmodSync(ENTRY, 0o755);
-if (existsSync(LINK)) {
-  unlinkSync(LINK);
-}
-symlinkSync(ENTRY, LINK);
-
-console.log(`[cli/install] Linked ${LINK} → ${ENTRY}`);
-
-const pathDirs = (process.env.PATH ?? '').split(':');
-if (!pathDirs.includes(BIN_DIR)) {
-  console.log('');
-  console.log(`⚠  ${BIN_DIR} is not on your PATH.`);
-  console.log('   Add this to your shell rc (~/.zshrc, ~/.bashrc, ...):');
-  console.log(`     export PATH="$HOME/.local/bin:$PATH"`);
-}

package/scripts/lib/channels.mjs

@@ -1,70 +0,0 @@
-// Single source of truth for fimo release channels.
-//
-// channel → { source, apiUrl, webUrl, distTag, prerelease }
-//
-// Read by the npm publish path (scripts/publish-npm.mjs) and the CI
-// release workflow. Defined ONCE so the npm and (legacy) R2 paths can
-// never drift on "what does staging mean" — the bug class behind a
-// published build accidentally pointing at the wrong API.
-//
-// Hard rule (D5): a published package bakes ONLY staging or prod. Never a
-// tunnel or localhost — that would leak a private URL to the public
-// registry. Tunnels/localhost are runtime FIMO_API_URL overrides, never
-// baked. `ALLOWED_API_URLS` enforces this at publish time.
-
-// Staging lives on the .team domain; production is fimo.ai.
-export const STAGING_API_URL = 'https://api.staging.fimo.team';
-export const STAGING_WEB_URL = 'https://staging.fimo.team';
-export const PROD_API_URL = 'https://api.fimo.ai';
-export const PROD_WEB_URL = 'https://fimo.ai';
-
-/**
- * @typedef {Object} Channel
- * @property {'npm'} source        - marks the published build's origin
- * @property {string} apiUrl       - cloud API base baked into release.json
- * @property {string} webUrl       - web URL baked into release.json
- * @property {string} distTag      - npm dist-tag to publish under
- * @property {boolean} prerelease  - true → synthesize a disposable X.Y.Z-<tag>.N version
- */
-
-/** @type {Record<string, Channel>} */
-export const CHANNELS = {
-  experimental: {
-    source: 'npm',
-    apiUrl: STAGING_API_URL,
-    webUrl: STAGING_WEB_URL,
-    distTag: 'experimental',
-    prerelease: true,
-  },
-  staging: {
-    source: 'npm',
-    apiUrl: STAGING_API_URL,
-    webUrl: STAGING_WEB_URL,
-    distTag: 'staging',
-    prerelease: true,
-  },
-  latest: {
-    source: 'npm',
-    apiUrl: PROD_API_URL,
-    webUrl: PROD_WEB_URL,
-    distTag: 'latest',
-    prerelease: false,
-  },
-};
-
-// A published package may bake ONLY these api URLs. Everything else
-// (localhost, tunnels) is refused at publish time.
-export const ALLOWED_API_URLS = new Set([STAGING_API_URL, PROD_API_URL]);
-
-/**
- * Resolve a channel by name, throwing on an unknown name.
- * @param {string} name
- * @returns {Channel}
- */
-export function resolveChannel(name) {
-  const channel = CHANNELS[name];
-  if (!channel) {
-    throw new Error(`Unknown channel "${name}". Valid channels: ${Object.keys(CHANNELS).join(', ')}.`);
-  }
-  return channel;
-}

package/scripts/lib/dev-release-state.mjs

@@ -1,44 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { relative, resolve } from 'node:path';
-
-/**
- * Record the latest locally-published experimental CLI version for this
- * checkout. `fimo deploy` uses this to swap a project-local `file:` dependency
- * to an immutable npm version before pushing to a remote sandbox.
- *
- * @param {string} cliRoot - apps/cli root
- * @param {{ version: string, channel: string }} release
- * @returns {string} the file written
- */
-export function writeDevReleaseState(cliRoot, release) {
-  const repoRoot = resolve(cliRoot, '..', '..');
-  const dir = resolve(repoRoot, '.fimo');
-  mkdirSync(dir, { recursive: true });
-
-  const payload = {
-    version: release.version,
-    channel: release.channel,
-    packageRoot: relative(repoRoot, cliRoot),
-    gitSha: readGitSha(repoRoot),
-    publishedAt: new Date().toISOString(),
-  };
-
-  const file = resolve(dir, 'dev.json');
-  writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
-  return file;
-}
-
-function readGitSha(repoRoot) {
-  const result = spawnSync('git', ['rev-parse', 'HEAD'], {
-    cwd: repoRoot,
-    encoding: 'utf8',
-  });
-  if (result.status === 0) {
-    const sha = result.stdout.trim();
-    if (sha.length > 0) {
-      return sha;
-    }
-  }
-  return null;
-}

package/scripts/lib/dev-release-state.test.ts

@@ -1,36 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { writeDevReleaseState } from './dev-release-state.mjs';
-
-const tmpRoots: string[] = [];
-
-afterEach(() => {
-  for (const root of tmpRoots.splice(0)) {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-describe('writeDevReleaseState', () => {
-  it('writes repo-root .fimo/dev.json for the checkout', () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'fimo-dev-state-'));
-    tmpRoots.push(root);
-    const cliRoot = path.join(root, 'apps', 'cli');
-    fs.mkdirSync(cliRoot, { recursive: true });
-
-    const file = writeDevReleaseState(cliRoot, {
-      version: '0.2.3-experimental.42',
-      channel: 'experimental',
-    });
-
-    expect(file).toBe(path.join(root, '.fimo', 'dev.json'));
-    expect(JSON.parse(fs.readFileSync(file, 'utf8'))).toMatchObject({
-      version: '0.2.3-experimental.42',
-      channel: 'experimental',
-      packageRoot: 'apps/cli',
-    });
-  });
-});

package/scripts/lib/postinstall-onboarding.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { isGlobalInstall, parseYesNo, shouldPromptForGlobalSkills } from './postinstall-onboarding.mjs';
-
-describe('isGlobalInstall', () => {
-  it('detects npm global installs', () => {
-    expect(isGlobalInstall({ npm_config_global: 'true' })).toBe(true);
-  });
-
-  it('detects package-manager location=global installs', () => {
-    expect(isGlobalInstall({ npm_config_location: 'global' })).toBe(true);
-  });
-
-  it('ignores local installs', () => {
-    expect(isGlobalInstall({})).toBe(false);
-  });
-});
-
-describe('shouldPromptForGlobalSkills', () => {
-  it('prompts only for interactive global installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toEqual({ ok: true });
-  });
-
-  it('skips CI and non-interactive installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', CI: '1' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'ci' });
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true' },
-        stdinIsTTY: false,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'non-interactive' });
-  });
-
-  it('honors the explicit skip env var', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', FIMO_SKIP_POSTINSTALL_PROMPT: '1' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'disabled' });
-  });
-
-  it('skips package-manager assume-yes installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', npm_config_yes: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', npm_config_force: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
-  });
-});
-
-describe('parseYesNo', () => {
-  it('parses yes, no, and empty defaults', () => {
-    expect(parseYesNo('y')).toBe(true);
-    expect(parseYesNo('no')).toBe(false);
-    expect(parseYesNo('', true)).toBe(true);
-    expect(parseYesNo('', false)).toBe(false);
-  });
-});

package/scripts/lib/release-core.mjs

@@ -1,225 +0,0 @@
-// Shared release-core: the channel-aware release.json bake.
-//
-// This is the single place that stamps which environment a published
-// build talks to. Both the npm publish path and any future CI job call
-// it, so the "which URL goes in which build" decision can't drift.
-//
-// `release.json` is a publish artifact: it is gitignored (apps/cli/.gitignore)
-// and only exists transiently while packing. The CLI reads it at runtime as
-// `FIMO_API_URL env || baked release.json || localhost` — so the bake only
-// governs a bare `npm i -g fimo` with no env set. The sandbox always
-// overrides it via the injected `.env`.
-
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { ALLOWED_API_URLS } from './channels.mjs';
-
-const TEMPLATE_PKG_REL = 'templates/react-router/package.json';
-const TEMPLATE_LOCK_REL = 'templates/react-router/pnpm-lock.yaml';
-
-/**
- * Write a `release.json` for a published (`source: 'npm'`) build using the
- * channel's baked URLs. Refuses any apiUrl not on the allowlist so a
- * tunnel/localhost can never reach the public registry (D5).
- *
- * @param {string} cliRoot - apps/cli root
- * @param {import('./channels.mjs').Channel} channel
- * @returns {string} the path written
- */
-export function writeReleaseJson(cliRoot, channel) {
-  if (!ALLOWED_API_URLS.has(channel.apiUrl)) {
-    throw new Error(
-      `Refusing to bake non-allowlisted apiUrl "${channel.apiUrl}" into a published package. ` +
-        `Published channels may bake only staging or prod (D5).`
-    );
-  }
-  const payload = {
-    source: channel.source,
-    apiUrl: channel.apiUrl,
-    webUrl: channel.webUrl,
-  };
-  const file = resolve(cliRoot, 'release.json');
-  writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
-  return file;
-}
-
-/**
- * Pin the bundled template's `fimo` dependency to an exact version at pack
- * time, so a project scaffolded from `fimo@X` depends on exactly `fimo@X`
- * (immutable, reproducible — no mutable URL, no caret drift). The committed
- * template keeps a dev-friendly value; this overwrites it only for the
- * tarball and the returned function restores it afterwards.
- *
- * @param {string} cliRoot
- * @param {string} version - exact version to pin (e.g. "0.3.0" or "0.3.0-experimental.4")
- * @returns {() => void} restore - rewrites the original file contents back
- */
-export function pinTemplateFimo(cliRoot, version) {
-  const file = resolve(cliRoot, TEMPLATE_PKG_REL);
-  if (!existsSync(file)) {
-    return () => {};
-  }
-  const original = readFileSync(file, 'utf8');
-  const pkg = JSON.parse(original);
-  let changed = false;
-  for (const field of ['dependencies', 'devDependencies']) {
-    if (pkg[field] && typeof pkg[field].fimo === 'string' && pkg[field].fimo !== version) {
-      pkg[field].fimo = version;
-      changed = true;
-    }
-  }
-  if (changed) {
-    writeFileSync(file, JSON.stringify(pkg, null, 2) + '\n');
-  }
-  return () => writeFileSync(file, original);
-}
-
-/**
- * Remove the template's pnpm-lock.yaml from the tarball at pack time.
- *
- * We can't ship a correct lockfile: it would have to pin the exact version
- * we're about to publish, which isn't on the registry yet (chicken-and-egg).
- * A stale lockfile pinning a different spec than package.json breaks frozen
- * installs (the 2026-06-11 outage class). With an exact, immutable version in
- * package.json, `fimo create` + a fresh `pnpm install` resolves
- * deterministically — so shipping no lockfile is the correct choice.
- * `scaffold.ts` already deletes the lockfile whenever it rewrites the dep, so
- * this only matters for the exact-npm-match path, but it's always safe.
- *
- * @param {string} cliRoot
- * @returns {() => void} restore - rewrites the original lockfile back, if any
- */
-export function stripTemplateLockfile(cliRoot) {
-  const file = resolve(cliRoot, TEMPLATE_LOCK_REL);
-  if (!existsSync(file)) {
-    return () => {};
-  }
-  const original = readFileSync(file, 'utf8');
-  rmSync(file, { force: true });
-  return () => writeFileSync(file, original);
-}
-
-/**
- * Parse `npm view <name> versions --json` output into a flat list of version
- * strings, tolerating every shape npm has shipped: an array of strings
- * (npm <= 11), a bare string when exactly one version is published
- * (npm <= 11), and the npm 12 wrapper — "npm view --json now always returns
- * an array", one entry per matched version, i.e. `[[...versions]]` for a bare
- * package name. Returns null when nothing version-shaped survives (error
- * envelopes, empty output), so callers fall back to the run-number/timestamp
- * counter instead of trusting garbage.
- *
- * @param {string} stdout - raw stdout of `npm view <name> versions --json`
- * @returns {string[] | null}
- */
-export function parsePublishedVersions(stdout) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    return null;
-  }
-  const versions = (Array.isArray(parsed) ? parsed : [parsed]).flat().filter((version) => typeof version === 'string');
-  return versions.length > 0 ? versions : null;
-}
-
-/**
- * Next per-version prerelease counter: one past the highest already-published
- * `<base>-<distTag>.<n>` on npm. Counting from what's actually published
- * (instead of resetting blindly to 1) keeps the counter collision-proof even
- * when the projected base flaps back to a value that already has prereleases —
- * npm versions are immutable, so a blind reset would make the publish fail.
- *
- * @param {readonly string[]} existingVersions - all published versions of the package
- * @param {string} base - X.Y.Z base (no prerelease suffix)
- * @param {string} distTag
- * @returns {number}
- */
-export function nextPrereleaseCounter(existingVersions, base, distTag) {
-  const prefix = `${base}-${distTag}.`;
-  let max = 0;
-  for (const version of existingVersions) {
-    if (!version.startsWith(prefix)) {
-      continue;
-    }
-    const n = Number(version.slice(prefix.length));
-    if (Number.isInteger(n) && n > max) {
-      max = n;
-    }
-  }
-  return max + 1;
-}
-
-/**
- * Compute the version to publish for a channel.
- * - Stable (`latest`) publishes the exact package.json version.
- * - Prerelease channels synthesize a disposable `X.Y.Z-<distTag>.<n>`.
- *   `n` counts per base version (`0.3.5-staging.1`, `.2`, …) when the
- *   published versions could be fetched from npm; otherwise it falls back
- *   to the CI run number, then a timestamp.
- *
- * @param {string} baseVersion - package.json version
- * @param {import('./channels.mjs').Channel} channel
- * @param {{ runId?: string, existingVersions?: readonly string[] }} [opts]
- * @returns {string}
- */
-export function computePublishVersion(baseVersion, channel, opts = {}) {
-  if (!channel.prerelease) {
-    return baseVersion;
-  }
-  // Strip any existing prerelease suffix from the base so we don't stack them.
-  const base = baseVersion.split('-')[0];
-  const n = opts.existingVersions
-    ? String(nextPrereleaseCounter(opts.existingVersions, base, channel.distTag))
-    : (opts.runId ?? String(Date.now()));
-  return `${base}-${channel.distTag}.${n}`;
-}
-
-const BUMP_RANK = { patch: 1, minor: 2, major: 3 };
-
-/**
- * Peek at pending changeset files and compute the version the next
- * `changeset version` run will produce for `fimo`. Prerelease channels use
- * this as their base so a staging build advertises the version prod will
- * actually ship (`0.3.4-staging.26` while 0.3.4 is pending) instead of the
- * already-released base. No pending changesets (or no .changeset dir) →
- * base unchanged.
- *
- * @param {string} baseVersion - package.json version
- * @param {string} changesetDir - absolute path to the repo's .changeset dir
- * @returns {string}
- */
-export function nextVersionFromChangesets(baseVersion, changesetDir) {
-  let entries;
-  try {
-    entries = readdirSync(changesetDir);
-  } catch {
-    return baseVersion;
-  }
-
-  let maxBump = null;
-  for (const name of entries) {
-    if (!name.endsWith('.md') || name === 'README.md') {
-      continue;
-    }
-    const text = readFileSync(join(changesetDir, name), 'utf8');
-    const frontmatter = text.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? '';
-    const bump = frontmatter.match(/['"]?fimo['"]?\s*:\s*(patch|minor|major)/)?.[1];
-    if (bump && (!maxBump || BUMP_RANK[bump] > BUMP_RANK[maxBump])) {
-      maxBump = bump;
-    }
-  }
-
-  if (!maxBump) {
-    return baseVersion;
-  }
-  const [major, minor, patch] = baseVersion.split('-')[0].split('.').map(Number);
-  if (maxBump === 'major') {
-    return `${major + 1}.0.0`;
-  }
-  if (maxBump === 'minor') {
-    return `${major}.${minor + 1}.0`;
-  }
-  return `${major}.${minor}.${patch + 1}`;
-}