fimo 0.7.0-experimental.2 → 0.7.0-experimental.4

package/dist/scripts/validate-route-metadata.test.js

@@ -0,0 +1,116 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateRouteMetadata } from './validate-route-metadata';
+describe('validateRouteMetadata i18n checks', () => {
+    let scratch = null;
+    afterEach(() => {
+        if (scratch) {
+            rmSync(scratch, { recursive: true, force: true });
+            scratch = null;
+        }
+    });
+    it('accepts fimoRoutes() with canonical routes and multi-locale path prefixes', () => {
+        const cwd = writeProject({
+            config: {
+                i18n: {
+                    defaultLocale: 'en',
+                    locales: ['en', 'es'],
+                    routing: { strategy: 'path-prefix' },
+                },
+                routes: {
+                    home: { path: '/', label: 'Home' },
+                    pricing: { path: '/pricing', label: 'Pricing' },
+                },
+            },
+            routesSource: `import type { RouteConfig } from '@react-router/dev/routes';
+import { index, route } from '@react-router/dev/routes';
+import { fimoRoutes } from 'fimo/react-router/routes';
+
+const routes = [
+  index('./pages/Index.tsx', { id: 'home' }),
+  route('pricing', './pages/Pricing.tsx', { id: 'pricing' }),
+] satisfies RouteConfig;
+
+export default fimoRoutes(routes) satisfies RouteConfig;
+`,
+            files: ['src/pages/Index.tsx', 'src/pages/Pricing.tsx'],
+        });
+        expect(validateRouteMetadata({ cwd }).errors).toEqual([]);
+    });
+    it('rejects invalid locale config', () => {
+        const cwd = writeProject({
+            config: {
+                i18n: {
+                    defaultLocale: 'en--US',
+                    locales: ['es'],
+                    routing: { strategy: 'path-prefix' },
+                },
+                routes: {
+                    home: { path: '/', label: 'Home' },
+                },
+            },
+            routesSource: `import { index } from '@react-router/dev/routes';
+export default [index('./pages/Index.tsx')];
+`,
+            files: ['src/pages/Index.tsx'],
+        });
+        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
+        expect(errors).toContain('Invalid i18n.defaultLocale "en--US"');
+        expect(errors).toContain('i18n.locales must include i18n.defaultLocale');
+    });
+    it('rejects canonical routes that claim locale prefixes', () => {
+        const cwd = writeProject({
+            config: {
+                i18n: {
+                    defaultLocale: 'en',
+                    locales: ['en', 'es'],
+                    routing: { strategy: 'path-prefix' },
+                },
+                routes: {
+                    spanish: { path: '/es', label: 'Spanish' },
+                },
+            },
+            routesSource: `import { route } from '@react-router/dev/routes';
+export default [route('es', './pages/Spanish.tsx')];
+`,
+            files: ['src/pages/Spanish.tsx'],
+        });
+        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
+        expect(errors).toContain('uses reserved locale prefix "es"');
+    });
+    it('warns as an error when top-level dynamic routes can capture locale URLs without fimoRoutes()', () => {
+        const cwd = writeProject({
+            config: {
+                i18n: {
+                    defaultLocale: 'en',
+                    locales: ['en', 'es'],
+                    routing: { strategy: 'path-prefix' },
+                },
+                routes: {
+                    page: { path: '/:slug', label: 'Page', params: { slug: { schema: 'Page', queryField: 'slug' } } },
+                },
+            },
+            routesSource: `import { route } from '@react-router/dev/routes';
+export default [route(':slug', './pages/Page.tsx')];
+`,
+            files: ['src/pages/Page.tsx'],
+        });
+        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
+        expect(errors).toContain('top-level dynamic route');
+        expect(errors).toContain('fimoRoutes(routes)');
+    });
+    function writeProject(args) {
+        scratch = mkdtempSync(join(tmpdir(), 'fimo-route-metadata-'));
+        mkdirSync(join(scratch, 'src'), { recursive: true });
+        writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify(args.config, null, 2));
+        writeFileSync(join(scratch, 'src', 'routes.ts'), args.routesSource);
+        for (const file of args.files) {
+            mkdirSync(join(scratch, file, '..'), { recursive: true });
+            writeFileSync(join(scratch, file), 'export default function Page() { return null; }\n');
+        }
+        return scratch;
+    }
+});

