fimo 0.9.0-experimental.4 → 0.9.0-experimental.6

package/dist/scripts/lib/discover-next-routes.js

@@ -0,0 +1,134 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const PAGE_FILES = new Set(['page.tsx', 'page.jsx', 'page.ts', 'page.js', 'page.mdx']);
+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 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;
+}
+/**
+ * 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, '/');
+            const lastStatic = [...parts].reverse().find((p) => !p.startsWith(':'));
+            routes.push({
+                id: routePath === '/' ? 'home' : parts.map((p) => p.replace(/^:/, '')).join('-'),
+                path: routePath,
+                label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? 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, '/');
+            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),
+            });
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/routes/bindings.d.ts

@@ -0,0 +1,93 @@
+import type { CmsCollectionSchema } from '../cms/types.js';
+/**
+ * Page-binding evidence for the page registry (`fimo-config.json#routes`).
+ * A dynamic page template (`/blog/:slug`) is only navigable in the Studio
+ * preview once its content param carries a binding
+ * `{ schema, queryField, displayField }` — the schema whose entries
+ * materialize the page instances. No binding can be inferred with certainty,
+ * so this module grades evidence: `strong` bindings are written by the
+ * machine, `candidate` ones ship to the agent prompt as ready-to-apply
+ * suggestions. Neutral: evidence comes in as plain route/schema facts; the
+ * framework and CMS specifics stay in their adapters.
+ */
+export interface PageParamBinding {
+    schema: string;
+    queryField: string;
+    displayField: string;
+}
+export interface PageBinding {
+    routeId: string;
+    path: string;
+    param: string;
+    binding: PageParamBinding;
+    confidence: 'strong' | 'candidate';
+    source: 'rewire' | 'cms-wiring';
+}
+export interface UnboundPage {
+    id: string;
+    path: string;
+    candidates: PageBinding[];
+}
+export interface PageBindingsResult {
+    /** Written into the registry by the caller. */
+    strong: PageBinding[];
+    /** Dynamic pages left without params — with any candidate suggestions. */
+    unbound: UnboundPage[];
+    /** Dynamic pages that already carry params (manual or a prior run). */
+    bound: Array<{
+        id: string;
+        path: string;
+    }>;
+}
+/** A list page known to render a collection (the page-rewire join). */
+export interface ListPageEvidence {
+    routePath: string | null;
+    schema: string;
+}
+export interface SchemaFieldsLike {
+    readonly [field: string]: {
+        readonly type?: string;
+    };
+}
+export declare function isLocaleParam(name: string): boolean;
+interface ParsedDynamicPath {
+    /** The trailing content param name (without `:`/`*`). */
+    contentParam: string;
+    /** Route path minus the trailing content-param segment. */
+    parentPath: string;
+}
+/**
+ * A bindable dynamic path = optional locale-ish params + ONE trailing content
+ * param (catch-all or plain). Anything else (multiple content params) needs
+ * judgment beyond a single binding.
+ */
+export declare function parseDynamicPath(path: string): ParsedDynamicPath | null;
+/** First title-ish string field of a schema — the picker label the Studio
+ *  shows. Null when the schema has none (binding downgrades to candidate). */
+export declare function displayFieldFor(fields: SchemaFieldsLike | undefined): string | null;
+/** CMS collections that structurally look like page-builder page types: a
+ *  top-level dynamic-zone (blocks oneOf) field. Structural, never name-based. */
+export declare function cmsPageTypeEvidence(schemas: readonly CmsCollectionSchema[]): Array<{
+    schema: string;
+    fields: SchemaFieldsLike;
+}>;
+export declare function collectPageBindings(options: {
+    routes: Record<string, {
+        path?: string;
+        params?: unknown;
+    }>;
+    /** Rewired list pages (route-space, from the framework adapter). */
+    listPages?: readonly ListPageEvidence[];
+    /** Structural CMS page types (from `cmsPageTypeEvidence`), only when the
+     *  CMS reads are actually wired to Fimo. */
+    cmsPageTypes?: ReadonlyArray<{
+        schema: string;
+        fields: SchemaFieldsLike;
+    }>;
+    /** Uids still provisional (machine drafts not yet adopted) — their bindings
+     *  are candidates: `adopt-drafts` will rename them. */
+    provisionalUids?: ReadonlySet<string>;
+    /** Known fields per schema, for the displayField pick. */
+    schemaFields?: Record<string, SchemaFieldsLike>;
+}): PageBindingsResult;
+export {};

package/dist/scripts/routes/bindings.js

