fimo 0.6.0 → 0.7.0-experimental.10

package/dist/scripts/frameworks/support.js

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const REACT_CHECK = {
+    pkg: 'react',
+    min: '18.0.0',
+    label: 'React',
+    reason: "Fimo's inline-editing runtime uses React 18 APIs (useSyncExternalStore).",
+    remedy: 'Upgrade React to 18 or newer. The content still migrates on older React; only inline editing needs 18+.',
+};
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export function supportChecksFor(detection) {
+    switch (detection.framework) {
+        case 'next':
+        case 'remix':
+        case 'react-router':
+            return [REACT_CHECK];
+        case 'vite':
+            return detection.react ? [REACT_CHECK] : [];
+        case 'nuxt':
+            return [
+                {
+                    pkg: 'nuxt',
+                    min: '3.0.0',
+                    label: 'Nuxt',
+                    reason: 'Fimo supports Nuxt 3+ (Vue 3). Nuxt 2 is end-of-life.',
+                    remedy: 'Upgrade to Nuxt 3 or newer.',
+                },
+            ];
+        case 'vue':
+            return [
+                {
+                    pkg: 'vue',
+                    min: '3.0.0',
+                    label: 'Vue',
+                    reason: 'Fimo supports Vue 3+. Vue 2 is end-of-life.',
+                    remedy: 'Upgrade to Vue 3 or newer.',
+                },
+            ];
+        case 'astro':
+            return [
+                {
+                    pkg: 'astro',
+                    min: '4.0.0',
+                    label: 'Astro',
+                    reason: 'Fimo supports Astro 4+.',
+                    remedy: 'Upgrade Astro to 4 or newer.',
+                },
+            ];
+        case 'sveltekit':
+            return [
+                {
+                    pkg: '@sveltejs/kit',
+                    min: '2.0.0',
+                    label: 'SvelteKit',
+                    reason: 'Fimo supports SvelteKit 2+.',
+                    remedy: 'Upgrade @sveltejs/kit to 2 or newer.',
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export function parseVersionFloor(spec) {
+    if (!spec) {
+        return null;
+    }
+    // A `||` union — the floor is the lowest branch, i.e. the first token.
+    const first = spec.split('||')[0];
+    const match = first.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: match[2] ? Number(match[2]) : 0,
+        patch: match[3] ? Number(match[3]) : 0,
+        raw: spec.trim(),
+    };
+}
+function isBelowFloor(found, min) {
+    const floor = parseVersionFloor(min);
+    if (!floor) {
+        return false;
+    }
+    if (found.major !== floor.major) {
+        return found.major < floor.major;
+    }
+    if (found.minor !== floor.minor) {
+        return found.minor < floor.minor;
+    }
+    return found.patch < floor.patch;
+}
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export function readHostVersion(cwd, pkg) {
+    const installed = join(cwd, 'node_modules', pkg, 'package.json');
+    if (existsSync(installed)) {
+        try {
+            const version = JSON.parse(readFileSync(installed, 'utf8')).version;
+            const parsed = parseVersionFloor(String(version));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // fall through to the declared range
+        }
+    }
+    const rootPkg = join(cwd, 'package.json');
+    if (existsSync(rootPkg)) {
+        try {
+            const pkgJson = JSON.parse(readFileSync(rootPkg, 'utf8'));
+            const spec = { ...pkgJson.dependencies, ...pkgJson.devDependencies }[pkg];
+            if (spec) {
+                return parseVersionFloor(String(spec));
+            }
+        }
+        catch {
+            // unreadable — nothing to gate on
+        }
+    }
+    return null;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export function checkHostSupport(cwd, detection) {
+    const violations = [];
+    const detected = [];
+    for (const check of supportChecksFor(detection)) {
+        const found = readHostVersion(cwd, check.pkg);
+        if (!found) {
+            continue;
+        }
+        detected.push({ label: check.label, version: found.raw });
+        if (isBelowFloor(found, check.min)) {
+            violations.push({
+                subject: check.label,
+                found: found.raw,
+                min: check.min,
+                headline: `${check.label} ${found.raw} is below Fimo's floor of ${check.label} ${check.min}. ${check.reason}`,
+                remedy: check.remedy,
+            });
+        }
+    }
+    return { ok: violations.length === 0, violations, detected };
+}

package/dist/scripts/frameworks/support.test.d.ts

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

package/dist/scripts/frameworks/support.test.js

@@ -0,0 +1,87 @@
+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 { checkHostSupport, parseVersionFloor, readHostVersion } from './support.js';
+let dir;
+function project(pkg, installed = {}) {
+    dir = mkdtempSync(join(tmpdir(), 'host-support-'));
+    writeFileSync(join(dir, 'package.json'), JSON.stringify(pkg));
+    for (const [name, version] of Object.entries(installed)) {
+        const modDir = join(dir, 'node_modules', name);
+        mkdirSync(modDir, { recursive: true });
+        writeFileSync(join(modDir, 'package.json'), JSON.stringify({ name, version }));
+    }
+    return dir;
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('parseVersionFloor', () => {
+    it('reads the lowest concrete version from real spec shapes', () => {
+        expect(parseVersionFloor('^18.2.0')).toMatchObject({ major: 18, minor: 2, patch: 0 });
+        expect(parseVersionFloor('>=2.0.0')).toMatchObject({ major: 2, minor: 0, patch: 0 });
+        expect(parseVersionFloor('~3.4')).toMatchObject({ major: 3, minor: 4, patch: 0 });
+        expect(parseVersionFloor('18')).toMatchObject({ major: 18, minor: 0, patch: 0 });
+        // a `||` union floors on the lowest (first) branch
+        expect(parseVersionFloor('^17.0.0 || ^18.0.0')).toMatchObject({ major: 17 });
+    });
+    it('returns null for specs with no numeric floor', () => {
+        expect(parseVersionFloor('latest')).toBeNull();
+        expect(parseVersionFloor('*')).toBeNull();
+        expect(parseVersionFloor('workspace:*')).toBeNull();
+        expect(parseVersionFloor('')).toBeNull();
+    });
+});
+describe('readHostVersion', () => {
+    it('prefers the installed manifest over the declared range', () => {
+        const cwd = project({ dependencies: { react: '^18.0.0' } }, { react: '18.3.1' });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 18, minor: 3, patch: 1 });
+    });
+    it('falls back to the declared range when nothing is installed', () => {
+        const cwd = project({ dependencies: { react: '^19.0.0' } });
+        expect(readHostVersion(cwd, 'react')).toMatchObject({ major: 19, minor: 0, patch: 0 });
+    });
+    it('returns null when the dependency is absent', () => {
+        const cwd = project({ dependencies: {} });
+        expect(readHostVersion(cwd, 'react')).toBeNull();
+    });
+});
+describe('checkHostSupport', () => {
+    it('passes a Next.js site on React 18', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^18.2.0' } }, { react: '18.3.1' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(true);
+        expect(result.violations).toEqual([]);
+        expect(result.detected).toContainEqual({ label: 'React', version: '18.3.1' });
+    });
+    it('passes a Next.js site on React 19', () => {
+        const cwd = project({ dependencies: { next: '16.2.11', react: '^19.0.0' } }, { react: '19.0.0' });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+    it('flags a React 17 site below the floor with an actionable message', () => {
+        const cwd = project({ dependencies: { next: '13.0.0', react: '^17.0.2' } }, { react: '17.0.2' });
+        const result = checkHostSupport(cwd, { framework: 'next' });
+        expect(result.ok).toBe(false);
+        expect(result.violations).toHaveLength(1);
+        expect(result.violations[0]).toMatchObject({ subject: 'React', min: '18.0.0' });
+        expect(result.violations[0].headline).toContain('React 17.0.2');
+        expect(result.violations[0].remedy).toMatch(/upgrade react/i);
+    });
+    it('flags a Nuxt 2 site below the floor', () => {
+        const cwd = project({ dependencies: { nuxt: '^2.17.0' } }, { nuxt: '2.17.0' });
+        const result = checkHostSupport(cwd, { framework: 'nuxt' });
+        expect(result.ok).toBe(false);
+        expect(result.violations[0]).toMatchObject({ subject: 'Nuxt', min: '3.0.0' });
+    });
+    it('does not gate a non-React bare Vite site', () => {
+        const cwd = project({ dependencies: { vite: '^5.0.0' } });
+        expect(checkHostSupport(cwd, { framework: 'vite', react: false }).ok).toBe(true);
+    });
+    it('does not gate on a version it cannot read', () => {
+        const cwd = project({ dependencies: { next: '16.0.0', react: 'workspace:*' } });
+        expect(checkHostSupport(cwd, { framework: 'next' }).ok).toBe(true);
+    });
+});

package/dist/scripts/frameworks/sveltekit/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** SvelteKit routes: every directory under src/routes holding a +page file. */
+export declare function discoverSvelteKitRoutes(routesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/sveltekit/routes.js

@@ -0,0 +1,50 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+function pushRoute(routes, parts) {
+    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+    routes.push({
+        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+        path: routePath,
+        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
+    });
+}
+const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+/** SvelteKit routes: every directory under src/routes holding a +page file. */
+export function discoverSvelteKitRoutes(routesDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        if (entries.some((entry) => /^\+page\.(svelte|md)$/.test(entry))) {
+            // Route groups (parens) are layout-only segments.
+            pushRoute(routes, segments.filter((seg) => !seg.startsWith('(')));
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            try {
+                if (statSync(full).isDirectory()) {
+                    walk(full, [...segments, toSegment(entry)]);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    };
+    walk(routesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/sveltekit/template-style.d.ts

@@ -0,0 +1,9 @@
+import { type TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * SvelteKit template wraps. The t binding is deliberately a mode-agnostic
+ * `const` — a `$derived` flips a legacy component into runes mode (breaking
+ * its own `$:` statements) and a `$:` reactive runs after init (arrays built
+ * at init see undefined). Labels only change with a reload in edit mode,
+ * which the wrap contract accepts.
+ */
+export declare const svelteTemplateWrapStyle: TemplateWrapStyle;

package/dist/scripts/frameworks/sveltekit/template-style.js

@@ -0,0 +1,54 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { injectIntoInstanceScript } from '../../apply-wrap-templates.js';
+import { slugify } from '../../apply-wrap.js';
+/**
+ * SvelteKit template wraps. The t binding is deliberately a mode-agnostic
+ * `const` — a `$derived` flips a legacy component into runes mode (breaking
+ * its own `$:` statements) and a `$:` reactive runs after init (arrays built
+ * at init see undefined). Labels only change with a reload in edit mode,
+ * which the wrap contract accepts.
+ */
+export const svelteTemplateWrapStyle = {
+    ext: '.svelte',
+    head: "import { page } from '$app/stores';\n\timport { makeFimoT } from 'fimo/svelte';\n\tconst t = makeFimoT($page.data.fimoLabels);",
+    headMarker: /makeFimoT/,
+    open: '{t(',
+    close: ')}',
+    injectHead: (code, head) => injectIntoInstanceScript(code, head, '<script>'),
+    // Route-convention filenames carry no meaning: scope +page/+layout keys by
+    // their route directory (src/routes/pricing/+page.svelte -> "pricing").
+    fileScope: (file) => {
+        const stem = basename(file).replace(/\.svelte$/, '');
+        if (!stem.startsWith('+')) {
+            return null;
+        }
+        const dir = basename(dirname(file));
+        if (!dir || dir === 'routes' || dir === 'src') {
+            return stem === '+layout' ? 'layout' : 'home';
+        }
+        return slugify(dir) || 'home';
+    },
+    // The store form reads $page.data.fimoLabels: wire the root server load
+    // once when the project has none. An existing +layout.server.* is agent
+    // work (merging into a user load function is judgment, and until then the
+    // inline fallbacks keep rendering identical).
+    ensureWiring: (rootDir) => {
+        const routesDir = join(rootDir, 'src', 'routes');
+        const existing = ['+layout.server.js', '+layout.server.ts'].some((name) => existsSync(join(routesDir, name)));
+        if (existing || !existsSync(routesDir)) {
+            return [];
+        }
+        const layoutPath = join(routesDir, '+layout.server.js');
+        writeFileSync(layoutPath, [
+            "import { loadFimoLabels } from 'fimo/svelte/server';",
+            '',
+            'export const load = async () => {',
+            '\tconst labels = await loadFimoLabels();',
+            '\treturn { fimoLabels: labels.dictionaries[labels.defaultLocale] ?? {} };',
+            '};',
+            '',
+        ].join('\n'));
+        return ['src/routes/+layout.server.js'];
+    },
+};

package/dist/scripts/frameworks/vite/routes.d.ts

@@ -0,0 +1,15 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/**
+ * Route discovery for Vite React SPAs: there is no file convention, so the
+ * routes live in react-router code. v1 reads LITERAL, ABSOLUTE paths from the
+ * two mainstream declaration shapes —
+ *
+ *   <Route path="/pricing" element={…} />          (JSX tree)
+ *   createBrowserRouter([{ path: '/pricing', … }])  (object form)
+ *
+ * — in files that import react-router. Relative child paths and index routes
+ * need the router's nesting semantics to resolve; they (and `*` wildcards)
+ * stay out of v1: the fimo-config route registry accepts manual entries for
+ * anything the scan cannot see, and scanned routes only ever ADD to it.
+ */
+export declare function discoverReactRouterDomRoutes(rootDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/vite/routes.js

@@ -0,0 +1,93 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+const ROUTE_SOURCE = /\.(tsx|jsx|ts|js)$/;
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', '.git']);
+/**
+ * Route discovery for Vite React SPAs: there is no file convention, so the
+ * routes live in react-router code. v1 reads LITERAL, ABSOLUTE paths from the
+ * two mainstream declaration shapes —
+ *
+ *   <Route path="/pricing" element={…} />          (JSX tree)
+ *   createBrowserRouter([{ path: '/pricing', … }])  (object form)
+ *
+ * — in files that import react-router. Relative child paths and index routes
+ * need the router's nesting semantics to resolve; they (and `*` wildcards)
+ * stay out of v1: the fimo-config route registry accepts manual entries for
+ * anything the scan cannot see, and scanned routes only ever ADD to it.
+ */
+export function discoverReactRouterDomRoutes(rootDir) {
+    const srcDir = join(rootDir, 'src');
+    const files = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry)) {
+                continue;
+            }
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(full);
+            }
+            else if (ROUTE_SOURCE.test(entry)) {
+                files.push(full);
+            }
+        }
+    };
+    walk(srcDir);
+    const routes = new Map();
+    for (const file of files) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!/from\s+['"]react-router(?:-dom)?['"]/.test(code)) {
+            continue;
+        }
+        const paths = [
+            ...[...code.matchAll(/<Route\b[^>]*\bpath\s*=\s*(?:"([^"]+)"|'([^']+)'|\{\s*(?:"([^"]+)"|'([^']+)')\s*\})/g)],
+            ...[...code.matchAll(/\bpath\s*:\s*(?:"([^"]+)"|'([^']+)')/g)],
+        ]
+            .map((match) => match.slice(1).find(Boolean))
+            .filter((path) => typeof path === 'string');
+        for (const raw of paths) {
+            if (!raw.startsWith('/') || raw.includes('*')) {
+                continue;
+            }
+            const path = raw !== '/' && raw.endsWith('/') ? raw.slice(0, -1) : raw;
+            if (routes.has(path)) {
+                continue;
+            }
+            const parts = path.split('/').filter(Boolean);
+            const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+            routes.set(path, {
+                id: path === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+                path,
+                label: path === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? path),
+            });
+        }
+    }
+    return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
+}

package/dist/scripts/frameworks/vite/routes.test.d.ts

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

package/dist/scripts/frameworks/vite/routes.test.js

@@ -0,0 +1,73 @@
+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 { discoverReactRouterDomRoutes } from './routes.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'vite-routes-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('discoverReactRouterDomRoutes', () => {
+    it('reads literal absolute paths from JSX Route trees', () => {
+        const root = project({
+            'src/App.tsx': `import { BrowserRouter, Route, Routes } from 'react-router-dom';
+export function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/about" element={<About />} />
+        <Route path="/features/pricing" element={<Pricing />} />
+        <Route path={'/contact'} element={<Contact />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}
+`,
+        });
+        const routes = discoverReactRouterDomRoutes(root);
+        expect(routes.map((route) => route.path)).toEqual(['/', '/about', '/contact', '/features/pricing']);
+        expect(routes[0]).toEqual({ id: 'home', path: '/', label: 'Home' });
+        expect(routes.find((route) => route.path === '/features/pricing')).toEqual({
+            id: 'features-pricing',
+            path: '/features/pricing',
+            label: 'Pricing',
+        });
+    });
+    it('reads object-form routers and keeps :params, skipping wildcards and relative paths', () => {
+        const root = project({
+            'src/router.ts': `import { createBrowserRouter } from 'react-router-dom';
+export const router = createBrowserRouter([
+  { path: '/', element: null },
+  { path: '/posts/:slug', element: null },
+  { path: '*', element: null },
+  { path: 'relative-child', element: null },
+]);
+`,
+        });
+        const routes = discoverReactRouterDomRoutes(root);
+        expect(routes.map((route) => route.path)).toEqual(['/', '/posts/:slug']);
+        expect(routes.find((route) => route.path === '/posts/:slug')).toEqual({
+            id: 'posts-slug',
+            path: '/posts/:slug',
+            label: 'Posts',
+        });
+    });
+    it('ignores path-shaped literals in files that do not import react-router', () => {
+        const root = project({
+            'src/config.ts': `export const nav = [{ path: '/dashboard', label: 'Dashboard' }];\n`,
+        });
+        expect(discoverReactRouterDomRoutes(root)).toEqual([]);
+    });
+});

package/dist/scripts/frameworks/vite/wiring.d.ts

@@ -0,0 +1,10 @@
+import type { RootWiringResult } from '../next/wiring.js';
+/**
+ * Vite React SPA root wiring: wrap the root render argument with
+ * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
+ * resolves) and import the project's fimo-config.json. Only the mainstream
+ * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
+ * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
+ * Anything else bails with the reason and stays agent work via the recipe.
+ */
+export declare function ensureSpaEntryWiring(cwd: string): RootWiringResult;

package/dist/scripts/frameworks/vite/wiring.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+/**
+ * Vite React SPA root wiring: wrap the root render argument with
+ * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
+ * resolves) and import the project's fimo-config.json. Only the mainstream
+ * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
+ * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
+ * Anything else bails with the reason and stays agent work via the recipe.
+ */
+export function ensureSpaEntryWiring(cwd) {
+    const entryFile = ['src/main.tsx', 'src/main.jsx', 'src/index.tsx', 'src/index.jsx']
+        .map((candidate) => path.join(cwd, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    const bail = (reason, rel = 'src/main.tsx') => ({
+        changes: [],
+        warnings: [`Root wiring not applied: ${reason} — follow the SPA recipe in the agent prompt (${rel}).`],
+        wired: false,
+    });
+    if (!entryFile) {
+        return bail('no src/main or src/index entry file found');
+    }
+    const rel = path.relative(cwd, entryFile);
+    const code = fs.readFileSync(entryFile, 'utf8');
+    if (code.includes('FimoSpaProviders')) {
+        return { changes: [], warnings: [], wired: true };
+    }
+    let program;
+    try {
+        program = parseSync(entryFile, code).program;
+    }
+    catch {
+        return bail('entry file could not be parsed', rel);
+    }
+    // The JSX argument of the root render call, found structurally: a call
+    // whose callee property is `render` with a JSX element first argument
+    // (covers `createRoot(…).render(<X/>)` and `ReactDOM.render(<X/>, node)`).
+    const renderArg = (function find(node) {
+        if (!node || typeof node !== 'object') {
+            return null;
+        }
+        const candidate = node;
+        if (candidate.type === 'CallExpression' &&
+            candidate.callee?.type === 'MemberExpression' &&
+            candidate.callee?.property?.name === 'render' &&
+            (candidate.arguments?.[0]?.type === 'JSXElement' || candidate.arguments?.[0]?.type === 'JSXFragment')) {
+            return candidate.arguments[0];
+        }
+        for (const value of Object.values(candidate)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    const found = find(entry);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            else if (value && typeof value === 'object') {
+                const found = find(value);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    })(program);
+    if (!renderArg) {
+        return bail('no root render call with a JSX argument found', rel);
+    }
+    const configImportPath = path
+        .relative(path.dirname(entryFile), path.join(cwd, 'fimo-config.json'))
+        .split(path.sep)
+        .join('/');
+    const jsx = code.slice(renderArg.start, renderArg.end);
+    const open = '<FimoSpaProviders\n' +
+        '    config={fimoConfig}\n' +
+        '    apiUrl={import.meta.env.VITE_API_URL}\n' +
+        '    previewScriptUrl={import.meta.env.DEV ? import.meta.env.VITE_FIMO_PREVIEW_SCRIPT_URL : undefined}\n' +
+        '  >';
+    let next = code.slice(0, renderArg.start) + `${open}\n    ${jsx}\n  </FimoSpaProviders>` + code.slice(renderArg.end);
+    // AST-positioned like ensureFimoImport: a multiline import's first line is
+    // not the end of the imports.
+    const importBlock = `import { FimoSpaProviders } from 'fimo/react';\nimport fimoConfig from '${configImportPath.startsWith('.') ? configImportPath : `./${configImportPath}`}';`;
+    let lastImportEnd = -1;
+    for (const node of program.body ?? []) {
+        if (node.type === 'ImportDeclaration') {
+            lastImportEnd = node.end;
+        }
+    }
+    // The wrap edit above only touched positions at/after renderArg.start,
+    // which is always beyond the import block, so import spans still hold.
+    next =
+        lastImportEnd >= 0
+            ? `${next.slice(0, lastImportEnd)}\n${importBlock}${next.slice(lastImportEnd)}`
+            : `${importBlock}\n${next}`;
+    fs.writeFileSync(entryFile, next);
+    return { changes: [`wired FimoSpaProviders into ${rel}`], warnings: [], wired: true };
+}