fimo 0.9.0-experimental.1 → 0.9.0

package/dist/scripts/apply-wrap.js

@@ -1,278 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { basename, join } from 'node:path';
-import { parseSync } from 'oxc-parser';
-import { scanWrappable } from './scan-wrappable.js';
-/**
- * The --apply codemod: performs the PROVABLY-SAFE wrap transforms
- * deterministically, leaving every judgment call to the agent.
- *
- * In scope:  plain JSX text -> FimoText, <img src="literal"> -> FimoMediaImage,
- *            <a href="/file.pdf"> -> FimoFileLink.
- * Out of scope (agent work): attributes (useLabels crosses the RSC boundary),
- *            formatted text (marks -> FimoRichTextBlock), next/image <Image>
- *            (framework-specific props), collections, layout wiring.
- *
- * Correctness is enforced by the gates, not assumed: the render-parity
- * baseline is captured BEFORE applying, and `fimo migrate wrap --check`
- * verifies the result like any other actor's work.
- */
-/** Elements whose children cannot contain a <span> wrapper. */
-const NO_ELEMENT_CHILDREN = new Set(['option', 'title', 'textarea', 'script', 'style', 'select']);
-function collapse(text) {
-    return text.replace(/\s+/g, ' ').trim();
-}
-// JSX text carries HTML entities (&apos;, &amp;, …). The FALLBACK keeps the
-// original source form, but the label VALUE is rendered literally by
-// FimoText — seeding the raw entity re-escapes it on screen (the remix
-// dogfood shipped "What&apos;s next?"). Decode when generating values.
-const JSX_ENTITIES = {
-    '&amp;': '&',
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&apos;': "'",
-    '&nbsp;': ' ',
-    '&copy;': '©',
-};
-export function decodeJsxEntities(text) {
-    return text
-        .replace(/&(amp|lt|gt|quot|apos|nbsp|copy);/g, (entity) => JSX_ENTITIES[entity] ?? entity)
-        .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
-        .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));
-}
-/** Deterministic scope from the file path: app/about/page.tsx -> about. */
-export function keyScope(file) {
-    const normalized = file.replace(/\\/g, '/');
-    const appMatch = normalized.match(/(?:^|\/)app\/(.*)\/?page\.[jt]sx?$/);
-    if (appMatch) {
-        const dir = appMatch[1].replace(/\/$/, '');
-        if (!dir) {
-            return 'home';
-        }
-        const segments = dir
-            .split('/')
-            .filter((segment) => !segment.startsWith('(') && !segment.startsWith('@'))
-            .map((segment) => segment.replace(/^\[+|\]+$/g, '').replace(/^\.\.\./, ''));
-        return segments.join('.') || 'home';
-    }
-    if (/(?:^|\/)app\/layout\.[jt]sx?$/.test(normalized)) {
-        return 'layout';
-    }
-    const stem = basename(normalized).replace(/\.[jt]sx?$/, '');
-    return slugify(stem) || 'shared';
-}
-export function slugify(text) {
-    return collapse(text)
-        .toLowerCase()
-        .normalize('NFD')
-        .replace(/[̀-ͯ]/g, '')
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .split('-')
-        .slice(0, 4)
-        .join('-');
-}
-export class KeyAllocator {
-    used = new Set();
-    constructor(existing) {
-        for (const key of existing) {
-            this.used.add(key);
-        }
-    }
-    allocate(scope, slug) {
-        const base = `${scope}.${slug || 'item'}`;
-        let candidate = base;
-        let counter = 2;
-        while (this.used.has(candidate)) {
-            candidate = `${base}-${counter++}`;
-        }
-        this.used.add(candidate);
-        return candidate;
-    }
-}
-/**
- * Merge the fimo/next import with an existing one, or insert a new one AFTER
- * the last import statement — positioned via the AST, never line matching
- * (a multiline `import {\n …` opening line is not the end of the imports,
- * as a real portfolio migration proved).
- */
-export function ensureFimoImport(code, specifiers, importModule = 'fimo/next') {
-    if (specifiers.length === 0) {
-        return code;
-    }
-    const moduleRe = importModule.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-    const importMatch = code.match(new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*(['\"])${moduleRe}\\2\\s*;?`));
-    if (importMatch) {
-        const existing = importMatch[1]
-            .split(',')
-            .map((token) => token.trim())
-            .filter(Boolean);
-        const merged = [...new Set([...existing, ...specifiers])].sort();
-        return code.replace(importMatch[0], `import { ${merged.join(', ')} } from "${importModule}";`);
-    }
-    const statement = `import { ${[...new Set(specifiers)].sort().join(', ')} } from "${importModule}";`;
-    let insertAt = 0;
-    try {
-        const program = parseSync('module.tsx', code).program;
-        for (const node of program.body ?? []) {
-            if (node.type === 'ImportDeclaration') {
-                insertAt = node.end;
-            }
-        }
-    }
-    catch {
-        insertAt = 0;
-    }
-    if (insertAt === 0) {
-        return `${statement}\n${code}`;
-    }
-    return `${code.slice(0, insertAt)}\n${statement}${code.slice(insertAt)}`;
-}
-export function applyWrapToFile(code, items, allocator, importModule = 'fimo/next') {
-    const applied = [];
-    const skipped = [];
-    const labels = {};
-    const edits = [];
-    const specifiers = new Set();
-    for (const item of items) {
-        const span = item.span;
-        if (!span) {
-            skipped.push({ item, reason: 'no span info' });
-            continue;
-        }
-        const scope = keyScope(item.file);
-        if (item.kind === 'text') {
-            if (span.parentTag && NO_ELEMENT_CHILDREN.has(span.parentTag.toLowerCase())) {
-                skipped.push({ item, reason: `<${span.parentTag}> cannot contain a wrapper element` });
-                continue;
-            }
-            const raw = code.slice(span.start, span.end);
-            const core = raw.trim();
-            if (!core) {
-                skipped.push({ item, reason: 'whitespace only' });
-                continue;
-            }
-            const lead = raw.slice(0, raw.indexOf(core));
-            const trail = raw.slice(raw.indexOf(core) + core.length);
-            const id = allocator.allocate(scope, slugify(core));
-            edits.push({
-                start: span.start,
-                end: span.end,
-                replacement: `${lead}<FimoText id="${id}">${core}</FimoText>${trail}`,
-            });
-            specifiers.add('FimoText');
-            labels[id] = decodeJsxEntities(collapse(core));
-            applied.push({ kind: 'text', file: item.file, line: item.line, id, preview: item.preview });
-            continue;
-        }
-        if (item.kind === 'image') {
-            if (span.openNameStart === undefined ||
-                span.openNameEnd === undefined ||
-                code.slice(span.openNameStart, span.openNameEnd) !== 'img') {
-                skipped.push({ item, reason: 'next/image and custom components stay agent work' });
-                continue;
-            }
-            const id = allocator.allocate(scope, slugify(basename(item.preview).replace(/\.[a-z0-9]+$/i, '')));
-            edits.push({
-                start: span.openNameStart,
-                end: span.openNameEnd,
-                replacement: `FimoMediaImage id="${id}"`,
-            });
-            specifiers.add('FimoMediaImage');
-            applied.push({ kind: 'image', file: item.file, line: item.line, id, preview: item.preview });
-            continue;
-        }
-        if (item.kind === 'file-link') {
-            if (span.openNameStart === undefined ||
-                span.openNameEnd === undefined ||
-                span.closeNameStart === undefined ||
-                span.closeNameEnd === undefined) {
-                skipped.push({ item, reason: 'self-closing or unparsable anchor' });
-                continue;
-            }
-            const id = allocator.allocate(scope, slugify(basename(item.preview).replace(/\.[a-z0-9]+$/i, '')));
-            edits.push({ start: span.openNameStart, end: span.openNameEnd, replacement: `FimoFileLink id="${id}"` });
-            edits.push({ start: span.closeNameStart, end: span.closeNameEnd, replacement: 'FimoFileLink' });
-            specifiers.add('FimoFileLink');
-            applied.push({ kind: 'file-link', file: item.file, line: item.line, id, preview: item.preview });
-            continue;
-        }
-        skipped.push({ item, reason: `${item.kind} stays agent work` });
-    }
-    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);
-    }
-    next = ensureFimoImport(next, [...specifiers], importModule);
-    return { code: next, applied, skipped, labels };
-}
-/**
- * Apply the safe transforms across the project. Mutates source files and
- * merges generated labels into `.fimo/migration/labels.json` (never
- * overwriting existing keys).
- */
-/** Recorded coverage exemptions the codemod must NOT wrap — items the user
- *  deliberately kept out (dev-only UI, OG-image markup, …). Matched by the
- *  same (file, kind, preview) triple the coverage gate uses, so "record the
- *  exemption first, then --apply auto-wraps the rest" holds. */
-function readApplyExemptions(rootDir) {
-    try {
-        const manifest = JSON.parse(readFileSync(join(rootDir, '.fimo', 'migration', 'manifest.json'), 'utf8'));
-        const raw = manifest?.wrap?.exemptions;
-        return Array.isArray(raw)
-            ? raw.filter((entry) => typeof entry?.file === 'string' &&
-                typeof entry?.kind === 'string' &&
-                typeof entry?.preview === 'string')
-            : [];
-    }
-    catch {
-        return [];
-    }
-}
-export function applyWrap(rootDir, opts = {}) {
-    const scan = scanWrappable(rootDir, { excludePrefixes: opts.excludePrefixes });
-    const existingLabels = (() => {
-        try {
-            return JSON.parse(readFileSync(join(rootDir, '.fimo', 'migration', 'labels.json'), 'utf8'));
-        }
-        catch {
-            return {};
-        }
-    })();
-    // Honor recorded exemptions: the codemod skips them so the coverage gate's
-    // exemption and the codemod stay consistent — otherwise --apply would wrap
-    // an item the user just exempted and the gate would flag the drift.
-    const exemptions = readApplyExemptions(rootDir);
-    const isExempt = (item) => exemptions.some((exemption) => exemption.file === item.file && exemption.kind === item.kind && exemption.preview === item.preview);
-    const allocator = new KeyAllocator([...Object.keys(existingLabels), ...scan.wrappedIds.labels]);
-    const byFile = new Map();
-    for (const item of scan.items) {
-        if (isExempt(item)) {
-            continue;
-        }
-        const list = byFile.get(item.file) ?? [];
-        list.push(item);
-        byFile.set(item.file, list);
-    }
-    const result = { applied: [], skipped: [], labels: {}, filesChanged: [] };
-    for (const [file, items] of byFile) {
-        const filePath = join(rootDir, file);
-        let code;
-        try {
-            code = readFileSync(filePath, 'utf8');
-        }
-        catch {
-            result.skipped.push(...items.map((item) => ({ item, reason: 'unreadable file' })));
-            continue;
-        }
-        const fileResult = applyWrapToFile(code, items, allocator, opts.importModule ?? 'fimo/next');
-        result.applied.push(...fileResult.applied);
-        result.skipped.push(...fileResult.skipped);
-        Object.assign(result.labels, fileResult.labels);
-        if (fileResult.applied.length > 0) {
-            writeFileSync(filePath, fileResult.code);
-            result.filesChanged.push(file);
-        }
-    }
-    return result;
-}

package/dist/scripts/cms/discover.d.ts

@@ -1,2 +0,0 @@
-import type { CmsConnector } from './types.js';
-export declare function detectCms(frontendDir: string): CmsConnector | null;

package/dist/scripts/cms/discover.js

@@ -1,17 +0,0 @@
-import { strapiConnector } from './strapi/index.js';
-/**
- * CMS-connector registry. Add a connector factory here to support a new
- * headless CMS; each returns its `CmsConnector` when it recognizes the
- * frontend, or null. First match wins. This is the ONLY CMS-neutral file that
- * enumerates the supported CMSs (the analogue of `frameworks/discover.ts`).
- */
-const CONNECTORS = [strapiConnector];
-export function detectCms(frontendDir) {
-    for (const factory of CONNECTORS) {
-        const connector = factory(frontendDir);
-        if (connector) {
-            return connector;
-        }
-    }
-    return null;
-}

package/dist/scripts/cms/example-content.d.ts

@@ -1,33 +0,0 @@
-import type { CmsCollectionSchema } from './types.js';
-/**
- * Generate example content for a CMS schema WITHOUT connecting to the CMS. The
- * shapes match `api.importEntries`: media fields get a self-contained
- * placeholder, references point at the first example of the target type
- * (`<target>-example-1`) so they resolve against the co-seeded data, blocks
- * (components / dynamic zones) get a filled array so page-builder pages render
- * instead of showing empty, and localized types get per-locale string variance
- * so the per-language editability is visible in Fimo. This is CMS-neutral: it
- * consumes the mapped Fimo schema only.
- */
-export interface ExampleSeed {
-    /** Fimo type name. */
-    readonly name: string;
-    readonly isSingleton: boolean;
-    readonly localized: boolean;
-    /** Entry data rows (slug lives inside data for collections). */
-    readonly rows: Array<Record<string, unknown>>;
-    /** Reference descriptor for `importEntries`. */
-    readonly references: Record<string, {
-        target?: string;
-        targets?: string[];
-        by: 'slug';
-        many?: boolean;
-    }>;
-}
-export interface ExampleOptions {
-    /** Rows per collection type (singletons always get exactly one). */
-    readonly count?: number;
-    /** Locale suffix on string values + the batch locale (for localized types). */
-    readonly locale?: string;
-}
-export declare function generateExampleSeed(schema: CmsCollectionSchema, options?: ExampleOptions): ExampleSeed;

package/dist/scripts/cms/example-content.js

@@ -1,162 +0,0 @@
-const DEFAULT_COUNT = 3;
-/** Variants seeded per dynamic-zone (`oneOf`) field — a representative page, not
- *  all N components. Real content (the pull) exercises the rest. */
-const EXAMPLE_BLOCK_VARIANTS = 5;
-/** Items seeded for a repeatable fixed-shape block. */
-const EXAMPLE_REPEATABLE_ITEMS = 2;
-/** Recursion cap for nested blocks — the schema is already depth-bounded; this
- *  keeps generation finite even for pathological nesting. */
-const MAX_FILL_DEPTH = 3;
-function kebabCase(name) {
-    return name
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/[^a-zA-Z0-9]+/g, '-')
-        .toLowerCase()
-        .replace(/^-+|-+$/g, '');
-}
-function humanize(field) {
-    return field
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .replace(/[_-]+/g, ' ')
-        .replace(/^\w/, (c) => c.toUpperCase());
-}
-function richTextDoc(text) {
-    return {
-        type: 'doc',
-        content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
-    };
-}
-/** A self-contained placeholder image (inline SVG data-URI) in the media
- *  envelope shape the wrap runtime already understands — no external host, no
- *  CSP surprises, so cards/heroes render instead of showing broken images. */
-function placeholderMedia(label) {
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630"><rect width="100%" height="100%" fill="#e5e7eb"/><text x="50%" y="50%" font-family="sans-serif" font-size="44" fill="#9ca3af" text-anchor="middle" dominant-baseline="middle">${label}</text></svg>`;
-    return {
-        source: 'local',
-        url: `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`,
-        alt: `${label} placeholder`,
-        width: 1200,
-        height: 630,
-        mime: 'image/svg+xml',
-        name: 'placeholder.svg',
-    };
-}
-/** Deterministic ISO date (no wall clock): 2024-01-01 + (n-1) days. */
-function exampleDate(n) {
-    return new Date(Date.UTC(2024, 0, n)).toISOString().slice(0, 10);
-}
-function exampleReferenceSlug(field) {
-    const targetName = field.target ?? field.targets?.[0];
-    if (!targetName) {
-        return undefined;
-    }
-    const slug = `${kebabCase(targetName)}-example-1`;
-    return field.many ? [slug] : slug;
-}
-/**
- * Fill a NON-reference field value from its Fimo def (scalars, blocks, and any
- * baked default such as a block variant's `__component` discriminator).
- * Reference fields return `undefined` here: the top-level pass owns them, and
- * server-side slug resolution does not reach references nested inside blocks.
- */
-function fillFieldValue(field, def, ctx) {
-    const baked = def.default;
-    if (baked !== undefined) {
-        return baked;
-    }
-    switch (def.type) {
-        case 'string':
-            return `${humanize(field)} example ${ctx.index}${ctx.localeSuffix}`;
-        case 'richtext':
-            return richTextDoc(`Example ${humanize(ctx.schemaName).toLowerCase()} content ${ctx.index}${ctx.localeSuffix}.`);
-        case 'number':
-            return ctx.index;
-        case 'boolean':
-            return ctx.index % 2 === 1;
-        case 'date':
-            return exampleDate(ctx.index);
-        case 'json':
-            return {};
-        case 'media':
-            return placeholderMedia(humanize(field));
-        case 'blocks':
-            return fillBlocks(def, ctx);
-        default:
-            // reference (nested) — omitted; the frontend accesses relations defensively.
-            return undefined;
-    }
-}
-/**
- * Fill a blocks value — always an array so page builders can `.map()` it. A
- * dynamic zone (`oneOf`) seeds one item per variant (representative subset,
- * each tagged with its `_type` discriminator); a fixed component (`fields`)
- * seeds one item (single) or a few (repeatable).
- */
-function fillBlocks(def, ctx) {
-    if (ctx.depth >= MAX_FILL_DEPTH) {
-        return [];
-    }
-    const childCtx = { ...ctx, depth: ctx.depth + 1 };
-    const schema = def.schema;
-    if ('oneOf' in schema) {
-        return schema.oneOf.slice(0, EXAMPLE_BLOCK_VARIANTS).map((variant) => ({
-            _type: variant.uid,
-            ...fillItem(variant.fields, childCtx),
-        }));
-    }
-    const itemCount = def.max === 1 ? 1 : EXAMPLE_REPEATABLE_ITEMS;
-    return Array.from({ length: itemCount }, () => fillItem(schema.fields, childCtx));
-}
-/** Fill every non-reference field of a block item. */
-function fillItem(fields, ctx) {
-    const item = {};
-    for (const [name, def] of Object.entries(fields)) {
-        const value = fillFieldValue(name, def, ctx);
-        if (value !== undefined) {
-            item[name] = value;
-        }
-    }
-    return item;
-}
-export function generateExampleSeed(schema, options = {}) {
-    const locale = options.locale;
-    const localeSuffix = locale ? ` (${locale})` : '';
-    const count = schema.isSingleton ? 1 : Math.max(1, options.count ?? DEFAULT_COUNT);
-    const references = {};
-    const rows = [];
-    for (let i = 1; i <= count; i += 1) {
-        const row = {};
-        if (!schema.isSingleton) {
-            row.slug = `${kebabCase(schema.name)}-example-${i}`;
-        }
-        for (const [field, def] of Object.entries(schema.fields)) {
-            // A connector-supplied example (dynamic zones, components) wins over the
-            // type-driven default — critical for dynamic zones, which must be arrays.
-            if (schema.examples && field in schema.examples) {
-                row[field] = schema.examples[field];
-                continue;
-            }
-            // References are top-level only: record the descriptor so the import
-            // endpoint resolves the slug to a documentId server-side.
-            if (def.type === 'reference') {
-                const value = exampleReferenceSlug(def);
-                if (value !== undefined) {
-                    row[field] = value;
-                    references[field] = {
-                        ...(def.target ? { target: def.target } : {}),
-                        ...(def.targets ? { targets: def.targets } : {}),
-                        by: 'slug',
-                        ...(def.many ? { many: true } : {}),
-                    };
-                }
-                continue;
-            }
-            const value = fillFieldValue(field, def, { localeSuffix, index: i, schemaName: schema.name, depth: 0 });
-            if (value !== undefined) {
-                row[field] = value;
-            }
-        }
-        rows.push(row);
-    }
-    return { name: schema.name, isSingleton: schema.isSingleton, localized: schema.localized, rows, references };
-}