@@ -0,0 +1,117 @@
+/** Params that identify a locale, not content — never schema-bound. The
+ *  Studio preview substitutes content params only; locale params are a known
+ *  limitation documented in the prompt. Mirrors the parity capture's list. */
+const LOCALE_PARAMS = /^(locale|lang|language)$/i;
+export function isLocaleParam(name) {
+    return LOCALE_PARAMS.test(name);
+}
+const TITLE_FIELDS = /^(title|name|label|heading)$/i;
+/**
+ * A bindable dynamic path = optional locale-ish params + ONE trailing content
+ * param (catch-all or plain). Anything else (multiple content params) needs
+ * judgment beyond a single binding.
+ */
+export function parseDynamicPath(path) {
+    const params = [...path.matchAll(/:([^/*]+)\*?/g)].map((match) => match[1]);
+    if (params.length === 0) {
+        return null;
+    }
+    const contentParams = params.filter((param) => !LOCALE_PARAMS.test(param));
+    if (contentParams.length !== 1) {
+        return null;
+    }
+    const contentParam = contentParams[0];
+    if (!new RegExp(`/:${contentParam}\\*?$`).test(path)) {
+        return null; // the content param must be the trailing segment
+    }
+    const parentPath = path.replace(new RegExp(`/:${contentParam}\\*?$`), '') || '/';
+    return { contentParam, parentPath };
+}
+function isCatchAll(path, param) {
+    return path.endsWith(`:${param}*`);
+}
+/** First title-ish string field of a schema — the picker label the Studio
+ *  shows. Null when the schema has none (binding downgrades to candidate). */
+export function displayFieldFor(fields) {
+    for (const [name, def] of Object.entries(fields ?? {})) {
+        if (TITLE_FIELDS.test(name) && (def.type === undefined || def.type === 'string')) {
+            return name;
+        }
+    }
+    return null;
+}
+/** CMS collections that structurally look like page-builder page types: a
+ *  top-level dynamic-zone (blocks oneOf) field. Structural, never name-based. */
+export function cmsPageTypeEvidence(schemas) {
+    return schemas
+        .filter((schema) => !schema.isSingleton &&
+        Object.values(schema.fields).some((field) => field.type === 'blocks' && 'oneOf' in field.schema))
+        .map((schema) => ({ schema: schema.name, fields: schema.fields }));
+}
+export function collectPageBindings(options) {
+    const { routes, listPages = [], cmsPageTypes = [], provisionalUids, schemaFields = {} } = options;
+    const strong = [];
+    const unbound = [];
+    const bound = [];
+    for (const [id, route] of Object.entries(routes)) {
+        const path = route.path;
+        if (typeof path !== 'string' || !path.includes(':')) {
+            continue;
+        }
+        if (route.params && typeof route.params === 'object' && Object.keys(route.params).length > 0) {
+            bound.push({ id, path });
+            continue;
+        }
+        const params = [...path.matchAll(/:([^/*]+)\*?/g)].map((match) => match[1]);
+        if (params.every((param) => isLocaleParam(param))) {
+            continue; // locale-only page — nothing to bind, effectively static
+        }
+        const parsed = parseDynamicPath(path);
+        if (!parsed) {
+            unbound.push({ id, path, candidates: [] });
+            continue;
+        }
+        const candidates = [];
+        const make = (schema, source, baseConfidence) => {
+            const fields = schemaFields[schema] ?? cmsPageTypes.find((type) => type.schema === schema)?.fields;
+            const display = displayFieldFor(fields);
+            const confidence = provisionalUids?.has(schema) || display === null ? 'candidate' : baseConfidence;
+            return {
+                routeId: id,
+                path,
+                param: parsed.contentParam,
+                binding: { schema, queryField: 'slug', displayField: display ?? 'slug' },
+                confidence,
+                source,
+            };
+        };
+        // Rewire join: a list page rendering collection X at the dynamic page's
+        // parent path is strong evidence the detail param resolves against X.
+        const parents = listPages.filter((page) => page.routePath === parsed.parentPath);
+        const parentSchemas = [...new Set(parents.map((page) => page.schema))];
+        if (parentSchemas.length === 1) {
+            candidates.push(make(parentSchemas[0], 'rewire', 'strong'));
+        }
+        else {
+            for (const schema of parentSchemas) {
+                candidates.push(make(schema, 'rewire', 'candidate'));
+            }
+        }
+        // CMS-structural join: a catch-all page of a CMS-wired site renders the
+        // CMS's page-builder type. Unique page-builder type → strong.
+        if (isCatchAll(path, parsed.contentParam) && cmsPageTypes.length > 0) {
+            const unique = cmsPageTypes.length === 1;
+            for (const type of cmsPageTypes) {
+                candidates.push(make(type.schema, 'cms-wiring', unique ? 'strong' : 'candidate'));
+            }
+        }
+        const winner = candidates.find((candidate) => candidate.confidence === 'strong');
+        if (winner && candidates.filter((candidate) => candidate.confidence === 'strong').length === 1) {
+            strong.push(winner);
+        }
+        else {
+            unbound.push({ id, path, candidates });
+        }
+    }
+    return { strong, unbound, bound };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.9.0-experimental.4",
+  "version": "0.9.0-experimental.6",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -58,6 +58,10 @@
       "types": "./dist/runtime/strapi/index.d.ts",
       "import": "./dist/runtime/strapi/index.js"
     },
+    "./seo": {
+      "types": "./dist/runtime/seo/neutral.d.ts",
+      "import": "./dist/runtime/seo/neutral.js"
+    },
     "./remix": {
       "types": "./dist/runtime/remix/index.d.ts",
       "import": "./dist/runtime/remix/index.js"

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.9.0-experimental.4",
+    "fimo": "0.9.0-experimental.6",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

package/templates/react-router/translations/en.json

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