fimo 0.9.0-experimental.1 → 0.9.0

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

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

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

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

@@ -1,90 +0,0 @@
-/**
- * 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/schema-map.d.ts

@@ -1,9 +0,0 @@
-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 (resolving components into editable blocks).
- */
-export declare function readStrapiSchemas(strapiAppDir: string): CmsCollectionSchema[];

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

@@ -1,277 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Strapi content-type schema → Fimo schema mapping. Strapi keeps every content
- * type as `apps/strapi/src/api/<api>/content-types/<ct>/schema.json` and every
- * component as `apps/strapi/src/components/<category>/<name>.json` — local,
- * declarative sources of truth — so the Fimo schemas can be derived without ever
- * contacting the CMS. All Strapi specifics live here (and in `detect.ts`).
- *
- * Structural content maps to Fimo **blocks** (Studio-editable ordered content):
- * a dynamic zone → a `oneOf` union of one variant per allowed component; a
- * single or repeatable component → a fixed `{ fields }` block. Each dynamic-zone
- * variant carries the original Strapi component id as a hidden, defaulted
- * `__component` field, so the served block is losslessly reversible to the
- * frontend's `block.__component` shape without a runtime lookup.
- */
-// Mirrors MAX_BLOCK_VARIANTS in @fimo/api-contracts — a `oneOf` beyond this
-// fails schema validation, so we cap and report rather than push an invalid set.
-const MAX_BLOCK_VARIANTS = 40;
-// Bound recursion into nested components; beyond this a nested component falls
-// back to `json` (still round-trips, just not granularly editable that deep).
-const MAX_COMPONENT_DEPTH = 5;
-// Field-name + type-name contracts from @fimo/api-contracts (content-fields.ts).
-const FIELD_NAME_PATTERN = /^[A-Za-z_]\w*$/;
-const RESERVED_BLOCK_FIELD_NAMES = new Set(['_key', '_type']);
-const COMPONENT_DISCRIMINATOR = '__component';
-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());
-}
-/** Strapi component uid (`sections.hero`) → a valid Fimo block variant uid
- *  (`SectionsHero`, matching `CONTENT_TYPE_NAME_PATTERN` /^[A-Za-z]\w*$/). */
-function variantUid(componentUid) {
-    const pascal = pascalCase(componentUid);
-    return /^[A-Za-z]/.test(pascal) ? pascal : `Block${pascal}`;
-}
-/**
- * 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; components and dynamic zones become blocks; relations to
- * non-imported targets (users, plugins) fall back to `json`.
- */
-function mapAttribute(field, attr, ctx) {
-    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 'component':
-            return mapComponentAttribute(attr, ctx);
-        case 'dynamiczone':
-            return mapDynamicZone(attr, ctx);
-        case 'json':
-            return { type: 'json' };
-        case 'relation': {
-            const targetName = attr.target ? ctx.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' };
-    }
-}
-/** Recursively map a component's attributes to a Fimo block-fields record.
- *  Returns null on a missing component, a cycle, or past the depth cap. */
-function componentFields(componentUid, ctx) {
-    if (!componentUid || ctx.depth > MAX_COMPONENT_DEPTH || ctx.visiting.has(componentUid)) {
-        return null;
-    }
-    const component = ctx.components.get(componentUid);
-    if (!component) {
-        return null;
-    }
-    const childCtx = {
-        ...ctx,
-        depth: ctx.depth + 1,
-        visiting: new Set(ctx.visiting).add(componentUid),
-    };
-    const fields = {};
-    for (const [name, attr] of Object.entries(component.attributes ?? {})) {
-        if (!FIELD_NAME_PATTERN.test(name) || RESERVED_BLOCK_FIELD_NAMES.has(name) || name === COMPONENT_DISCRIMINATOR) {
-            continue;
-        }
-        const mapped = mapAttribute(name, attr, childCtx);
-        if (mapped) {
-            fields[name] = mapped;
-        }
-    }
-    return fields;
-}
-/** A single/repeatable Strapi component → a fixed `{ fields }` blocks field.
- *  Single (non-repeatable) is capped to one item; repeatable is unbounded. A
- *  component that can't resolve (missing/cyclic/too deep) falls back to json. */
-function mapComponentAttribute(attr, ctx) {
-    const fields = componentFields(attr.component, ctx);
-    if (!fields) {
-        return { type: 'json' };
-    }
-    const schema = { fields };
-    return attr.repeatable ? { type: 'blocks', schema } : { type: 'blocks', schema, max: 1 };
-}
-/** A Strapi dynamic zone → a `oneOf` blocks field, one variant per allowed
- *  component. Each variant bakes a hidden, defaulted `__component` so the stored
- *  block reverses losslessly to the frontend's `block.__component` shape. */
-function mapDynamicZone(attr, ctx) {
-    const componentUids = attr.components ?? [];
-    if (componentUids.length > MAX_BLOCK_VARIANTS) {
-        console.warn(`[migration] dynamic zone has ${componentUids.length} components; Fimo blocks allow at most ` +
-            `${MAX_BLOCK_VARIANTS} variants — mapping the first ${MAX_BLOCK_VARIANTS}, dropping ` +
-            `${componentUids.length - MAX_BLOCK_VARIANTS}.`);
-    }
-    const seenUids = new Set();
-    const variants = [];
-    for (const componentUid of componentUids.slice(0, MAX_BLOCK_VARIANTS)) {
-        const fields = componentFields(componentUid, ctx);
-        if (!fields) {
-            continue;
-        }
-        // Dedupe pascalCase collisions (`a.hero` + `a_hero` → `AHero`); the baked
-        // `__component` still carries each variant's true source id.
-        let uid = variantUid(componentUid);
-        for (let n = 2; seenUids.has(uid); n += 1) {
-            uid = `${variantUid(componentUid)}${n}`;
-        }
-        seenUids.add(uid);
-        const component = ctx.components.get(componentUid);
-        variants.push({
-            uid,
-            label: component?.info?.displayName ?? uid,
-            fields: {
-                [COMPONENT_DISCRIMINATOR]: { type: 'string', default: componentUid, editable: false },
-                ...fields,
-            },
-        });
-    }
-    if (variants.length === 0) {
-        return { type: 'json' };
-    }
-    return { type: 'blocks', schema: { oneOf: variants } };
-}
-function mapSchema(raw, uidToName, components) {
-    const info = raw.schema.info ?? {};
-    const name = uidToName.get(raw.uid);
-    const fields = {};
-    const ctx = { uidToName, components, visiting: new Set(), depth: 0 };
-    for (const [field, attr] of Object.entries(raw.schema.attributes ?? {})) {
-        const mapped = mapAttribute(field, attr, ctx);
-        if (mapped) {
-            fields[field] = mapped;
-        }
-    }
-    return {
-        name,
-        label: info.displayName || name,
-        isSingleton: raw.schema.kind === 'singleType',
-        localized: raw.schema.pluginOptions?.i18n?.localized === true,
-        fields,
-        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;
-}
-/** Walk `<strapiAppDir>/src/components/<category>/<name>.json` into a uid→schema
- *  map. Strapi component uids are `<category>.<name>` (the dir + filename). */
-function collectComponents(strapiAppDir) {
-    const components = new Map();
-    const componentsDir = join(strapiAppDir, 'src', 'components');
-    if (!existsSync(componentsDir)) {
-        return components;
-    }
-    for (const categoryEntry of readdirSync(componentsDir, { withFileTypes: true })) {
-        if (!categoryEntry.isDirectory()) {
-            continue;
-        }
-        const categoryDir = join(componentsDir, categoryEntry.name);
-        for (const fileEntry of readdirSync(categoryDir, { withFileTypes: true })) {
-            if (!fileEntry.isFile() || !fileEntry.name.endsWith('.json')) {
-                continue;
-            }
-            const uid = `${categoryEntry.name}.${fileEntry.name.slice(0, -'.json'.length)}`;
-            try {
-                const parsed = JSON.parse(readFileSync(join(categoryDir, fileEntry.name), 'utf8'));
-                components.set(uid, { ...parsed, uid });
-            }
-            catch {
-                // Malformed component json — skip, never abort the whole import.
-            }
-        }
-    }
-    return components;
-}
-/**
- * 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 (resolving components into editable blocks).
- */
-export function readStrapiSchemas(strapiAppDir) {
-    const raws = collectRawSchemas(strapiAppDir);
-    const components = collectComponents(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, components)).sort((a, b) => a.name.localeCompare(b.name));
-}

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

