fimo 0.6.0 → 0.7.0-experimental.10

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

@@ -0,0 +1,56 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { detectStrapi } from './detect.js';
+let root;
+function pkg(dir, deps) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 't', dependencies: deps }));
+}
+afterEach(() => {
+    if (root) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('detectStrapi', () => {
+    it('detects Strapi in a monorepo via a types dep and locates the CMS app', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-'));
+        writeFileSync(join(root, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n');
+        const frontend = join(root, 'apps', 'ui');
+        pkg(frontend, { next: '^16.0.0', '@repo/strapi-types': 'workspace:*' });
+        const cms = join(root, 'apps', 'strapi');
+        pkg(cms, { '@strapi/strapi': '5.48.1' });
+        mkdirSync(join(cms, 'src', 'api'), { recursive: true });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.cms).toBe('Strapi');
+        expect(detection.host).toBe('Strapi');
+        expect(detection.appDir).toBe(cms);
+        expect(detection.evidence.some((e) => e.includes('@repo/strapi-types'))).toBe(true);
+    });
+    it('detects Strapi via a strapi-named client module with no dependency', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-lib-'));
+        const frontend = join(root, 'app');
+        pkg(frontend, { next: '^16.0.0' });
+        mkdirSync(join(frontend, 'src', 'lib', 'strapi-api'), { recursive: true });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.evidence.some((e) => e.includes('strapi-api'))).toBe(true);
+    });
+    it('detects a decoupled Strapi (SDK dep, no co-located app) with a null appDir', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-decoupled-'));
+        const frontend = join(root, 'frontend');
+        pkg(frontend, { next: '^16.0.0', '@strapi/client': '^1.0.0' });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.appDir).toBeNull();
+    });
+    it('returns null when there is no Strapi signal', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-none-'));
+        const frontend = join(root, 'app');
+        pkg(frontend, { next: '^16.0.0', '@sanity/client': '^3.0.0' });
+        mkdirSync(join(frontend, 'src', 'components'), { recursive: true });
+        expect(detectStrapi(frontend)).toBeNull();
+    });
+});

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

@@ -0,0 +1,3 @@
+import type { CmsConnector } from '../types.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export declare function strapiConnector(frontendDir: string): CmsConnector | null;

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

@@ -0,0 +1,25 @@
+import { detectStrapi } from './detect.js';
+import { renderStrapiListSource } from './list-source.js';
+import { readStrapiSchemas } from './schema-map.js';
+import { detectStrapiTouchpoints } from './touchpoints.js';
+import { wireStrapiClient } from './wire-client.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export function strapiConnector(frontendDir) {
+    const detection = detectStrapi(frontendDir);
+    if (!detection) {
+        return null;
+    }
+    return {
+        detection,
+        readSchemas: () => (detection.appDir ? readStrapiSchemas(detection.appDir) : []),
+        renderListSource: (schemas, serverImport) => schemas.length > 0 ? renderStrapiListSource(schemas, serverImport) : null,
+        wireClient: (cwd, schemas) => detection.clientDir
+            ? wireStrapiClient(cwd, detection.clientDir, schemas)
+            : {
+                changes: [],
+                warnings: ['No Strapi client directory detected — wire fimoStrapiFetch manually.'],
+                wired: false,
+            },
+        detectTouchpoints: (cwd) => detectStrapiTouchpoints(cwd),
+    };
+}

package/dist/scripts/cms/strapi/list-source.d.ts

@@ -0,0 +1,17 @@
+import type { CmsCollectionSchema } from '../types.js';
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export declare function renderStrapiListSource(schemas: CmsCollectionSchema[], serverImport: string): string;

package/dist/scripts/cms/strapi/list-source.js

