fimo 0.9.0-experimental.5 → 0.9.0-experimental.7

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/dist/scripts/scan-wrappable.d.ts

@@ -4,7 +4,7 @@
  * user-visible attribute strings. Drives the wrap migration's coverage gate:
  * every item must end wrapped, ignored-with-a-reason, or unresolved.
  */
-export type WrappableKind = 'text' | 'image' | 'video' | 'file-link' | 'attribute';
+export type WrappableKind = 'text' | 'formatted-text' | 'image' | 'video' | 'file-link' | 'attribute';
 export interface WrappableItem {
     kind: WrappableKind;
     file: string;

package/dist/scripts/scan-wrappable.js

@@ -118,6 +118,36 @@ const WRAPPABLE_ATTRIBUTES = new Set(['placeholder', 'title', 'aria-label']);
 const FILE_LINK_PATTERN = /\.(pdf|zip|docx?|xlsx?|pptx?|csv|mp4|mov|webm)$/i;
 const SKIP_DIRS = new Set(['node_modules', '.next', '.git', 'dist', 'build', '.fimo']);
 const MIN_TEXT_LENGTH = 3;
+/**
+ * Prose containers whose children mix raw text with inline elements or
+ * expressions. Wrapping such text node-by-node produces FRAGMENT labels
+ * (", and agencies building…") that nobody can find or edit as a sentence —
+ * the whole block merges into ONE `formatted-text` item instead (agent work:
+ * the fimo`` tagged template or RichText, never the auto-wrap codemod).
+ */
+const PROSE_TAGS = new Set([
+    'p',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'li',
+    'blockquote',
+    'figcaption',
+    'dt',
+    'dd',
+    'label',
+    'legend',
+    'td',
+    'th',
+    'caption',
+    'summary',
+]);
+function meaningfulLength(text) {
+    return text.replace(/[^\p{L}\p{N}]/gu, '').length;
+}
 const PREVIEW_LENGTH = 60;
 function toPreview(value) {
     const collapsed = value.replace(/\s+/g, ' ').trim();
@@ -465,6 +495,50 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
     function detectCollection(declarator) {
         detectCollectionFromDeclarator(declarator, code, 0, relPath, collections);
     }
+    // Text nodes absorbed into a merged formatted-text item (keyed by offset) —
+    // the JSXText visitor skips them so fragments never become labels.
+    const mergedText = new Set();
+    function containsWrappedContent(node) {
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 't') {
+            return true;
+        }
+        if (node.type === 'TaggedTemplateExpression' && node.tag?.type === 'Identifier' && node.tag.name === 'fimo') {
+            return true;
+        }
+        if (node.type === 'JSXElement') {
+            const name = jsxElementName(node);
+            if (name && WRAPPING_COMPONENTS.has(name)) {
+                return true;
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (Array.isArray(child)) {
+                if (child.some((item) => containsWrappedContent(item))) {
+                    return true;
+                }
+            }
+            else if (typeof child === 'object' && child !== null && containsWrappedContent(child)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Every JSXText inside a prose element, recursing through inline children
+     *  (inside a `<p>`, nested elements are inline by HTML rules). */
+    function collectProseTextNodes(node, out) {
+        for (const child of node.children ?? []) {
+            if (child.type === 'JSXText') {
+                out.push(child);
+            }
+            else if (child.type === 'JSXElement') {
+                collectProseTextNodes(child, out);
+            }
+        }
+    }
     function visit(node, insideWrapped, parentTag, scopes) {
         if (!node || typeof node !== 'object') {
             return;
@@ -548,7 +622,43 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
                 }
             }
         }
-        if (node.type === 'JSXText' && !insideWrapped) {
+        // Mixed prose detection runs on the ELEMENT (before its children are
+        // visited): a prose tag whose direct children interleave raw text with
+        // inline elements/expressions becomes ONE formatted-text item, and its
+        // text nodes are recorded so the JSXText visitor below skips them.
+        if (node.type === 'JSXElement' && !insideWrapped) {
+            const proseName = jsxElementName(node);
+            if (proseName && PROSE_TAGS.has(proseName)) {
+                const children = node.children ?? [];
+                const directText = children.filter((child) => child.type === 'JSXText' && meaningfulLength(String(child.value ?? '')) > 0);
+                const inline = children.filter((child) => child.type === 'JSXElement' ||
+                    (child.type === 'JSXExpressionContainer' && child.expression?.type !== 'JSXEmptyExpression'));
+                if (directText.length > 0 &&
+                    inline.length > 0 &&
+                    !directText.some((child) => mergedText.has(child.start)) &&
+                    !children.some((child) => containsWrappedContent(child))) {
+                    const textNodes = [];
+                    collectProseTextNodes(node, textNodes);
+                    const combined = textNodes.map((textNode) => String(textNode.value ?? '')).join(' ');
+                    if (meaningfulLength(combined) >= MIN_TEXT_LENGTH) {
+                        for (const textNode of textNodes) {
+                            if (typeof textNode.start === 'number') {
+                                mergedText.add(textNode.start);
+                            }
+                        }
+                        const inner = code.slice(node.openingElement?.end ?? node.start ?? 0, node.closingElement?.start ?? node.end ?? 0);
+                        items.push({
+                            kind: 'formatted-text',
+                            file: relPath,
+                            line: lineOf(code, node.start ?? 0),
+                            preview: toPreview(inner),
+                            span: { start: node.start, end: node.end, parentTag: proseName },
+                        });
+                    }
+                }
+            }
+        }
+        if (node.type === 'JSXText' && !insideWrapped && !mergedText.has(node.start)) {
             const text = String(node.value ?? '');
             const meaningful = text.replace(/[^\p{L}\p{N}]/gu, '');
             if (meaningful.length >= MIN_TEXT_LENGTH) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.9.0-experimental.5",
+  "version": "0.9.0-experimental.7",
   "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.5",
+    "fimo": "0.9.0-experimental.7",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

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

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