fimo 0.9.0-experimental.6 → 0.9.0-experimental.8

package/dist/scripts/routes/page-structure.js

@@ -0,0 +1,234 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { frameworkSectionStyle } from '../frameworks/discover.js';
+import { componentImports, resolveModuleFile, resolveRouteFiles } from './label-prefixes.js';
+const MAX_SECTION_DEPTH = 3;
+const MAX_DRAFT_ROWS = 50;
+const pascal = (value) => value
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+    .split(/[-_.\s]/)
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+const camel = (value) => {
+    const p = pascal(value);
+    return p.charAt(0).toLowerCase() + p.slice(1);
+};
+/** Capitalized JSX tags in DOCUMENT order (deduped, first appearance). */
+function sectionTags(code) {
+    const seen = new Set();
+    const tags = [];
+    for (const match of code.matchAll(/<([A-Z]\w*)[\s/>]/g)) {
+        if (!seen.has(match[1])) {
+            seen.add(match[1]);
+            tags.push(match[1]);
+        }
+    }
+    return tags;
+}
+function draftSection(context, tag, file, depth) {
+    const rel = relative(context.cwd, file);
+    const prefix = context.style.fileScope(rel);
+    const labelKeys = context.keysByPrefix.get(prefix) ?? [];
+    const collections = (context.collectionsByFile.get(rel) ?? []).map((candidate) => ({
+        name: candidate.name,
+        fields: candidate.fields,
+        count: candidate.count,
+        ...(candidate.typedRows ? { rows: candidate.typedRows.slice(0, MAX_DRAFT_ROWS) } : {}),
+    }));
+    const children = depth < MAX_SECTION_DEPTH ? draftChildSections(context, file, depth + 1) : [];
+    if (labelKeys.length === 0 && collections.length === 0 && children.length === 0) {
+        return null; // pure layout — nothing to model
+    }
+    const draft = { key: camel(tag), component: tag, file: rel, prefix, labelKeys, collections };
+    if (children.length > 0) {
+        draft.children = children;
+    }
+    return draft;
+}
+/** Auto-imported components (Nuxt's components/ convention): a tag with no
+ *  import statement may still be a local file at a conventional path. */
+function resolveAutoImportedComponent(context, tag) {
+    for (const dir of context.style.fallbackComponentDirs) {
+        for (const ext of context.style.extensions) {
+            const candidate = join(context.cwd, dir, `${tag}${ext}`);
+            try {
+                if (statSync(candidate).isFile()) {
+                    return candidate;
+                }
+            }
+            catch {
+                /* try next */
+            }
+        }
+    }
+    return null;
+}
+function draftChildSections(context, file, depth) {
+    let code;
+    try {
+        code = readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const imports = componentImports(code);
+    const sections = [];
+    for (const tag of sectionTags(code)) {
+        const spec = imports.get(tag);
+        const sectionFile = spec
+            ? resolveModuleFile(context.cwd, file, spec, context.style.extensions)
+            : resolveAutoImportedComponent(context, tag);
+        if (!sectionFile || context.visited.has(sectionFile)) {
+            continue; // library components (Button, Link) have no local file
+        }
+        context.visited.add(sectionFile);
+        const section = draftSection(context, tag, sectionFile, depth);
+        if (section) {
+            sections.push(section);
+        }
+    }
+    return sections;
+}
+export function draftPageStructures(args) {
+    const { cwd, framework, routes, collections } = args;
+    const keysByPrefix = new Map();
+    for (const key of args.stagedKeys) {
+        const dot = key.indexOf('.');
+        if (dot > 0) {
+            const prefix = key.slice(0, dot);
+            keysByPrefix.set(prefix, [...(keysByPrefix.get(prefix) ?? []), key]);
+        }
+    }
+    const collectionsByFile = new Map();
+    for (const candidate of collections) {
+        collectionsByFile.set(candidate.file, [...(collectionsByFile.get(candidate.file) ?? []), candidate]);
+    }
+    const style = frameworkSectionStyle(framework);
+    const drafts = [];
+    for (const { routeId, file } of resolveRouteFiles(cwd, framework, routes)) {
+        const context = { cwd, style, keysByPrefix, collectionsByFile, visited: new Set([file]) };
+        const sections = draftChildSections(context, file, 1);
+        if (sections.length > 1) {
+            drafts.push({ pageId: routeId, single: pascal(routeId), sections });
+        }
+    }
+    markSharedSections(drafts);
+    return drafts;
+}
+/** A section file drafted on several pages is chrome — flag it so the agent
+ *  models it once (Single Type) instead of nesting it under every page. */
+function markSharedSections(drafts) {
+    const pagesByFile = new Map();
+    const index = (pageId, sections) => {
+        for (const section of sections) {
+            pagesByFile.set(section.file, (pagesByFile.get(section.file) ?? new Set()).add(pageId));
+            index(pageId, section.children ?? []);
+        }
+    };
+    for (const draft of drafts) {
+        index(draft.pageId, draft.sections);
+    }
+    const flag = (sections) => {
+        for (const section of sections) {
+            if ((pagesByFile.get(section.file)?.size ?? 0) > 1) {
+                section.shared = true;
+            }
+            flag(section.children ?? []);
+        }
+    };
+    for (const draft of drafts) {
+        flag(draft.sections);
+    }
+}
+/** Flat section count across the nesting — the summary's visibility number. */
+export function countDraftSections(draft) {
+    const walk = (sections) => sections.reduce((total, section) => total + 1 + walk(section.children ?? []), 0);
+    return walk(draft.sections);
+}
+const labelFieldName = (key) => camel(key.split('.').pop() ?? key);
+const scalarType = (value) => value.length > 80 || value.includes('\n') ? 'text' : 'string';
+function sectionBlock(section, labelValues) {
+    const fields = {};
+    const value = {};
+    let fieldCount = 0;
+    for (const key of section.labelKeys) {
+        const name = labelFieldName(key);
+        if (fields[name]) {
+            continue;
+        }
+        const labelValue = labelValues[key] ?? '';
+        fields[name] = { type: scalarType(labelValue) };
+        value[name] = labelValue;
+        fieldCount += 1;
+    }
+    for (const collection of section.collections) {
+        const name = camel(collection.name);
+        if (fields[name]) {
+            continue;
+        }
+        const itemFields = {};
+        for (const field of collection.fields) {
+            itemFields[field] = { type: 'string' };
+        }
+        if (Object.keys(itemFields).length === 0) {
+            continue;
+        }
+        fields[name] = { type: 'blocks', schema: { fields: itemFields } };
+        value[name] = (collection.rows ?? []).map((row) => {
+            const item = {};
+            for (const field of collection.fields) {
+                const cell = row[field];
+                if (cell != null && typeof cell !== 'object') {
+                    item[field] = typeof cell === 'string' ? cell : String(cell);
+                }
+            }
+            return item;
+        });
+        fieldCount += 1;
+    }
+    for (const child of section.children ?? []) {
+        if (child.shared) {
+            continue;
+        }
+        const block = sectionBlock(child, labelValues);
+        if (!block || fields[child.key]) {
+            continue;
+        }
+        fields[child.key] = { type: 'blocks', max: 1, schema: { fields: block.fields } };
+        value[child.key] = [block.value];
+        fieldCount += block.fieldCount;
+    }
+    if (Object.keys(fields).length === 0) {
+        return null;
+    }
+    return { fields, value, fieldCount };
+}
+export function buildPageSingleDraft(draft, labelValues) {
+    const fields = {};
+    const document = {};
+    let totalFields = 0;
+    for (const section of draft.sections) {
+        if (section.shared || fields[section.key]) {
+            continue;
+        }
+        const block = sectionBlock(section, labelValues);
+        if (!block) {
+            continue;
+        }
+        fields[section.key] = { type: 'blocks', max: 1, schema: { fields: block.fields } };
+        document[section.key] = [block.value];
+        totalFields += block.fieldCount;
+    }
+    // A one-field page is a label, not a Single — only real structure drafts.
+    if (Object.keys(fields).length === 0 || totalFields < 3) {
+        return null;
+    }
+    return {
+        uid: draft.single,
+        pageId: draft.pageId,
+        schema: { uid: draft.single, name: draft.single, isSingleton: true, fields },
+        document,
+    };
+}

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;
@@ -97,6 +97,10 @@ export interface WrappedIds {
     media: string[];
     richText: string[];
     files: string[];
+    /** Every wrapped key, ALL kinds, in ENCOUNTER order (per-file walk, files
+     *  in walk order) — the on-page reading order the Studio Pages view sorts
+     *  by. Deduplicated keeping the first occurrence; never sorted. */
+    ordered: string[];
 }
 export interface WrapScanResult {
     items: WrappableItem[];

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();
@@ -212,7 +242,7 @@ function extractTemplate(ext, code) {
 }
 function scanTemplateFile(ext, code, relPath) {
     const items = [];
-    const wrappedIds = { labels: [], media: [], richText: [], files: [] };
+    const wrappedIds = { labels: [], media: [], richText: [], files: [], ordered: [] };
     let wrapped = 0;
     const { template, offset, frontmatter } = extractTemplate(ext, code);
     // t('key', ...) in frontmatter/script and in template expressions = wrapped.
@@ -220,6 +250,7 @@ function scanTemplateFile(ext, code, relPath) {
         for (const match of source.matchAll(/\bt\(\s*['"]([^'"]+)['"]/g)) {
             wrapped += 1;
             wrappedIds.labels.push(match[1]);
+            wrappedIds.ordered.push(match[1]);
         }
     }
     // data-fimo-source attributes = wrapped media/labels rendered via attrs.
@@ -444,7 +475,7 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
     const items = [];
     let wrapped = 0;
     let foreignI18n = 0;
-    const wrappedIds = { labels: [], media: [], richText: [], files: [] };
+    const wrappedIds = { labels: [], media: [], richText: [], files: [], ordered: [] };
     const collections = [];
     const templateExt = filePath.match(/\.(astro|vue|svelte)$/)?.[1];
     if (templateExt) {
@@ -465,6 +496,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;
@@ -486,6 +561,7 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
                 const id = attributeValue(node, 'id');
                 if (kind && id) {
                     wrappedIds[kind].push(id.value);
+                    wrappedIds.ordered.push(id.value);
                 }
             }
             if (!insideWrapped && name) {
@@ -548,7 +624,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) {
@@ -584,6 +696,7 @@ export function scanWrappableFile(filePath, code, relPath, opts = {}) {
                     const resolved = resolveScopedKey(node.callee.name, firstArg.value, childScopes);
                     if (!resolved.unresolvable) {
                         wrappedIds.labels.push(resolved.key);
+                        wrappedIds.ordered.push(resolved.key);
                     }
                 }
             }
@@ -1066,6 +1179,8 @@ export function scanWrappable(rootDir, opts = {}) {
         richText: new Set(),
         files: new Set(),
     };
+    const orderedIds = [];
+    const orderedSeen = new Set();
     for (const file of files) {
         let code;
         try {
@@ -1086,6 +1201,12 @@ export function scanWrappable(rootDir, opts = {}) {
                 idSets[kind].add(id);
             }
         }
+        for (const id of result.wrappedIds.ordered) {
+            if (!orderedSeen.has(id)) {
+                orderedSeen.add(id);
+                orderedIds.push(id);
+            }
+        }
     }
     const dataFiles = [];
     // Markdown/MDX documents: group per directory so a 40-post blog is ONE
@@ -1227,6 +1348,8 @@ export function scanWrappable(rootDir, opts = {}) {
             media: [...idSets.media].sort(),
             richText: [...idSets.richText].sort(),
             files: [...idSets.files].sort(),
+            // Encounter order, never sorted — the on-page reading order.
+            ordered: orderedIds,
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.9.0-experimental.6",
+  "version": "0.9.0-experimental.8",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/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.6",
+    "fimo": "0.9.0-experimental.8",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

package/dist/scripts/lib/discover-next-routes.d.ts

@@ -1,17 +0,0 @@
-export interface DiscoveredRoute {
-    id: string;
-    path: string;
-    label: string;
-}
-/**
- * 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[];

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

@@ -1,134 +0,0 @@
-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;
-}