package/dist/scripts/validate-schemas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/validate-schemas.test.js

@@ -0,0 +1,263 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateSchemas } from './validate-schemas';
+describe('validateSchemas', () => {
+    let scratch = null;
+    afterEach(() => {
+        if (scratch) {
+            rmSync(scratch, { recursive: true, force: true });
+            scratch = null;
+        }
+    });
+    function writeProject(schemas) {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+        for (const [fileName, schema] of Object.entries(schemas)) {
+            writeFileSync(join(scratch, 'src/schemas', fileName), typeof schema === 'string' ? schema : JSON.stringify(schema, null, 2));
+        }
+        return scratch;
+    }
+    it('accepts a valid schema', () => {
+        const cwd = writeProject({
+            'Author.json': {
+                uid: 'Author',
+                name: 'Authors',
+                fields: {
+                    name: { type: 'string' },
+                },
+            },
+            'BlogPost.json': {
+                uid: 'BlogPost',
+                name: 'Blog Posts',
+                fields: {
+                    title: { type: 'string' },
+                    body: { type: 'richtext' },
+                    coverImage: { type: 'media' },
+                    featured: { type: 'boolean' },
+                    author: { type: 'reference', target: 'Author' },
+                },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 2 });
+    });
+    it('accepts self-referential reference fields', () => {
+        const cwd = writeProject({
+            'Item.json': {
+                uid: 'Item',
+                name: 'Items',
+                fields: {
+                    title: { type: 'string' },
+                    parent: { type: 'reference', target: 'Item' },
+                },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
+    });
+    it('accepts a non-localized schema policy', () => {
+        const cwd = writeProject({
+            'Author.json': {
+                uid: 'Author',
+                name: 'Authors',
+                i18n: { enabled: false },
+                fields: { name: { type: 'string' } },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
+    });
+    it('rejects a non-boolean singleton policy', () => {
+        const cwd = writeProject({
+            'Settings.json': {
+                uid: 'Settings',
+                name: 'Settings',
+                isSingleton: 'yes',
+                fields: {},
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toEqual([expect.objectContaining({ rule: 'schemas/singleton' })]);
+    });
+    it.each([true, { enabled: 'no' }, { enabled: false, fallback: 'en' }, { fallback: 'en' }])('rejects an invalid schema-level i18n policy %#', (i18n) => {
+        const cwd = writeProject({
+            'Author.json': {
+                uid: 'Author',
+                name: 'Authors',
+                i18n,
+                fields: { name: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/i18n' });
+    });
+    it('returns no errors when the schemas directory does not exist', () => {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        expect(validateSchemas({ cwd: scratch })).toEqual({ errors: [], schemasChecked: 0 });
+    });
+    it('rejects reserved field names like slug', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'TeamMember',
+                name: 'Team Members',
+                fields: {
+                    name: { type: 'string' },
+                    slug: { type: 'string' },
+                },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reserved-field', file: 'src/schemas/TeamMember.json' });
+        expect(errors[0].message).toContain('"slug" is reserved');
+        expect(errors[0].message).toContain('entry data');
+    });
+    it('rejects every reserved metadata name', () => {
+        const cwd = writeProject({
+            'Bad.json': {
+                uid: 'Bad',
+                name: 'Bad',
+                fields: Object.fromEntries(['id', 'documentId', 'slug', 'locale', 'createdAt', 'updatedAt', '__fimo'].map((name) => [
+                    name,
+                    { type: 'string' },
+                ])),
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(7);
+        expect(errors.every((err) => err.rule === 'schemas/reserved-field')).toBe(true);
+    });
+    it('rejects unsupported field types', () => {
+        const cwd = writeProject({
+            'Product.json': {
+                uid: 'Product',
+                name: 'Products',
+                fields: { price: { type: 'decimal' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-type' });
+        expect(errors[0].message).toContain('"decimal"');
+        expect(errors[0].message).toContain('string, richtext, media');
+    });
+    it('rejects reference fields without a valid target', () => {
+        const cwd = writeProject({
+            'Post.json': {
+                uid: 'Post',
+                name: 'Posts',
+                fields: { author: { type: 'reference' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
+    });
+    it('rejects reference fields targeting a missing local schema', () => {
+        const cwd = writeProject({
+            'Post.json': {
+                uid: 'Post',
+                name: 'Posts',
+                fields: { author: { type: 'reference', target: 'Author' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
+        expect(errors[0].message).toContain('unknown schema "Author"');
+    });
+    it('rejects reference-only properties on scalar fields', () => {
+        const cwd = writeProject({
+            'Post.json': {
+                uid: 'Post',
+                name: 'Posts',
+                fields: { author: { type: 'string', target: 'Author' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-shape' });
+    });
+    it('rejects schema uid names that cannot be used as content type identifiers', () => {
+        const cwd = writeProject({
+            'blog-post.json': {
+                uid: 'blog-post',
+                name: 'Blog Posts',
+                fields: { title: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/type-name' });
+    });
+    it('rejects field names that cannot be used in generated source paths', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { 'hero-title': { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-name' });
+    });
+    it('rejects field-level i18n settings', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { title: { type: 'string', i18n: true } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
+    });
+    it('rejects reference-level locale settings', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { parent: { type: 'reference', target: 'Page', localized: true } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
+        expect(errors[0].message).toContain('"localized"');
+    });
+    it('rejects a uid that does not match the file name', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'Member',
+                name: 'Team Members',
+                fields: { name: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/uid' });
+    });
+    it('rejects missing uid, name, and fields', () => {
+        const cwd = writeProject({ 'Empty.json': {} });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors.map((err) => err.rule)).toEqual(['schemas/uid', 'schemas/name', 'schemas/fields']);
+    });
+    it('reports invalid JSON', () => {
+        const cwd = writeProject({ 'Broken.json': '{ not json' });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/parse' });
+    });
+    it('validates multiple files and counts them', () => {
+        const cwd = writeProject({
+            'Good.json': { uid: 'Good', name: 'Good', fields: { title: { type: 'string' } } },
+            'Bad.json': { uid: 'Bad', name: 'Bad', fields: { slug: { type: 'string' } } },
+        });
+        const result = validateSchemas({ cwd });
+        expect(result.schemasChecked).toBe(2);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBe('src/schemas/Bad.json');
+    });
+});

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "fimo",
-  "version": "0.7.0-experimental.2",
+  "version": "0.7.0-experimental.4",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
   },
   "files": [
     "dist/",
-    "!dist/**/*.d.ts.map",
     "assets/",
-    "scripts/postinstall.mjs",
-    "scripts/lib/postinstall-onboarding.mjs",
+    "scripts/",
     "templates/",
     "README.md",
     "release.json"
@@ -22,6 +20,18 @@
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
+    "./react": {
+      "types": "./dist/runtime/react/index.d.ts",
+      "import": "./dist/runtime/react/index.js"
+    },
+    "./next": {
+      "types": "./dist/runtime/next/index.d.ts",
+      "import": "./dist/runtime/next/index.js"
+    },
+    "./next/server": {
+      "types": "./dist/runtime/next/server.d.ts",
+      "import": "./dist/runtime/next/server.js"
+    },
     "./react-router": {
       "types": "./dist/runtime/react-router/index.d.ts",
       "import": "./dist/runtime/react-router/index.js"
@@ -41,6 +51,46 @@
     "./templates": {
       "types": "./dist/runtime/templates.d.ts",
       "import": "./dist/runtime/templates.js"
+    },
+    "./remix": {
+      "types": "./dist/runtime/remix/index.d.ts",
+      "import": "./dist/runtime/remix/index.js"
+    },
+    "./remix/server": {
+      "types": "./dist/runtime/remix/server.d.ts",
+      "import": "./dist/runtime/remix/server.js"
+    },
+    "./astro": {
+      "types": "./dist/runtime/astro/index.d.ts",
+      "import": "./dist/runtime/astro/index.js"
+    },
+    "./astro/server": {
+      "types": "./dist/runtime/astro/server.d.ts",
+      "import": "./dist/runtime/astro/server.js"
+    },
+    "./nuxt": {
+      "types": "./dist/runtime/nuxt/index.d.ts",
+      "import": "./dist/runtime/nuxt/index.js"
+    },
+    "./nuxt/server": {
+      "types": "./dist/runtime/nuxt/server.d.ts",
+      "import": "./dist/runtime/nuxt/server.js"
+    },
+    "./svelte": {
+      "types": "./dist/runtime/svelte/index.d.ts",
+      "import": "./dist/runtime/svelte/index.js"
+    },
+    "./svelte/server": {
+      "types": "./dist/runtime/svelte/server.d.ts",
+      "import": "./dist/runtime/svelte/server.js"
+    },
+    "./vue": {
+      "types": "./dist/runtime/vue/index.d.ts",
+      "import": "./dist/runtime/vue/index.js"
+    },
+    "./vue/server": {
+      "types": "./dist/runtime/vue/server.d.ts",
+      "import": "./dist/runtime/vue/server.js"
     }
   },
   "publishConfig": {
@@ -49,7 +99,7 @@
   "scripts": {
     "build": "pnpm run clean && tsc -b tsconfig.json && chmod +x dist/cli/index.js",
     "build:bundle": "node scripts/bundle-cli.mjs",
-    "check:types": "tsc -b tsconfig.json && tsc -p tsconfig.test.json",
+    "check:types": "tsc -b tsconfig.json",
     "start": "tsx src/cli/index.ts",
     "install-cli": "pnpm build && node scripts/install-cli.mjs",
     "publish:npm": "node scripts/publish-npm.mjs",
@@ -62,16 +112,23 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "dependencies": {
+    "@clack/core": "^1.2.0",
+    "@clack/prompts": "^1.2.0",
     "@rollup/pluginutils": "^5.1.0",
+    "agent-install": "^0.0.5",
+    "better-auth": "1.4.18",
     "change-case": "^5.4.4",
+    "cheerio": "^1.0.0",
+    "commander": "^13.1.0",
     "eta": "^3.5.0",
+    "lucide-react": "^0.577.0",
+    "open": "^10.1.2",
     "oxc-parser": "^0.118.0",
     "react-error-boundary": "^6.0.0",
+    "yaml": "2.8.2",
     "zod": "4.1.8"
   },
   "devDependencies": {
-    "@clack/core": "^1.2.0",
-    "@clack/prompts": "^1.2.0",
     "@fimo/agents-bundle": "workspace:*",
     "@fimo/api-contracts": "workspace:*",
     "@fimo/cli-kit": "workspace:*",
@@ -80,12 +137,7 @@
     "@types/node": "^22.15.29",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "agent-install": "^0.0.5",
-    "better-auth": "1.4.18",
-    "cheerio": "^1.0.0",
-    "commander": "^13.1.0",
     "esbuild": "^0.25.10",
-    "open": "^10.1.2",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "react-router": "^7.15.1",
@@ -93,30 +145,43 @@
     "typescript": "5.9.2",
     "vite": "^8.0.13",
     "vitest": "^4.1.6",
-    "wrangler": "^4.83.0",
-    "yaml": "2.8.2"
+    "wrangler": "^4.83.0"
   },
   "peerDependencies": {
+    "@remix-run/react": ">=2.0.0",
+    "@sveltejs/kit": ">=2.0.0",
     "@tanstack/react-query": "^5.80.6",
+    "astro": ">=4.0.0",
+    "next": ">=14.0.0",
+    "nuxt": ">=3.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "react-router": "^7.0.0 || ^8.0.0",
-    "vite": "^7.0.0 || ^8.0.0"
+    "react-router": "^7.0.0",
+    "vue": ">=3.0.0"
   },
   "peerDependenciesMeta": {
     "@tanstack/react-query": {
       "optional": true
     },
-    "react": {
+    "next": {
       "optional": true
     },
-    "react-dom": {
+    "react-router": {
       "optional": true
     },
-    "react-router": {
+    "@remix-run/react": {
+      "optional": true
+    },
+    "astro": {
+      "optional": true
+    },
+    "nuxt": {
+      "optional": true
+    },
+    "@sveltejs/kit": {
       "optional": true
     },
-    "vite": {
+    "vue": {
       "optional": true
     }
   },

package/scripts/add-ext.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Rewrite relative imports to add `.js` extensions (required by Node ESM).
+// Idempotent. Preserves all other code.
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = resolve(fileURLToPath(import.meta.url), '..');
+const ROOTS = process.argv.slice(2).map((p) => resolve(p));
+
+const IMPORT_RE = /(from\s+|import\s*\(\s*)(['"])(\.\.?\/[^'"\s]+?)\2/g;
+
+function walk(dir, out) {
+  for (const name of readdirSync(dir)) {
+    if (['node_modules', 'dist', '.git'].includes(name)) continue;
+    const p = `${dir}/${name}`;
+    const st = statSync(p);
+    if (st.isDirectory()) walk(p, out);
+    else if (/\.(ts|tsx|mts|mjs)$/.test(name) && !name.endsWith('.d.ts')) out.push(p);
+  }
+}
+
+function rewriteOne(filePath) {
+  const src = readFileSync(filePath, 'utf-8');
+  const dir = filePath.split('/').slice(0, -1).join('/');
+  let mutated = false;
+  const out = src.replace(IMPORT_RE, (match, lead, quote, spec) => {
+    const ext = extname(spec);
+    if (ext) return match;
+    const candidate = resolve(dir, spec);
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+      mutated = true;
+      return `${lead}${quote}${spec}/index.js${quote}`;
+    }
+    mutated = true;
+    return `${lead}${quote}${spec}.js${quote}`;
+  });
+  if (mutated) {
+    writeFileSync(filePath, out);
+    console.log(`updated ${filePath.slice(HERE.length - 7)}`);
+  }
+}
+
+const files = [];
+for (const r of ROOTS) walk(r, files);
+for (const f of files) rewriteOne(f);
+console.log(`[add-ext] processed ${files.length} files`);

package/scripts/bump-version.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Bumps the Fimo CLI version in apps/cli/package.json — NO git tag, NO commit.
+//
+// Under the branch-driven release model the version lives in
+// apps/cli/package.json and you bump it in a PR. CI creates the
+// `cli@<version>` git tag when it publishes `@latest` on a `production`
+// merge, so this script must NOT create a tag — that would collide with
+// CI's tag-guard (the publish would skip, thinking the version already
+// shipped).
+//
+// Usage:
+//   pnpm -F fimo release:bump patch
+//   pnpm -F fimo release:bump minor
+//   pnpm -F fimo release:bump major
+//   pnpm -F fimo release:bump 1.2.3            # explicit version
+//
+// After bumping, commit the change in your PR. Merging it through to
+// `production` is what publishes `@latest` and creates the tag.
+
+import { spawnSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = resolve(HERE, '..');
+
+const VALID_INCREMENTS = new Set(['major', 'minor', 'patch', 'premajor', 'preminor', 'prepatch', 'prerelease']);
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.error(
+    '[cli/bump] usage: pnpm -F fimo release:bump <patch|minor|major|premajor|preminor|prepatch|prerelease|X.Y.Z> [--preid <id>]'
+  );
+  process.exit(1);
+}
+
+const increment = args[0];
+const isExplicitVersion = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/.test(increment);
+if (!VALID_INCREMENTS.has(increment) && !isExplicitVersion) {
+  console.error(
+    `[cli/bump] invalid increment "${increment}". expected one of ${[...VALID_INCREMENTS].join('|')} or an explicit X.Y.Z.`
+  );
+  process.exit(1);
+}
+
+// Bump package.json ONLY — `--no-git-tag-version` skips both the commit and
+// the tag. CI owns the `cli@<version>` tag (created on the @latest publish).
+// Use pnpm (not npm) — npm chokes on the `workspace:*` devDeps.
+const versionArgs = ['version', '--no-git-tag-version', ...args];
+console.log(`[cli/bump] $ pnpm ${versionArgs.join(' ')}`);
+const result = spawnSync('pnpm', versionArgs, { cwd: CLI_ROOT, stdio: 'inherit' });
+if (result.status !== 0) {
+  console.error(`[cli/bump] pnpm version failed (exit ${result.status}).`);
+  process.exit(result.status ?? 1);
+}
+
+console.log('[cli/bump] bumped apps/cli/package.json (no tag, no commit).');
+console.log('[cli/bump] commit it in your PR — merging to `production` publishes @latest + tags it.');