@@ -0,0 +1,90 @@
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export function renderStrapiListSource(schemas, serverImport) {
+    const entries = schemas
+        .filter((schema) => !schema.isSingleton)
+        .map((schema) => `  '${schema.sourceUid}': '${schema.name}',`)
+        .join('\n');
+    return `// AUTO-GENERATED by \`fimo migrate --scaffold-cms\`. Renders the CMS collections
+// scaffolded into Fimo (EXAMPLE content) for LIST views, so pages show the fake
+// content from Fimo while detail views and dynamic zones stay on your CMS.
+//
+// Wire your CMS client's list methods to this (see the migration prompt), e.g.
+// inside fetchMany/fetchAll:  const fimo = await fimoCmsList(uid, { limit });
+//                             if (fimo) return fimo;
+// Best-effort and generic by design — adjust per component as needed.
+import { fetchEntries } from '${serverImport}';
+
+// Strapi content-type UID -> Fimo type name (from the scaffold).
+const FIMO_TYPES: Record<string, string> = {
+${entries}
+};
+
+function docToText(node: unknown): string {
+  if (!node || typeof node !== 'object') {
+    return '';
+  }
+  const record = node as { text?: unknown; content?: unknown };
+  if (typeof record.text === 'string') {
+    return record.text;
+  }
+  if (Array.isArray(record.content)) {
+    return record.content.map(docToText).join(' ');
+  }
+  return '';
+}
+
+function reshapeValue(value: unknown): unknown {
+  // Richtext is a ProseMirror doc -> flatten to plain text so string consumers
+  // (excerpts, read-time) are safe. Media { url, ... } and scalars pass through.
+  if (value && typeof value === 'object' && (value as { type?: unknown }).type === 'doc') {
+    return docToText(value);
+  }
+  return value;
+}
+
+function reshape(data: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    out[key] = reshapeValue(value);
+  }
+  return out;
+}
+
+/**
+ * A Strapi-v5-shaped list envelope built from the scaffolded Fimo content, or
+ * null when nothing was scaffolded for this UID (fall back to the live CMS).
+ */
+export async function fimoCmsList(
+  uid: string,
+  options: { limit?: number } = {}
+): Promise<{ data: Record<string, unknown>[]; meta: { pagination: Record<string, number> } } | null> {
+  const typeName = FIMO_TYPES[uid];
+  if (!typeName) {
+    return null;
+  }
+  const entries = await fetchEntries(typeName, options.limit ? { limit: options.limit } : {});
+  if (entries.length === 0) {
+    return null;
+  }
+  const data = entries.map((entry) => ({ id: entry.id, documentId: entry.id, ...reshape(entry.data) }));
+  return {
+    data,
+    meta: { pagination: { page: 1, pageSize: data.length, pageCount: 1, total: data.length } },
+  };
+}
+`;
+}

package/dist/scripts/cms/strapi/list-source.test.d.ts

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

package/dist/scripts/cms/strapi/list-source.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { renderStrapiListSource } from './list-source.js';
+const schema = (name, sourceUid, isSingleton = false) => ({
+    name,
+    label: name,
+    isSingleton,
+    localized: false,
+    fields: {},
+    sourceUid,
+    sourcePath: `/${name.toLowerCase()}`,
+});
+describe('renderStrapiListSource', () => {
+    it('emits a helper importing fetchEntries with a uid→type map for collections only', () => {
+        const src = renderStrapiListSource([
+            schema('BlogPost', 'api::blog-post.blog-post'),
+            schema('PostTag', 'api::post-tag.post-tag'),
+            schema('Global', 'api::global.global', true),
+        ], 'fimo/next/server');
+        expect(src).toContain("import { fetchEntries } from 'fimo/next/server';");
+        expect(src).toContain("'api::blog-post.blog-post': 'BlogPost',");
+        expect(src).toContain("'api::post-tag.post-tag': 'PostTag',");
+        // Singletons have no list view — excluded from the map.
+        expect(src).not.toContain('api::global.global');
+        expect(src).toContain('export async function fimoCmsList(');
+        // Richtext flattening + fallback-to-CMS contract are present.
+        expect(src).toContain('docToText');
+        expect(src).toContain('return null');
+    });
+    it('threads the framework server import through', () => {
+        const src = renderStrapiListSource([schema('Cms', 'api::cms.cms')], 'fimo/astro/server');
+        expect(src).toContain("import { fetchEntries } from 'fimo/astro/server';");
+    });
+});

package/dist/scripts/cms/strapi/schema-map.d.ts

@@ -0,0 +1,9 @@
+import type { CmsCollectionSchema } from '../types.js';
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export declare function pascalCase(name: string): string;
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields.
+ */
+export declare function readStrapiSchemas(strapiAppDir: string): CmsCollectionSchema[];

package/dist/scripts/cms/strapi/schema-map.js

