fimo 0.8.0 → 0.9.0-experimental.10

package/dist/scripts/frameworks/next/rewire.js

@@ -0,0 +1,282 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+import { ensureFimoImport } from '../../apply-wrap.js';
+import { routePathForAppPage } from './routes.js';
+function applyEdits(code, edits) {
+    let next = code;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+        next = next.slice(0, edit.start) + edit.replacement + next.slice(edit.end);
+    }
+    return next;
+}
+function walkAll(node, visit) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            walkAll(child, visit);
+        }
+        return;
+    }
+    const record = node;
+    if (typeof record.type === 'string') {
+        visit(record);
+    }
+    for (const [key, value] of Object.entries(record)) {
+        if (key !== 'type' && value && typeof value === 'object') {
+            walkAll(value, visit);
+        }
+    }
+}
+function defaultExportFunction(program) {
+    const exportDefault = (program.body ?? []).find((node) => node.type === 'ExportDefaultDeclaration');
+    if (!exportDefault || exportDefault.declaration?.type !== 'FunctionDeclaration') {
+        return null;
+    }
+    const body = exportDefault.declaration.body;
+    if (!body || (body.type !== 'FunctionBody' && body.type !== 'BlockStatement')) {
+        return null;
+    }
+    return exportDefault.declaration;
+}
+/** Every reference to `name` (outside `ignoredSpans`) must sit inside the
+ *  component body — otherwise moving the binding into the component would
+ *  break module-level consumers (metadata, generateStaticParams, …). */
+function referencesConfinedToFunction(program, name, fn, ignoredSpans) {
+    let confined = true;
+    walkAll(program, (node) => {
+        if (node.type !== 'Identifier' || node.name !== name) {
+            return;
+        }
+        const inIgnored = ignoredSpans.some((span) => node.start >= span.start && node.end <= span.end);
+        const inFn = node.start >= fn.body.start && node.end <= fn.body.end;
+        if (!inIgnored && !inFn) {
+            confined = false;
+        }
+    });
+    return confined;
+}
+function relativeImport(fromFile, toFile) {
+    const rel = path.relative(path.dirname(fromFile), toFile).split(path.sep).join('/');
+    return rel.startsWith('.') ? rel : `./${rel}`;
+}
+function pageFilesUnder(dir) {
+    const out = [];
+    const walk = (current) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (/\.(tsx|jsx|js)$/.test(entry.name)) {
+                out.push(full);
+            }
+        }
+    };
+    if (fs.existsSync(dir)) {
+        walk(dir);
+    }
+    return out;
+}
+export function rewireNextCollectionPages(cwd, detection, scan, drafts) {
+    const changes = [];
+    const warnings = [];
+    const pages = [];
+    let rewired = 0;
+    if (!detection.appDir) {
+        return { changes, warnings: ['Collection pages not rewired: pages-router project.'], rewired, pages };
+    }
+    const appDirAbs = path.join(cwd, detection.appDir);
+    const uidBySourceName = new Map(drafts.map((draft) => [draft.sourceName, draft.uid]));
+    const draftsBySourceFile = new Map();
+    for (const draft of drafts) {
+        const bucket = draftsBySourceFile.get(draft.source) ?? [];
+        bucket.push(draft.uid);
+        draftsBySourceFile.set(draft.source, bucket);
+    }
+    const bail = (page, reason) => {
+        warnings.push(`Page not rewired (${page}): ${reason} — wire it with wrapCollection per the prompt recipe.`);
+    };
+    const recordPage = (fileAbs, uid) => {
+        pages.push({ file: path.relative(cwd, fileAbs), uid, routePath: routePathForAppPage(appDirAbs, fileAbs) });
+    };
+    // Pages wired on a PREVIOUS run still carry binding evidence (the uid in the
+    // call site is final once `adopt-drafts` renamed it) — collect them before
+    // rewiring so re-runs keep feeding the page registry.
+    for (const pageAbs of pageFilesUnder(appDirAbs)) {
+        let code;
+        try {
+            code = fs.readFileSync(pageAbs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const match of code.matchAll(/wrapCollection\(\s*['"]([^'"]+)['"]/g)) {
+            recordPage(pageAbs, match[1]);
+        }
+    }
+    // ── In-code array literals: extract to src/data/<name>.json + wire ──
+    for (const candidate of scan.collections) {
+        const pageAbs = path.join(cwd, candidate.file);
+        if (!pageAbs.startsWith(appDirAbs + path.sep)) {
+            bail(candidate.file, `in-code collection \`${candidate.name}\` sits outside the app directory`);
+            continue;
+        }
+        const uid = uidBySourceName.get(candidate.name);
+        if (!uid) {
+            continue;
+        }
+        const rows = candidate.typedRows;
+        if (!rows || rows.length !== candidate.count) {
+            bail(candidate.file, `\`${candidate.name}\` is larger than the extraction window`);
+            continue;
+        }
+        const code = fs.readFileSync(pageAbs, 'utf8');
+        if (code.includes("'use client'") || code.includes('"use client"')) {
+            bail(candidate.file, 'client component (no server fetch)');
+            continue;
+        }
+        let program;
+        try {
+            program = parseSync(pageAbs, code).program;
+        }
+        catch {
+            bail(candidate.file, 'could not parse');
+            continue;
+        }
+        // `const x = [...]`, `= [...] as const`, `= [...] satisfies T` all count.
+        const isArrayInit = (init) => {
+            const inner = init?.type === 'TSAsExpression' || init?.type === 'TSSatisfiesExpression' ? init.expression : init;
+            return inner?.type === 'ArrayExpression';
+        };
+        const declaration = (program.body ?? []).find((node) => node.type === 'VariableDeclaration' &&
+            node.declarations?.length === 1 &&
+            node.declarations[0]?.id?.name === candidate.name &&
+            isArrayInit(node.declarations[0]?.init));
+        if (!declaration) {
+            bail(candidate.file, `top-level \`const ${candidate.name} = [...]\` not found`);
+            continue;
+        }
+        const fn = defaultExportFunction(program);
+        if (!fn) {
+            bail(candidate.file, 'the default export is not a plain function declaration');
+            continue;
+        }
+        if (!referencesConfinedToFunction(program, candidate.name, fn, [declaration])) {
+            bail(candidate.file, `\`${candidate.name}\` is referenced outside the page component`);
+            continue;
+        }
+        const dataDir = path.join(cwd, 'src', 'data');
+        const dataFileAbs = path.join(dataDir, `${candidate.name}.json`);
+        if (fs.existsSync(dataFileAbs)) {
+            bail(candidate.file, `src/data/${candidate.name}.json already exists`);
+            continue;
+        }
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.writeFileSync(dataFileAbs, `${JSON.stringify(rows, null, 2)}\n`);
+        const edits = [{ start: declaration.start, end: declaration.end, replacement: '' }];
+        if (!fn.async) {
+            edits.push({ start: fn.start, end: fn.start, replacement: 'async ' });
+        }
+        edits.push({
+            start: fn.body.start + 1,
+            end: fn.body.start + 1,
+            replacement: `\n  const ${candidate.name} = await wrapCollection('${uid}', ${candidate.name}Source);\n`,
+        });
+        let next = applyEdits(code, edits);
+        next = `import ${candidate.name}Source from '${relativeImport(pageAbs, dataFileAbs)}';\n${next}`;
+        next = ensureFimoImport(next, ['wrapCollection'], 'fimo/next/server');
+        fs.writeFileSync(pageAbs, next);
+        rewired += 1;
+        recordPage(pageAbs, uid);
+        changes.push(`rewired ${candidate.file}: \`${candidate.name}\` extracted to src/data/${candidate.name}.json and read through wrapCollection('${uid}')`);
+    }
+    // ── Data-file default imports: wire the importing pages ──
+    const dataFileUids = new Map();
+    for (const dataFile of scan.dataFiles) {
+        const uids = draftsBySourceFile.get(dataFile.file);
+        if (uids && uids.length === 1 && /\.json$/i.test(dataFile.file)) {
+            dataFileUids.set(path.resolve(cwd, dataFile.file), uids[0]);
+        }
+    }
+    if (dataFileUids.size > 0) {
+        for (const pageAbs of pageFilesUnder(appDirAbs)) {
+            const code = fs.readFileSync(pageAbs, 'utf8');
+            const rel = path.relative(cwd, pageAbs);
+            if (!code.includes('src/data/')) {
+                continue;
+            }
+            if (code.includes('wrapCollection(')) {
+                continue;
+            }
+            let program;
+            try {
+                program = parseSync(pageAbs, code).program;
+            }
+            catch {
+                continue;
+            }
+            const imports = (program.body ?? []).filter((node) => node.type === 'ImportDeclaration' && typeof node.source?.value === 'string');
+            const targets = [];
+            for (const declaration of imports) {
+                const specifier = (declaration.specifiers ?? []).find((entry) => entry.type === 'ImportDefaultSpecifier');
+                if (!specifier || !declaration.source.value.startsWith('.')) {
+                    continue;
+                }
+                const resolved = path.resolve(path.dirname(pageAbs), declaration.source.value);
+                const uid = dataFileUids.get(resolved);
+                if (uid) {
+                    targets.push({ node: declaration, local: specifier.local.name, uid });
+                }
+            }
+            if (targets.length === 0) {
+                continue;
+            }
+            if (code.includes("'use client'") || code.includes('"use client"')) {
+                bail(rel, 'client component (no server fetch)');
+                continue;
+            }
+            const fn = defaultExportFunction(program);
+            if (!fn) {
+                bail(rel, 'the default export is not a plain function declaration');
+                continue;
+            }
+            const confined = targets.every((target) => referencesConfinedToFunction(program, target.local, fn, [target.node]));
+            if (!confined) {
+                bail(rel, 'the imported collection is referenced outside the page component');
+                continue;
+            }
+            const edits = [];
+            if (!fn.async) {
+                edits.push({ start: fn.start, end: fn.start, replacement: 'async ' });
+            }
+            for (const target of targets) {
+                const specifier = (target.node.specifiers ?? []).find((entry) => entry.type === 'ImportDefaultSpecifier');
+                edits.push({
+                    start: specifier.local.start,
+                    end: specifier.local.end,
+                    replacement: `${target.local}Source`,
+                });
+                edits.push({
+                    start: fn.body.start + 1,
+                    end: fn.body.start + 1,
+                    replacement: `\n  const ${target.local} = await wrapCollection('${target.uid}', ${target.local}Source);\n`,
+                });
+            }
+            let next = applyEdits(code, edits);
+            next = ensureFimoImport(next, ['wrapCollection'], 'fimo/next/server');
+            fs.writeFileSync(pageAbs, next);
+            rewired += 1;
+            for (const target of targets) {
+                recordPage(pageAbs, target.uid);
+            }
+            changes.push(`rewired ${rel}: ${targets.map((target) => `wrapCollection('${target.uid}')`).join(', ')} over the imported source rows`);
+        }
+    }
+    return { changes, warnings, rewired, pages };
+}

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

@@ -0,0 +1,30 @@
+import { type RouteFileResolution, type RouteLike } from '../../routes/module-resolve.js';
+export interface DiscoveredRoute {
+    id: string;
+    path: string;
+    /** The source file that renders this route (file-based frameworks set it;
+     *  code-declared routers resolve files separately). */
+    file?: string;
+    label: string;
+}
+/**
+ * Route path for ONE app-router page file, using the same segment
+ * normalization as discovery — so a rewired page can be joined back to its
+ * registry route. Returns null for non-routable locations (`@slot`, `_lib`).
+ */
+export declare function routePathForAppPage(appDir: string, pageFile: string): string | null;
+/**
+ * Discover page routes of a Next.js app-router directory (`app/` or
+ * `src/app/`). Returns display routes for `fimo-config.json#routes` so the
+ * Studio page switcher can enumerate a wrapped site's pages.
+ */
+export declare function discoverNextRoutes(appDir: string): DiscoveredRoute[];
+/**
+ * Pages-router discovery (`pages/` or `src/pages/`): every module is a route
+ * except `_app`/`_document`/`_error` and `api/`. `[param]` segments map to
+ * `:param` (the parity capture skips dynamic routes, same as app router).
+ */
+export declare function discoverNextPagesRoutes(pagesDir: string): DiscoveredRoute[];
+/** Registry-routed (frameworkRouteFiles): registry route ids → the app-dir
+ *  page files that render them, joined by routePathForAppPage. */
+export declare function resolveNextRouteFiles(cwd: string, routes: Record<string, RouteLike>): RouteFileResolution[];

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

@@ -0,0 +1,176 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { discoveredRouteLabel } from '../../lib/humanize.js';
+import { walkFiles } from '../../routes/module-resolve.js';
+const PAGE_FILES = new Set(['page.tsx', 'page.jsx', 'page.ts', 'page.js', 'page.mdx']);
+function segmentToPath(segment) {
+    // Route groups `(marketing)` don't contribute URL segments. Parallel-route
+    // slots `@modal` and private folders `_lib` are not standalone pages.
+    if (segment.startsWith('(')) {
+        return '';
+    }
+    if (segment.startsWith('@') || segment.startsWith('_')) {
+        return null;
+    }
+    const catchAll = segment.match(/^\[\.\.\.(.+)\]$/) ?? segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+    if (catchAll) {
+        return `:${catchAll[1]}*`;
+    }
+    const param = segment.match(/^\[(.+)\]$/);
+    if (param) {
+        return `:${param[1]}`;
+    }
+    return segment;
+}
+/**
+ * Route path for ONE app-router page file, using the same segment
+ * normalization as discovery — so a rewired page can be joined back to its
+ * registry route. Returns null for non-routable locations (`@slot`, `_lib`).
+ */
+export function routePathForAppPage(appDir, pageFile) {
+    const rel = relative(appDir, pageFile);
+    if (rel.startsWith('..')) {
+        return null;
+    }
+    const segments = rel.split(sep).slice(0, -1);
+    const parts = [];
+    for (const segment of segments) {
+        const mapped = segmentToPath(segment);
+        if (mapped === null) {
+            return null;
+        }
+        if (mapped.length > 0) {
+            parts.push(mapped);
+        }
+    }
+    return `/${parts.join('/')}`.replace(/\/+/g, '/');
+}
+/**
+ * Discover page routes of a Next.js app-router directory (`app/` or
+ * `src/app/`). Returns display routes for `fimo-config.json#routes` so the
+ * Studio page switcher can enumerate a wrapped site's pages.
+ */
+export function discoverNextRoutes(appDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        if (entries.some((entry) => PAGE_FILES.has(entry))) {
+            const parts = segments.filter((s) => s.length > 0);
+            const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+            routes.push({
+                id: routePath === '/' ? 'home' : parts.map((p) => p.replace(/^:/, '')).join('-'),
+                path: routePath,
+                label: discoveredRouteLabel(routePath),
+            });
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (!isDir) {
+                continue;
+            }
+            const mapped = segmentToPath(entry);
+            if (mapped === null) {
+                continue;
+            }
+            walk(full, [...segments, mapped]);
+        }
+    };
+    walk(appDir, []);
+    return routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+const PAGES_EXTENSIONS = /\.(tsx|jsx|ts|js)$/;
+const PAGES_SKIP = new Set(['api']);
+/**
+ * Pages-router discovery (`pages/` or `src/pages/`): every module is a route
+ * except `_app`/`_document`/`_error` and `api/`. `[param]` segments map to
+ * `:param` (the parity capture skips dynamic routes, same as app router).
+ */
+export function discoverNextPagesRoutes(pagesDir) {
+    const routes = [];
+    const toSegment = (name) => name
+        .replace(/^\[\.\.\.(.+)\]$/, ':$1')
+        .replace(/^\[\[\.\.\.(.+)\]\]$/, ':$1')
+        .replace(/^\[(.+)\]$/, ':$1');
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                // api/ is only special at the pages root.
+                if (!(segments.length === 0 && PAGES_SKIP.has(entry))) {
+                    walk(full, [...segments, toSegment(entry)]);
+                }
+                continue;
+            }
+            if (!PAGES_EXTENSIONS.test(entry)) {
+                continue;
+            }
+            const base = entry.replace(PAGES_EXTENSIONS, '');
+            if (base.startsWith('_')) {
+                continue;
+            }
+            const parts = base === 'index' ? segments : [...segments, toSegment(base)];
+            const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+            routes.push({
+                id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+                path: routePath,
+                label: discoveredRouteLabel(routePath),
+            });
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}
+/** Registry-routed (frameworkRouteFiles): registry route ids → the app-dir
+ *  page files that render them, joined by routePathForAppPage. */
+export function resolveNextRouteFiles(cwd, routes) {
+    const appDir = [join(cwd, 'app'), join(cwd, 'src', 'app')].find((dir) => existsSync(dir));
+    if (!appDir) {
+        return [];
+    }
+    const PAGE_FILE = /^page\.(?:tsx|jsx|ts|js|mdx)$/;
+    const pageFiles = [];
+    walkFiles(appDir, (name) => PAGE_FILE.test(name), pageFiles);
+    const byPath = new Map();
+    for (const [routeId, route] of Object.entries(routes)) {
+        if (typeof route?.path === 'string') {
+            byPath.set(route.path, routeId);
+        }
+    }
+    const resolutions = [];
+    for (const file of pageFiles) {
+        const routePath = routePathForAppPage(appDir, file);
+        const routeId = routePath ? byPath.get(routePath) : undefined;
+        if (routeId) {
+            resolutions.push({ routeId, file });
+        }
+    }
+    return resolutions;
+}

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

@@ -0,0 +1,33 @@
+import type { FrameworkDetection } from '../../detect-framework.js';
+/**
+ * Next.js-side wrap wiring: everything the wrap migration must touch that is
+ * specific to this framework lives HERE, not in the generic flow. Mirror this
+ * module when adding a framework (see the fimo-framework-adapter skill).
+ */
+export declare function ensureNextWiring(cwd: string): {
+    changes: string[];
+    warnings: string[];
+};
+export interface RootWiringResult {
+    changes: string[];
+    warnings: string[];
+    /** True when the root wiring is in place (pre-existing or just applied). */
+    wired: boolean;
+}
+/**
+ * Candidate app-router root-layout files: the direct `<appDir>/layout.*` plus,
+ * for i18n apps that place the `<html>` layout under a dynamic segment
+ * (next-intl's `app/[locale]/layout.tsx`), any `<appDir>/[segment]/layout.*`.
+ * Existing files only, in resolution order.
+ */
+export declare function nextRootLayoutFiles(cwd: string, appDir: string): string[];
+/**
+ * Wire the app-router root layout deterministically: imports, async default
+ * export, loader calls, `<FimoNextScripts />` in head, and `{children}`
+ * wrapped in `<FimoNextProviders>`. Only the provably safe shape is touched —
+ * one default-exported function whose JSX returns `<html>…<body>` with a
+ * `{children}` expression somewhere inside body (create-next-app and its
+ * variants). Anything else bails with the reason, and the agent prompt keeps
+ * the manual recipe.
+ */
+export declare function ensureNextLayoutWiring(cwd: string, detection: Pick<FrameworkDetection, 'appDir'>): RootWiringResult;