@@ -1,23 +0,0 @@
-import type { CmsCollectionSchema } from '../types.js';
-/**
- * Field-shape manifest for the `fimo/strapi` reshape. A Fimo blocks value is
- * always an array, but a Strapi single component reads as an object — so the
- * reshape needs to know, per structural field, whether to unwrap the one-item
- * array (`single`) or keep it (`list`), plus the nested shapes inside. Leaf
- * fields (scalars, media, richtext, references) are omitted — the runtime
- * reshapes those by value-inspection. Derived from the Strapi source at scaffold
- * time and baked into the generated module, so nothing is inferred at runtime.
- *
- * This mirrors `BlockFieldShape` in `runtime/strapi/reshape.ts` (the composite
- * boundary forbids sharing the type across `scripts`/`runtime`); the
- * `shapes.test.ts` round-trip guards their agreement.
- */
-export interface BlockFieldShape {
-    kind: 'single' | 'list';
-    fields?: FieldShapes;
-    variants?: Record<string, FieldShapes>;
-}
-export type FieldShapes = Record<string, BlockFieldShape>;
-/** Per-type structural manifest, keyed by Fimo type name. Types with no blocks
- *  fields are omitted (the reshape falls back to pure value-inspection). */
-export declare function computeFieldShapes(schemas: CmsCollectionSchema[]): Record<string, FieldShapes>;

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

@@ -1,38 +0,0 @@
-function shapesFrom(fields) {
-    const shapes = {};
-    for (const [name, def] of Object.entries(fields)) {
-        if (def.type !== 'blocks') {
-            continue; // leaves are value-inspected by the runtime reshape
-        }
-        if ('oneOf' in def.schema) {
-            const variants = {};
-            for (const variant of def.schema.oneOf) {
-                const nested = shapesFrom(variant.fields);
-                if (Object.keys(nested).length > 0) {
-                    variants[variant.uid] = nested;
-                }
-            }
-            shapes[name] = { kind: 'list', ...(Object.keys(variants).length > 0 ? { variants } : {}) };
-        }
-        else {
-            const nested = shapesFrom(def.schema.fields);
-            shapes[name] = {
-                kind: def.max === 1 ? 'single' : 'list',
-                ...(Object.keys(nested).length > 0 ? { fields: nested } : {}),
-            };
-        }
-    }
-    return shapes;
-}
-/** Per-type structural manifest, keyed by Fimo type name. Types with no blocks
- *  fields are omitted (the reshape falls back to pure value-inspection). */
-export function computeFieldShapes(schemas) {
-    const byType = {};
-    for (const schema of schemas) {
-        const shapes = shapesFrom(schema.fields);
-        if (Object.keys(shapes).length > 0) {
-            byType[schema.name] = shapes;
-        }
-    }
-    return byType;
-}

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

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

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