@@ -0,0 +1,149 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const TO_MANY = new Set(['oneToMany', 'manyToMany']);
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export function pascalCase(name) {
+    return name
+        .replace(/[^a-zA-Z0-9]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (c) => c.toUpperCase());
+}
+/**
+ * Map one Strapi attribute to a Fimo field. Returns `null` for fields Fimo does
+ * not model as content (the slug uid, passwords). Relations to imported types
+ * become references; relations to non-imported targets (users, plugins) and
+ * structural fields (components, dynamic zones) fall back to `json` so example
+ * content round-trips and never dangles.
+ */
+function mapAttribute(field, attr, uidToName) {
+    if (field === 'slug') {
+        // Fimo reserves `slug` as entry metadata (set inside the row data).
+        return null;
+    }
+    switch (attr.type) {
+        case 'password':
+            return null;
+        case 'string':
+        case 'text':
+        case 'email':
+        case 'uid':
+        case 'enumeration':
+            return { type: 'string' };
+        case 'richtext':
+        case 'blocks':
+            return { type: 'richtext' };
+        case 'integer':
+        case 'biginteger':
+        case 'decimal':
+        case 'float':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'date':
+        case 'datetime':
+        case 'time':
+        case 'timestamp':
+            return { type: 'date' };
+        case 'media':
+            return { type: 'media' };
+        case 'json':
+        case 'component':
+        case 'dynamiczone':
+            return { type: 'json' };
+        case 'relation': {
+            const targetName = attr.target ? uidToName.get(attr.target) : undefined;
+            if (!targetName) {
+                // Relation to a non-imported target (users-permissions, other plugins).
+                return { type: 'json' };
+            }
+            const many = attr.relation ? TO_MANY.has(attr.relation) : false;
+            return many ? { type: 'reference', target: targetName, many: true } : { type: 'reference', target: targetName };
+        }
+        default:
+            // Unknown/custom attribute — never crash; keep the value verbatim.
+            return { type: 'json' };
+    }
+}
+function mapSchema(raw, uidToName) {
+    const info = raw.schema.info ?? {};
+    const name = uidToName.get(raw.uid);
+    const fields = {};
+    const examples = {};
+    for (const [field, attr] of Object.entries(raw.schema.attributes ?? {})) {
+        const mapped = mapAttribute(field, attr, uidToName);
+        if (mapped) {
+            fields[field] = mapped;
+            // Dynamic zones (and repeatable components) render as ARRAYS a page
+            // builder maps over; a single component as an OBJECT. Seed the correct
+            // empty shape so pages render instead of crashing on `{}.map(...)`.
+            if (attr.type === 'dynamiczone' || (attr.type === 'component' && attr.repeatable)) {
+                examples[field] = [];
+            }
+            else if (attr.type === 'component') {
+                examples[field] = {};
+            }
+        }
+    }
+    return {
+        name,
+        label: info.displayName || name,
+        isSingleton: raw.schema.kind === 'singleType',
+        localized: raw.schema.pluginOptions?.i18n?.localized === true,
+        fields,
+        ...(Object.keys(examples).length > 0 ? { examples } : {}),
+        sourceUid: raw.uid,
+        sourcePath: `/${info.pluralName ?? raw.contentTypeName}`,
+    };
+}
+/** Walk `<strapiAppDir>/src/api/<api>/content-types/<ct>/schema.json`. */
+function collectRawSchemas(strapiAppDir) {
+    const apiDir = join(strapiAppDir, 'src', 'api');
+    if (!existsSync(apiDir)) {
+        return [];
+    }
+    const raws = [];
+    for (const apiEntry of readdirSync(apiDir, { withFileTypes: true })) {
+        if (!apiEntry.isDirectory()) {
+            continue;
+        }
+        const ctRoot = join(apiDir, apiEntry.name, 'content-types');
+        if (!existsSync(ctRoot)) {
+            continue;
+        }
+        for (const ctEntry of readdirSync(ctRoot, { withFileTypes: true })) {
+            if (!ctEntry.isDirectory()) {
+                continue;
+            }
+            const schemaPath = join(ctRoot, ctEntry.name, 'schema.json');
+            if (!existsSync(schemaPath)) {
+                continue;
+            }
+            try {
+                const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+                raws.push({
+                    uid: `api::${apiEntry.name}.${ctEntry.name}`,
+                    apiName: apiEntry.name,
+                    contentTypeName: ctEntry.name,
+                    schema,
+                });
+            }
+            catch {
+                // Malformed schema.json — skip, never abort the whole import.
+            }
+        }
+    }
+    return raws;
+}
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields.
+ */
+export function readStrapiSchemas(strapiAppDir) {
+    const raws = collectRawSchemas(strapiAppDir);
+    const uidToName = new Map();
+    for (const raw of raws) {
+        const singular = raw.schema.info?.singularName ?? raw.contentTypeName;
+        uidToName.set(raw.uid, pascalCase(singular));
+    }
+    return raws.map((raw) => mapSchema(raw, uidToName)).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/scripts/cms/strapi/schema-map.test.d.ts

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

package/dist/scripts/cms/strapi/schema-map.test.js

@@ -0,0 +1,91 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { readStrapiSchemas } from './schema-map.js';
+let dir;
+function writeSchema(apiName, ctName, schema) {
+    const ctDir = join(dir, 'src', 'api', apiName, 'content-types', ctName);
+    mkdirSync(ctDir, { recursive: true });
+    writeFileSync(join(ctDir, 'schema.json'), JSON.stringify(schema));
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('readStrapiSchemas', () => {
+    it('maps Strapi attribute types to Fimo fields and resolves relations', () => {
+        dir = mkdtempSync(join(tmpdir(), 'strapi-schema-'));
+        writeSchema('blog-post', 'blog-post', {
+            kind: 'collectionType',
+            info: { singularName: 'blog-post', pluralName: 'blog-posts', displayName: 'Blog Post' },
+            pluginOptions: {},
+            attributes: {
+                title: { type: 'string', required: true },
+                slug: { type: 'uid', targetField: 'title' },
+                content: { type: 'richtext' },
+                readTime: { type: 'integer' },
+                featured: { type: 'boolean' },
+                publishedAt: { type: 'datetime' },
+                level: { type: 'enumeration', enum: ['a', 'b'] },
+                cover: { type: 'media' },
+                hero: { type: 'component', component: 'blocks.hero', repeatable: false },
+                sections: { type: 'dynamiczone', components: [] },
+                category: { type: 'relation', relation: 'manyToOne', target: 'api::post-category.post-category' },
+                tags: { type: 'relation', relation: 'manyToMany', target: 'api::post-tag.post-tag' },
+                author: { type: 'relation', relation: 'manyToOne', target: 'plugin::users-permissions.user' },
+            },
+        });
+        writeSchema('post-category', 'post-category', {
+            kind: 'collectionType',
+            info: { singularName: 'post-category', pluralName: 'post-categories', displayName: 'Post Category' },
+            attributes: { name: { type: 'string' }, slug: { type: 'uid' } },
+        });
+        writeSchema('post-tag', 'post-tag', {
+            kind: 'collectionType',
+            info: { singularName: 'post-tag', pluralName: 'post-tags', displayName: 'Post Tag' },
+            attributes: { name: { type: 'string' } },
+        });
+        writeSchema('global', 'global', {
+            kind: 'singleType',
+            info: { singularName: 'global', pluralName: 'globals', displayName: 'Global' },
+            pluginOptions: { i18n: { localized: true } },
+            attributes: { siteName: { type: 'string' } },
+        });
+        const schemas = readStrapiSchemas(dir);
+        expect(schemas.map((s) => s.name)).toEqual(['BlogPost', 'Global', 'PostCategory', 'PostTag']);
+        const blogPost = schemas.find((s) => s.name === 'BlogPost');
+        expect(blogPost.isSingleton).toBe(false);
+        expect(blogPost.localized).toBe(false);
+        expect(blogPost.sourceUid).toBe('api::blog-post.blog-post');
+        expect(blogPost.fields).toMatchObject({
+            title: { type: 'string' },
+            content: { type: 'richtext' },
+            readTime: { type: 'number' },
+            featured: { type: 'boolean' },
+            publishedAt: { type: 'date' },
+            level: { type: 'string' },
+            cover: { type: 'media' },
+            hero: { type: 'json' },
+            sections: { type: 'json' },
+            category: { type: 'reference', target: 'PostCategory' },
+            tags: { type: 'reference', target: 'PostTag', many: true },
+            author: { type: 'json' },
+        });
+        // slug is reserved entry metadata — never a schema field.
+        expect('slug' in blogPost.fields).toBe(false);
+        // Structural fields get the correct empty shape so pages render:
+        // dynamic zone → array, single component → object.
+        expect(blogPost.examples?.sections).toEqual([]);
+        expect(blogPost.examples?.hero).toEqual({});
+        const global = schemas.find((s) => s.name === 'Global');
+        expect(global.isSingleton).toBe(true);
+        expect(global.localized).toBe(true);
+    });
+    it('returns an empty list when the app has no content types', () => {
+        dir = mkdtempSync(join(tmpdir(), 'strapi-schema-empty-'));
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        expect(readStrapiSchemas(dir)).toEqual([]);
+    });
+});

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

@@ -0,0 +1,31 @@
+export type StrapiCallReason = 'strapi-sdk-import' | 'env-ref' | 'uid-ref';
+export interface StrapiCallSite {
+    /** Path relative to the frontend directory. */
+    file: string;
+    line: number;
+    reason: StrapiCallReason;
+    snippet: string;
+}
+export interface StrapiTouchpoints {
+    /** Strapi SDK / client / generated-type packages still declared in package.json. */
+    dependencies: string[];
+    /** Source lines that still reach Strapi at runtime. */
+    callSites: StrapiCallSite[];
+    /** `STRAPI_*` keys still present in dotenv files (cleanup; low severity). */
+    envVars: string[];
+    /** No runtime Strapi coupling remains (no SDK deps, no call sites): the cutover is complete. */
+    clean: boolean;
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export declare function detectStrapiTouchpoints(frontendDir: string): StrapiTouchpoints;

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

@@ -0,0 +1,145 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs|astro|vue|svelte)$/;
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.vercel',
+    '.git',
+]);
+const MAX_FILES = 2000;
+/** A runtime reference to Strapi's base-URL / token env config. */
+const ENV_REF_RE = /\bSTRAPI[A-Z0-9_]*_URL\b|\bNEXT_PUBLIC_STRAPI[A-Z0-9_]*\b|\bSTRAPI[A-Z0-9_]*_TOKEN\b/;
+/** A Strapi content-type UID string (`api::article.article`). */
+const UID_REF_RE = /api::[a-z0-9-]+\.[a-z0-9-]+/;
+/** An import/require specifier — captured so a Strapi SDK can be told apart from `fimo/strapi`. */
+const IMPORT_RE = /(?:from\s+|require\(\s*|import\(\s*)['"`]([^'"`]+)['"`]/;
+/** A STRAPI env assignment in a dotenv file. */
+const ENV_KEY_RE = /^\s*([A-Z0-9_]*STRAPI[A-Z0-9_]*)\s*=/;
+function readDeps(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+function classifyLine(line) {
+    const importMatch = IMPORT_RE.exec(line);
+    // A Strapi SDK/client import — but NOT the `fimo/strapi` compat adapter.
+    if (importMatch && /strapi/i.test(importMatch[1]) && !/fimo/i.test(importMatch[1])) {
+        return 'strapi-sdk-import';
+    }
+    if (ENV_REF_RE.test(line)) {
+        return 'env-ref';
+    }
+    if (UID_REF_RE.test(line)) {
+        return 'uid-ref';
+    }
+    return null;
+}
+function scanCallSites(frontendDir) {
+    const sites = [];
+    let scanned = 0;
+    const walk = (dir) => {
+        if (scanned >= MAX_FILES) {
+            return;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (scanned >= MAX_FILES) {
+                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;
+            const full = join(dir, entry.name);
+            let text;
+            try {
+                text = readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length; i += 1) {
+                const reason = classifyLine(lines[i]);
+                if (reason) {
+                    sites.push({
+                        file: relative(frontendDir, full),
+                        line: i + 1,
+                        reason,
+                        snippet: lines[i].trim().slice(0, 200),
+                    });
+                }
+            }
+        }
+    };
+    walk(frontendDir);
+    return sites;
+}
+function scanEnvKeys(frontendDir) {
+    const keys = new Set();
+    for (const name of ['.env', '.env.local', '.env.development', '.env.production']) {
+        const file = join(frontendDir, name);
+        if (!existsSync(file)) {
+            continue;
+        }
+        try {
+            for (const line of readFileSync(file, 'utf8').split('\n')) {
+                const match = ENV_KEY_RE.exec(line);
+                if (match) {
+                    keys.add(match[1]);
+                }
+            }
+        }
+        catch {
+            // unreadable — ignore
+        }
+    }
+    return [...keys];
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export function detectStrapiTouchpoints(frontendDir) {
+    const dependencies = Object.keys(readDeps(frontendDir)).filter((name) => /strapi/i.test(name));
+    const callSites = scanCallSites(frontendDir);
+    const envVars = scanEnvKeys(frontendDir);
+    return {
+        dependencies,
+        callSites,
+        envVars,
+        clean: dependencies.length === 0 && callSites.length === 0,
+    };
+}

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

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