package/dist/scripts/cms/strapi/detect.d.ts

@@ -1,2 +0,0 @@
-import type { CmsDetection } from '../types.js';
-export declare function detectStrapi(frontendDir: string): CmsDetection | null;

package/dist/scripts/cms/strapi/detect.js

@@ -1,186 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-/**
- * Detect a Strapi backend behind a wrapped frontend. Strapi is consumed via a
- * hand-rolled fetch client against an env-var base URL (no SDK, no hardcoded
- * URL), so the generic external-source scanner misses it entirely — detection
- * keys on the distinctive local signals instead:
- *   - a dependency whose name mentions strapi (`@repo/strapi-types`,
- *     `@strapi/client`, generated types packages);
- *   - a `strapi`-named client module under `src/lib`/`src`;
- *   - Strapi's `api::x.y` content-type UID strings in the source;
- *   - a `STRAPI`-flavored base-URL env var.
- * The co-located Strapi app (monorepo) is located by walking up to the
- * workspace root and finding the sibling that depends on `@strapi/strapi`; its
- * path drives schema import. A decoupled Strapi (no co-located app) still
- * surfaces as a source for the keep-live decision, with `appDir: null`.
- */
-const UID_RE = /["'`]api::[a-z0-9-]+\.[a-z0-9-]+["'`]/;
-const STRAPI_ENV_RE = /STRAPI[A-Z0-9_]*_URL|NEXT_PUBLIC_STRAPI/;
-const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs)$/;
-const SKIP_DIRS = new Set(['node_modules', '.next', '.turbo', 'dist', 'build', '.git', 'coverage']);
-const MAX_FILES_SCANNED = 400;
-function safeReaddir(dir) {
-    try {
-        return readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-}
-function readDeps(dir) {
-    try {
-        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
-        return { ...pkg.dependencies, ...pkg.devDependencies };
-    }
-    catch {
-        return {};
-    }
-}
-function strapiDependency(deps) {
-    for (const name of Object.keys(deps)) {
-        if (/strapi/i.test(name)) {
-            return name;
-        }
-    }
-    return null;
-}
-/** Shallow look for a `strapi`-named client module under src/lib or src. */
-function strapiLibModule(frontendDir) {
-    for (const base of [join(frontendDir, 'src', 'lib'), join(frontendDir, 'src'), join(frontendDir, 'lib')]) {
-        if (!existsSync(base)) {
-            continue;
-        }
-        try {
-            for (const entry of readdirSync(base, { withFileTypes: true })) {
-                if (/strapi/i.test(entry.name)) {
-                    return join(base, entry.name);
-                }
-            }
-        }
-        catch {
-            // unreadable dir — ignore
-        }
-    }
-    return null;
-}
-/** Bounded source scan for `api::x.y` UID strings or a STRAPI base-URL env. */
-function scanSourceSignals(frontendDir) {
-    const root = existsSync(join(frontendDir, 'src')) ? join(frontendDir, 'src') : frontendDir;
-    let scanned = 0;
-    let uid = false;
-    let env = false;
-    const walk = (dir) => {
-        if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
-            return;
-        }
-        for (const entry of safeReaddir(dir)) {
-            if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
-                return;
-            }
-            if (entry.isDirectory()) {
-                if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
-                    walk(join(dir, entry.name));
-                }
-                continue;
-            }
-            if (!SOURCE_EXT_RE.test(entry.name)) {
-                continue;
-            }
-            scanned += 1;
-            try {
-                const text = readFileSync(join(dir, entry.name), 'utf8');
-                if (!uid && UID_RE.test(text)) {
-                    uid = true;
-                }
-                if (!env && STRAPI_ENV_RE.test(text)) {
-                    env = true;
-                }
-            }
-            catch {
-                // unreadable file — ignore
-            }
-        }
-    };
-    walk(root);
-    return { uid, env };
-}
-function findWorkspaceRoot(startDir) {
-    let dir = startDir;
-    for (let depth = 0; depth < 6; depth += 1) {
-        if (existsSync(join(dir, 'pnpm-workspace.yaml')) ||
-            existsSync(join(dir, 'turbo.json')) ||
-            existsSync(join(dir, 'lerna.json'))) {
-            return dir;
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            break;
-        }
-        dir = parent;
-    }
-    return null;
-}
-/** Find the sibling app that depends on `@strapi/strapi` (the CMS app). */
-function findStrapiApp(frontendDir) {
-    const root = findWorkspaceRoot(frontendDir);
-    if (!root) {
-        return null;
-    }
-    const searchRoots = [join(root, 'apps'), root, join(root, 'packages')];
-    for (const searchRoot of searchRoots) {
-        if (!existsSync(searchRoot)) {
-            continue;
-        }
-        for (const entry of safeReaddir(searchRoot)) {
-            if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
-                continue;
-            }
-            const candidate = join(searchRoot, entry.name);
-            const deps = readDeps(candidate);
-            if (deps['@strapi/strapi'] && existsSync(join(candidate, 'src', 'api'))) {
-                return candidate;
-            }
-        }
-    }
-    return null;
-}
-export function detectStrapi(frontendDir) {
-    if (!existsSync(frontendDir) || !statSync(frontendDir).isDirectory()) {
-        return null;
-    }
-    const evidence = [];
-    const dep = strapiDependency(readDeps(frontendDir));
-    if (dep) {
-        evidence.push(`dependency ${dep}`);
-    }
-    const libModule = strapiLibModule(frontendDir);
-    if (libModule) {
-        evidence.push(`client module ${libModule.slice(frontendDir.length + 1)}`);
-    }
-    // Only pay for the source scan when the cheap signals are inconclusive.
-    if (evidence.length === 0) {
-        const signals = scanSourceSignals(frontendDir);
-        if (signals.uid) {
-            evidence.push('api::* content-type UIDs in source');
-        }
-        if (signals.env) {
-            evidence.push('STRAPI base-URL env var');
-        }
-    }
-    if (evidence.length === 0) {
-        return null;
-    }
-    const appDir = findStrapiApp(frontendDir);
-    if (appDir) {
-        evidence.push(`schemas in ${appDir.slice(findWorkspaceRoot(frontendDir).length + 1)}`);
-    }
-    return {
-        cms: 'Strapi',
-        host: 'Strapi',
-        appDir,
-        clientDir: libModule,
-        evidence,
-        locales: [],
-    };
-}