fimo 0.6.0 → 0.7.0-experimental.10

package/dist/scripts/apply-wrap.test.js

@@ -0,0 +1,226 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { applyWrap, ensureFimoImport, keyScope, slugify } from './apply-wrap.js';
+import { scanWrappable } from './scan-wrappable.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'apply-wrap-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('keyScope / slugify', () => {
+    it('derives scopes from app-router paths', () => {
+        expect(keyScope('app/page.tsx')).toBe('home');
+        expect(keyScope('app/about/page.tsx')).toBe('about');
+        expect(keyScope('app/(marketing)/pricing/page.tsx')).toBe('pricing');
+        expect(keyScope('app/layout.tsx')).toBe('layout');
+        expect(keyScope('components/Footer.tsx')).toBe('footer');
+    });
+    it('slugifies text deterministically', () => {
+        expect(slugify('To get started, edit the page.tsx file.')).toBe('to-get-started-edit');
+        expect(slugify('Déjà vu!')).toBe('deja-vu');
+    });
+});
+describe('ensureFimoImport', () => {
+    it('inserts after the last import', () => {
+        const out = ensureFimoImport('import x from "y";\n\nconst a = 1;', ['FimoText']);
+        expect(out).toContain('import x from "y";\nimport { FimoText } from "fimo/next";');
+    });
+    it('merges into an existing fimo/next import', () => {
+        const out = ensureFimoImport('import { FimoText } from "fimo/next";\n', ['FimoMediaImage', 'FimoText']);
+        expect(out).toContain('import { FimoMediaImage, FimoText } from "fimo/next";');
+    });
+    it('decodes JSX entities in generated label values (fallback keeps the source form)', async () => {
+        const { applyWrapToFile, KeyAllocator } = await import('./apply-wrap.js');
+        const code = `export default function P() {\n  return <p>What&apos;s next &amp; more?</p>;\n}`;
+        const result = applyWrapToFile(code, [
+            {
+                kind: 'text',
+                file: 'app/page.tsx',
+                line: 2,
+                preview: 'What&apos;s next &amp; more?',
+                span: { start: code.indexOf('What'), end: code.indexOf('?</p>') + 1, parentTag: 'p' },
+            },
+        ], new KeyAllocator([]));
+        const [value] = Object.values(result.labels);
+        expect(value).toBe("What's next & more?");
+        expect(result.code).toContain('What&apos;s next &amp; more?');
+    });
+    it('targets the adapter module of the detected framework, never fimo/next unconditionally', () => {
+        const inserted = ensureFimoImport('const a = 1;', ['FimoText'], 'fimo/remix');
+        expect(inserted).toContain('import { FimoText } from "fimo/remix";');
+        const merged = ensureFimoImport('import { FimoText } from "fimo/remix";\n', ['FimoMediaImage'], 'fimo/remix');
+        expect(merged).toContain('import { FimoMediaImage, FimoText } from "fimo/remix";');
+    });
+});
+describe('applyWrap', () => {
+    it('wraps plain text, images, and file links; leaves judgment items', () => {
+        const cwd = project({
+            'app/page.tsx': `export default function Page() {
+  return (
+    <main>
+      <h1>Ship your site in hours</h1>
+      <img src="/hero.png" alt="Hero" />
+      <a href="/whitepaper.pdf">Download the whitepaper</a>
+      <p>Read <strong>honest numbers</strong> today</p>
+      <input placeholder="Your email" />
+      <select><option>Pick one</option></select>
+    </main>
+  );
+}`,
+        });
+        const result = applyWrap(cwd);
+        const code = readFileSync(join(cwd, 'app/page.tsx'), 'utf8');
+        expect(code).toContain('<FimoText id="home.ship-your-site-in">Ship your site in hours</FimoText>');
+        expect(code).toContain('<FimoMediaImage id="home.hero" src="/hero.png" alt="Hero" />');
+        expect(code).toContain('<FimoFileLink id="home.whitepaper" href="/whitepaper.pdf">');
+        expect(code).toContain('</FimoFileLink>');
+        expect(code).toContain('import { FimoFileLink, FimoMediaImage, FimoText } from "fimo/next";');
+        // Judgment items untouched: option text, attribute, rich-ish fragments.
+        expect(code).toContain('<option>Pick one</option>');
+        expect(code).toContain('placeholder="Your email"');
+        expect(result.skipped.some((entry) => entry.reason.includes('<option>'))).toBe(true);
+        expect(result.skipped.some((entry) => entry.item.kind === 'attribute')).toBe(true);
+        // Labels generated for wrapped text (incl. link text wrapped inside FimoFileLink).
+        expect(result.labels['home.ship-your-site-in']).toBe('Ship your site in hours');
+        // The wrapped file parses again and the safe items are gone.
+        const rescan = scanWrappable(cwd);
+        expect(rescan.items.filter((item) => item.kind === 'image' || item.kind === 'file-link')).toEqual([]);
+        expect(rescan.wrappedIds.media).toEqual(['home.hero']);
+        expect(rescan.wrappedIds.files).toEqual(['home.whitepaper']);
+    });
+    it('is idempotent: a second apply changes nothing', () => {
+        const cwd = project({
+            'app/about/page.tsx': `export default function About() {
+  return <h1>We believe analytics should be readable</h1>;
+}`,
+        });
+        applyWrap(cwd);
+        const once = readFileSync(join(cwd, 'app/about/page.tsx'), 'utf8');
+        const second = applyWrap(cwd);
+        const twice = readFileSync(join(cwd, 'app/about/page.tsx'), 'utf8');
+        expect(twice).toBe(once);
+        expect(second.applied).toEqual([]);
+        expect(second.filesChanged).toEqual([]);
+    });
+    it('skips items recorded as exemptions (exempt-first, then --apply wraps the rest)', () => {
+        const cwd = project({
+            'app/page.tsx': `export default function Page() {
+  return (
+    <main>
+      <h1>Wrap this headline</h1>
+      <p>But keep this dev note verbatim</p>
+    </main>
+  );
+}`,
+            '.fimo/migration/manifest.json': JSON.stringify({
+                wrap: {
+                    exemptions: [
+                        {
+                            file: 'app/page.tsx',
+                            kind: 'text',
+                            preview: 'But keep this dev note verbatim',
+                            reason: 'dev-only note',
+                            status: 'unresolved',
+                        },
+                    ],
+                },
+            }),
+        });
+        const result = applyWrap(cwd);
+        const code = readFileSync(join(cwd, 'app/page.tsx'), 'utf8');
+        // The non-exempt headline is auto-wrapped...
+        expect(code).toContain('<FimoText id="home.wrap-this-headline">Wrap this headline</FimoText>');
+        // ...the exempt item is left byte-for-byte and never labelled.
+        expect(code).toContain('<p>But keep this dev note verbatim</p>');
+        expect(code).not.toContain('FimoText id="home.but-keep');
+        expect(Object.values(result.labels)).not.toContain('But keep this dev note verbatim');
+        expect(Object.values(result.labels)).toContain('Wrap this headline');
+    });
+    it('leaves next/image components to the agent', () => {
+        const cwd = project({
+            'app/page.tsx': `import Image from "next/image";
+export default function Page() {
+  return <Image src="/logo.svg" alt="Logo" width={10} height={10} priority />;
+}`,
+        });
+        const result = applyWrap(cwd);
+        expect(result.applied).toEqual([]);
+        expect(result.skipped.some((entry) => entry.reason.includes('next/image'))).toBe(true);
+        expect(readFileSync(join(cwd, 'app/page.tsx'), 'utf8')).toContain('<Image src="/logo.svg"');
+    });
+    it('preserves surrounding whitespace so rendering stays identical', () => {
+        const cwd = project({
+            'app/page.tsx': `export default function Page() {
+  return (
+    <p>
+      Hello world from Fimo
+    </p>
+  );
+}`,
+        });
+        applyWrap(cwd);
+        const code = readFileSync(join(cwd, 'app/page.tsx'), 'utf8');
+        expect(code).toMatch(/<p>\n      <FimoText id="home\.hello-world-from-fimo">Hello world from Fimo<\/FimoText>\n    <\/p>/);
+    });
+    it('avoids key collisions across duplicate texts', () => {
+        const cwd = project({
+            'app/page.tsx': `export default function Page() {
+  return (
+    <div>
+      <button>Contact us</button>
+      <button>Contact us</button>
+    </div>
+  );
+}`,
+        });
+        const result = applyWrap(cwd);
+        expect(Object.keys(result.labels).sort()).toEqual(['home.contact-us', 'home.contact-us-2']);
+    });
+});
+describe('back-office exclusion', () => {
+    it('never touches excluded sections', () => {
+        const cwd = project({
+            'app/admin/page.tsx': `export default function Admin() {
+  return <h1>Secret admin panel</h1>;
+}`,
+            'app/page.tsx': `export default function Home() {
+  return <h1>Public home</h1>;
+}`,
+        });
+        const result = applyWrap(cwd, { excludePrefixes: ['app/admin'] });
+        expect(readFileSync(join(cwd, 'app/admin/page.tsx'), 'utf8')).not.toContain('FimoText');
+        expect(readFileSync(join(cwd, 'app/page.tsx'), 'utf8')).toContain('FimoText');
+        expect(result.applied.map((entry) => entry.file)).toEqual(['app/page.tsx']);
+    });
+});
+describe('ensureFimoImport with multiline imports', () => {
+    it('inserts after a multiline import statement, never inside it', () => {
+        const code = `import { useEffect } from "react";
+import {
+  AnimatedSpan,
+  Terminal,
+  TypingAnimation,
+} from "@/components/magicui/terminal";
+
+export function X() { return null; }`;
+        const out = ensureFimoImport(code, ['FimoText']);
+        expect(out).toContain('} from "@/components/magicui/terminal";\nimport { FimoText } from "fimo/next";');
+        expect(out.indexOf('import { FimoText }')).toBeGreaterThan(out.indexOf('TypingAnimation'));
+    });
+    it('prepends when the file has no imports', () => {
+        const out = ensureFimoImport('export const x = 1;', ['FimoText']);
+        expect(out.startsWith('import { FimoText } from "fimo/next";\n')).toBe(true);
+    });
+});

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

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

package/dist/scripts/cms/discover.js

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,32 @@
+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 are omitted (a fake URL
+ * would render a broken image), references point at the first example of the
+ * target type (`<target>-example-1`) so they resolve against the co-seeded
+ * data, 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

@@ -0,0 +1,108 @@
+const DEFAULT_COUNT = 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;
+}
+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;
+            }
+            switch (def.type) {
+                case 'string':
+                    row[field] = `${humanize(field)} example ${i}${localeSuffix}`;
+                    break;
+                case 'richtext':
+                    row[field] = richTextDoc(`Example ${humanize(schema.name).toLowerCase()} content ${i}${localeSuffix}.`);
+                    break;
+                case 'number':
+                    row[field] = i;
+                    break;
+                case 'boolean':
+                    row[field] = i % 2 === 1;
+                    break;
+                case 'date':
+                    row[field] = exampleDate(i);
+                    break;
+                case 'json':
+                    row[field] = {};
+                    break;
+                case 'media':
+                    row[field] = placeholderMedia(humanize(field));
+                    break;
+                case '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 } : {}),
+                        };
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        rows.push(row);
+    }
+    return { name: schema.name, isSingleton: schema.isSingleton, localized: schema.localized, rows, references };
+}

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

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

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

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { generateExampleSeed } from './example-content.js';
+const blogPost = {
+    name: 'BlogPost',
+    label: 'Blog Post',
+    isSingleton: false,
+    localized: false,
+    fields: {
+        title: { type: 'string' },
+        content: { type: 'richtext' },
+        readTime: { type: 'number' },
+        featured: { type: 'boolean' },
+        publishedOn: { type: 'date' },
+        meta: { type: 'json' },
+        cover: { type: 'media' },
+        category: { type: 'reference', target: 'PostCategory' },
+        tags: { type: 'reference', target: 'PostTag', many: true },
+    },
+    sourceUid: 'api::blog-post.blog-post',
+    sourcePath: '/blog-posts',
+};
+describe('generateExampleSeed', () => {
+    it('generates typed rows with a slug per collection entry', () => {
+        const seed = generateExampleSeed(blogPost, { count: 2 });
+        expect(seed.rows).toHaveLength(2);
+        const [first, second] = seed.rows;
+        expect(first.slug).toBe('blog-post-example-1');
+        expect(first.title).toBe('Title example 1');
+        expect(first.content).toMatchObject({ type: 'doc' });
+        expect(first.readTime).toBe(1);
+        expect(first.featured).toBe(true);
+        expect(second.featured).toBe(false);
+        expect(first.publishedOn).toBe('2024-01-01');
+        expect(second.publishedOn).toBe('2024-01-02');
+        expect(first.meta).toEqual({});
+    });
+    it('seeds a self-contained placeholder for media fields', () => {
+        const seed = generateExampleSeed(blogPost, { count: 1 });
+        expect(seed.rows[0].cover).toMatchObject({ source: 'local', width: 1200, height: 630 });
+        expect(seed.rows[0].cover.url).toContain('data:image/svg+xml');
+    });
+    it('points references at the first example of the target, with a descriptor', () => {
+        const seed = generateExampleSeed(blogPost, { count: 1 });
+        expect(seed.rows[0].category).toBe('post-category-example-1');
+        expect(seed.rows[0].tags).toEqual(['post-tag-example-1']);
+        expect(seed.references.category).toEqual({ target: 'PostCategory', by: 'slug' });
+        expect(seed.references.tags).toEqual({ target: 'PostTag', by: 'slug', many: true });
+    });
+    it('gives a singleton exactly one slug-less row', () => {
+        const seed = generateExampleSeed({ ...blogPost, name: 'Global', isSingleton: true }, { count: 5 });
+        expect(seed.rows).toHaveLength(1);
+        expect(seed.rows[0].slug).toBeUndefined();
+    });
+    it('varies string values per locale so per-language editing is visible', () => {
+        const fr = generateExampleSeed(blogPost, { count: 1, locale: 'fr' });
+        expect(fr.rows[0].title).toBe('Title example 1 (fr)');
+    });
+    it('uses a connector-supplied example (dynamic-zone array) over the type default', () => {
+        const withExample = {
+            ...blogPost,
+            fields: { ...blogPost.fields, sections: { type: 'json' } },
+            examples: { sections: [] },
+        };
+        expect(generateExampleSeed(withExample, { count: 1 }).rows[0].sections).toEqual([]);
+    });
+});

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

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

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

@@ -0,0 +1,186 @@
+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: [],
+    };
+}

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

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