@wp-typia/project-tools 0.24.4 → 0.24.5

package/dist/runtime/add/cli-add-workspace-ai-source-emitters.js

@@ -0,0 +1,302 @@
+import { quoteTsString } from "./cli-add-shared.js";
+import { buildAiFeatureEndpointManifest } from "./ai-feature-artifacts.js";
+import { OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, createScaffoldCompatibilityConfig, renderScaffoldCompatibilityConfig, resolveScaffoldCompatibilityPolicy, } from "../templates/scaffold-compatibility.js";
+import { formatResolveRestNonceSource, indentMultiline, } from "./cli-add-workspace-rest-source-utils.js";
+import { toPascalCase, toTitleCase } from "../shared/string-case.js";
+export { buildAiFeatureSyncScriptSource, } from "./cli-add-workspace-ai-sync-script-source.js";
+/**
+ * Build the workspace inventory entry written into `scripts/block-config.ts` for one AI feature.
+ */
+export function buildAiFeatureConfigEntry(aiFeatureSlug, namespace) {
+    const pascalCase = toPascalCase(aiFeatureSlug);
+    const title = toTitleCase(aiFeatureSlug);
+    const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+    const manifest = buildAiFeatureEndpointManifest({
+        namespace,
+        pascalCase,
+        slugKebabCase: aiFeatureSlug,
+        title,
+    });
+    return [
+        "\t{",
+        `\t\taiSchemaFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`)},`,
+        `\t\tapiFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api.ts`)},`,
+        `\t\tclientFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-client.ts`)},`,
+        `\t\tcompatibility: ${renderScaffoldCompatibilityConfig(compatibilityPolicy)},`,
+        `\t\tdataFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/data.ts`)},`,
+        `\t\tnamespace: ${quoteTsString(namespace)},`,
+        `\t\topenApiFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api.openapi.json`)},`,
+        `\t\tphpFile: ${quoteTsString(`inc/ai-features/${aiFeatureSlug}.php`)},`,
+        "\t\trestManifest: defineEndpointManifest(",
+        indentMultiline(JSON.stringify(manifest, null, "\t"), "\t\t\t"),
+        "\t\t),",
+        `\t\tslug: ${quoteTsString(aiFeatureSlug)},`,
+        `\t\ttypesFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-types.ts`)},`,
+        `\t\tvalidatorsFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-validators.ts`)},`,
+        "\t},",
+    ].join("\n");
+}
+/**
+ * Generate TypeScript request, response, and telemetry contracts for an AI feature scaffold.
+ */
+export function buildAiFeatureTypesSource(aiFeatureSlug) {
+    const pascalCase = toPascalCase(aiFeatureSlug);
+    return `import { tags } from 'typia';
+
+export interface ${pascalCase}AiFeatureRequest {
+\tbrief: string & tags.MinLength< 1 > & tags.MaxLength< 4000 >;
+\tcontext?: string & tags.MaxLength< 4000 >;
+}
+
+export interface ${pascalCase}AiFeatureResult {
+\ttitle: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tsummary: string & tags.MinLength< 1 > & tags.MaxLength< 2000 >;
+\tconfidence?: number & tags.Minimum< 0 > & tags.Maximum< 1 >;
+}
+
+export interface ${pascalCase}AiFeatureTokenUsage {
+\tcompletionTokens: number & tags.Type< 'uint32' >;
+\tpromptTokens: number & tags.Type< 'uint32' >;
+\ttotalTokens: number & tags.Type< 'uint32' >;
+\tthoughtTokens?: number & tags.Type< 'uint32' >;
+}
+
+export interface ${pascalCase}AiFeatureTelemetry {
+\tmodelId: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tmodelName: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tproviderId: string & tags.MinLength< 1 > & tags.MaxLength< 80 >;
+\tproviderName: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tproviderType: 'client' | 'cloud' | 'server';
+\tresultId: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\ttokenUsage: ${pascalCase}AiFeatureTokenUsage;
+}
+
+export interface ${pascalCase}AiFeatureResponse {
+\tresult: ${pascalCase}AiFeatureResult;
+\ttelemetry: ${pascalCase}AiFeatureTelemetry;
+}
+
+export type ${pascalCase}AiFeatureSupportProbeMode = 'request-time';
+
+export type ${pascalCase}AiFeatureUnavailableErrorCode =
+\t'ai_client_unavailable';
+
+export type ${pascalCase}AiFeatureUnavailableReasonCode =
+\t| 'missing-wordpress-ai-client'
+\t| 'request-time-support-probe';
+
+export interface ${pascalCase}AiFeatureSupportReason {
+\tcode: ${pascalCase}AiFeatureUnavailableReasonCode;
+\tlabel: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tmessage: string & tags.MinLength< 1 > & tags.MaxLength< 4000 >;
+}
+
+export interface ${pascalCase}AiFeatureSupportMetadata {
+\tfeatureLabel: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tfeatureSlug: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+\tcompatibility: {
+\t\thardMinimums: {
+\t\t\tphp?: string;
+\t\t\twordpress?: string;
+\t\t};
+\t\tmode: 'baseline' | 'optional' | 'required';
+\t\toptionalFeatureIds: string[];
+\t\toptionalFeatures: string[];
+\t\trequiredFeatureIds: string[];
+\t\trequiredFeatures: string[];
+\t\truntimeGates: string[];
+\t};
+\tsupportProbe: {
+\t\tendpointMethod: 'POST';
+\t\tendpointPath: string & tags.MinLength< 1 > & tags.MaxLength< 200 >;
+\t\tmode: ${pascalCase}AiFeatureSupportProbeMode;
+\t\tunavailableErrorCode: ${pascalCase}AiFeatureUnavailableErrorCode;
+\t};
+\tunavailableReasons: ${pascalCase}AiFeatureSupportReason[];
+}
+`;
+}
+/**
+ * Generate runtime validators for the AI feature request/result/response contracts.
+ */
+export function buildAiFeatureValidatorsSource(aiFeatureSlug) {
+    const pascalCase = toPascalCase(aiFeatureSlug);
+    return `import typia from 'typia';
+
+import { toValidationResult } from '@wp-typia/rest';
+import type {
+\t${pascalCase}AiFeatureRequest,
+\t${pascalCase}AiFeatureResponse,
+\t${pascalCase}AiFeatureResult,
+} from './api-types';
+
+const validateFeatureRequest = typia.createValidate< ${pascalCase}AiFeatureRequest >();
+const validateFeatureResult = typia.createValidate< ${pascalCase}AiFeatureResult >();
+const validateFeatureResponse = typia.createValidate< ${pascalCase}AiFeatureResponse >();
+
+export const apiValidators = {
+\tfeatureRequest: ( input: unknown ) =>
+\t\ttoValidationResult< ${pascalCase}AiFeatureRequest >(
+\t\t\tvalidateFeatureRequest( input )
+\t\t),
+\tfeatureResult: ( input: unknown ) =>
+\t\ttoValidationResult< ${pascalCase}AiFeatureResult >(
+\t\t\tvalidateFeatureResult( input )
+\t\t),
+\tfeatureResponse: ( input: unknown ) =>
+\t\ttoValidationResult< ${pascalCase}AiFeatureResponse >(
+\t\t\tvalidateFeatureResponse( input )
+\t\t),
+};
+`;
+}
+/**
+ * Generate the typed client wrapper that calls the scaffolded AI feature endpoint.
+ */
+export function buildAiFeatureApiSource(aiFeatureSlug) {
+    const pascalCase = toPascalCase(aiFeatureSlug);
+    const compatibility = createScaffoldCompatibilityConfig(resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY));
+    const title = toTitleCase(aiFeatureSlug);
+    return `import {
+\tcallEndpoint,
+\tresolveRestRouteUrl,
+} from '@wp-typia/rest';
+
+import type {
+\t${pascalCase}AiFeatureRequest,
+\t${pascalCase}AiFeatureSupportMetadata,
+} from './api-types';
+import {
+\trun${pascalCase}AiFeatureEndpoint,
+} from './api-client';
+
+${formatResolveRestNonceSource("spaced")}
+
+function isPlainObject( value: unknown ): value is Record< string, unknown > {
+\treturn (
+\t\t!! value &&
+\t\ttypeof value === 'object' &&
+\t\t! Array.isArray( value )
+\t);
+}
+
+export const aiFeatureRunEndpoint = {
+\t...run${pascalCase}AiFeatureEndpoint,
+\tbuildRequestOptions: () => {
+\t\tconst nonce = resolveRestNonce();
+\t\treturn {
+\t\t\theaders: nonce
+\t\t\t\t? {
+\t\t\t\t\t'X-WP-Nonce': nonce,
+\t\t\t\t}
+\t\t\t\t: undefined,
+\t\t\turl: resolveRestRouteUrl( run${pascalCase}AiFeatureEndpoint.path ),
+\t\t};
+\t},
+};
+
+export const aiFeatureSupportMetadata = {
+\tcompatibility: ${JSON.stringify(compatibility, null, "\t")},
+\tfeatureLabel: ${quoteTsString(title)},
+\tfeatureSlug: ${quoteTsString(aiFeatureSlug)},
+\tsupportProbe: {
+\t\tendpointMethod: 'POST',
+\t\tendpointPath: aiFeatureRunEndpoint.path,
+\t\tmode: 'request-time',
+\t\tunavailableErrorCode: 'ai_client_unavailable',
+\t},
+\tunavailableReasons: [
+\t\t{
+\t\t\tcode: 'missing-wordpress-ai-client',
+\t\t\tlabel: 'WordPress AI Client unavailable',
+\t\t\tmessage:
+\t\t\t\t'This AI feature stays disabled until the WordPress AI Client is available on the site.',
+\t\t},
+\t\t{
+\t\t\tcode: 'request-time-support-probe',
+\t\t\tlabel: 'Support is checked at request time',
+\t\t\tmessage:
+\t\t\t\t'Support is verified when the feature runs, so editor and admin UIs should degrade gracefully when the site rejects the request.',
+\t\t},
+\t],
+} satisfies ${pascalCase}AiFeatureSupportMetadata;
+
+export function getAiFeatureSupportHintLines() {
+\treturn aiFeatureSupportMetadata.unavailableReasons.map(
+\t\t( reason ) => reason.message
+\t);
+}
+
+export function isAiFeatureSupportUnavailableError( error: unknown ) {
+\tif ( ! isPlainObject( error ) ) {
+\t\treturn false;
+\t}
+
+\tconst data = isPlainObject( error.data ) ? error.data : undefined;
+\treturn (
+\t\terror.code === aiFeatureSupportMetadata.supportProbe.unavailableErrorCode ||
+\t\tdata?.status === 501
+\t);
+}
+
+export function resolveAiFeatureUnavailableMessage( error: unknown ) {
+\tif (
+\t\tisPlainObject( error ) &&
+\t\ttypeof error.message === 'string' &&
+\t\terror.message.length > 0
+\t) {
+\t\treturn error.message;
+\t}
+
+\treturn aiFeatureSupportMetadata.unavailableReasons[ 0 ]?.message ??
+\t\t'This AI feature is currently unavailable.';
+}
+
+export function runAiFeature( request: ${pascalCase}AiFeatureRequest ) {
+\treturn callEndpoint( aiFeatureRunEndpoint, request );
+}
+`;
+}
+/**
+ * Generate React endpoint-mutation hooks for the scaffolded AI feature client wrapper.
+ */
+export function buildAiFeatureDataSource(aiFeatureSlug) {
+    const pascalCase = toPascalCase(aiFeatureSlug);
+    return `import {
+\tuseEndpointMutation,
+\ttype UseEndpointMutationOptions,
+} from '@wp-typia/rest/react';
+
+import type {
+\t${pascalCase}AiFeatureRequest,
+\t${pascalCase}AiFeatureResponse,
+} from './api-types';
+import {
+\taiFeatureRunEndpoint,
+\taiFeatureSupportMetadata,
+\tgetAiFeatureSupportHintLines,
+\tisAiFeatureSupportUnavailableError,
+\tresolveAiFeatureUnavailableMessage,
+} from './api';
+
+export type UseRun${pascalCase}AiFeatureMutationOptions =
+\tUseEndpointMutationOptions<
+\t\t${pascalCase}AiFeatureRequest,
+\t\t${pascalCase}AiFeatureResponse,
+\t\tunknown
+\t>;
+
+export function useRun${pascalCase}AiFeatureMutation(
+\toptions: UseRun${pascalCase}AiFeatureMutationOptions = {}
+) {
+\treturn useEndpointMutation( aiFeatureRunEndpoint, options );
+}
+
+export {
+\taiFeatureSupportMetadata,
+\tgetAiFeatureSupportHintLines,
+\tisAiFeatureSupportUnavailableError,
+\tresolveAiFeatureUnavailableMessage,
+};
+`;
+}

package/dist/runtime/add/cli-add-workspace-ai-sync-rest-anchors.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Patch `scripts/sync-rest-contracts.ts` after sync-project wiring so AI feature REST artifacts join the split sync flow.
+ */
+export declare function ensureAiFeatureSyncRestAnchors(workspace: WorkspaceProject): Promise<void>;

package/dist/runtime/add/cli-add-workspace-ai-sync-rest-anchors.js

@@ -0,0 +1,236 @@
+import path from "node:path";
+import { patchFile } from "./cli-add-shared.js";
+function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
+    if (!nextSource.includes(target) && !hasAnchor) {
+        throw new Error([
+            `ensureAiFeatureSyncRestAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+            `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
+            "Restore the generated template or add the AI feature wiring manually before retrying.",
+        ].join(" "));
+    }
+}
+function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement, anchorDescription, syncRestScriptPath) {
+    if (nextSource.includes(target)) {
+        return nextSource;
+    }
+    const hasAnchor = typeof anchor === "string" ? nextSource.includes(anchor) : anchor.test(nextSource);
+    assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath);
+    return nextSource.replace(anchor, replacement);
+}
+function replaceBlockConfigImportForAiFeatures(nextSource, syncRestScriptPath) {
+    const importPatterns = [
+        /^import\s*\{\n(?:\t[^\n]*\n)+\} from ["']\.\/block-config["'];?$/mu,
+        /^import\s*\{[^\n]*\}\s*from\s*["']\.\/block-config["'];?$/mu,
+    ];
+    const importMatch = importPatterns.map((pattern) => pattern.exec(nextSource)).find(Boolean) ??
+        null;
+    if (!importMatch) {
+        throw new Error([
+            `ensureAiFeatureSyncRestAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+            "Missing expected workspace inventory import anchor in scripts/sync-rest-contracts.ts.",
+            "Restore the generated template or add the AI feature wiring manually before retrying.",
+        ].join(" "));
+    }
+    const importSource = importMatch[0];
+    if (importSource.includes("AI_FEATURES") &&
+        importSource.includes("WorkspaceAiFeatureConfig")) {
+        return nextSource;
+    }
+    const hasContracts = importSource.includes("CONTRACTS");
+    const hasContractConfig = importSource.includes("WorkspaceContractConfig");
+    const hasPostMeta = importSource.includes("POST_META");
+    const hasPostMetaConfig = importSource.includes("WorkspacePostMetaConfig");
+    const replacement = [
+        "import {",
+        "\tAI_FEATURES,",
+        "\tBLOCKS,",
+        ...(hasContracts ? ["\tCONTRACTS,"] : []),
+        ...(hasPostMeta ? ["\tPOST_META,"] : []),
+        "\tREST_RESOURCES,",
+        "\ttype WorkspaceAiFeatureConfig,",
+        "\ttype WorkspaceBlockConfig,",
+        ...(hasContractConfig ? ["\ttype WorkspaceContractConfig,"] : []),
+        ...(hasPostMetaConfig ? ["\ttype WorkspacePostMetaConfig,"] : []),
+        "\ttype WorkspaceRestResourceConfig,",
+        "} from './block-config';",
+    ].join("\n");
+    return nextSource.replace(importSource, replacement);
+}
+function replaceAiFeatureSyncSummaryCopy(nextSource, syncRestScriptPath) {
+    const standaloneSummary = "workspace blocks, standalone contracts, and plugin-level resources";
+    const standaloneAiSummary = "workspace blocks, standalone contracts, plugin-level resources, and AI features";
+    const standalonePostMetaSummary = "workspace blocks, standalone contracts, post meta contracts, and plugin-level resources";
+    const standalonePostMetaAiSummary = "workspace blocks, standalone contracts, post meta contracts, plugin-level resources, and AI features";
+    const postMetaSummary = "workspace blocks, post meta contracts, and plugin-level resources";
+    const postMetaAiSummary = "workspace blocks, post meta contracts, plugin-level resources, and AI features";
+    const restResourceSummary = "workspace blocks and plugin-level resources";
+    const restResourceAiSummary = "workspace blocks, plugin-level resources, and AI features";
+    if (nextSource.includes(standalonePostMetaSummary)) {
+        return nextSource
+            .split(standalonePostMetaSummary)
+            .join(standalonePostMetaAiSummary);
+    }
+    if (nextSource.includes(standaloneSummary)) {
+        return nextSource.split(standaloneSummary).join(standaloneAiSummary);
+    }
+    if (nextSource.includes(postMetaSummary)) {
+        return nextSource.split(postMetaSummary).join(postMetaAiSummary);
+    }
+    if (nextSource.includes(restResourceSummary)) {
+        return nextSource.split(restResourceSummary).join(restResourceAiSummary);
+    }
+    if (nextSource.includes(standaloneAiSummary) ||
+        nextSource.includes(standalonePostMetaAiSummary) ||
+        nextSource.includes(postMetaAiSummary) ||
+        nextSource.includes(restResourceAiSummary)) {
+        return nextSource;
+    }
+    throw new Error([
+        `ensureAiFeatureSyncRestAnchors could not patch ${path.basename(syncRestScriptPath)}.`,
+        "Missing expected sync summary copy anchor in scripts/sync-rest-contracts.ts.",
+        "Restore the generated template or add the AI feature wiring manually before retrying.",
+    ].join(" "));
+}
+function formatNoResourcesSubject(subjects) {
+    if (subjects.length <= 2) {
+        return subjects.join(" or ");
+    }
+    const lastSubject = subjects[subjects.length - 1];
+    return `${subjects.slice(0, -1).join(", ")}, or ${lastSubject}`;
+}
+function buildAiFeatureNoResourcesGuard({ hasPostMeta, hasStandaloneContracts, }) {
+    const condition = ["restBlocks.length === 0"];
+    if (hasStandaloneContracts) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("standaloneContracts.length === 0");
+    }
+    if (hasPostMeta) {
+        condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+        condition.push("postMetaContracts.length === 0");
+    }
+    condition[condition.length - 1] = `${condition[condition.length - 1]} &&`;
+    condition.push("restResources.length === 0 &&");
+    condition.push("aiFeatures.length === 0");
+    const noResourcesSubject = formatNoResourcesSubject([
+        "REST-enabled workspace blocks",
+        ...(hasStandaloneContracts ? ["standalone contracts"] : []),
+        ...(hasPostMeta ? ["post meta contracts"] : []),
+        "plugin-level REST resources",
+        "AI features",
+    ]);
+    return [
+        "if (",
+        ...condition.map((line) => `\t\t${line}`),
+        "\t) {",
+        "\t\tconsole.log(",
+        "\t\t\toptions.check",
+        `\t\t\t\t? 'ℹ️ No ${noResourcesSubject} are registered yet. \`sync-rest --check\` is already clean.'`,
+        `\t\t\t\t: 'ℹ️ No ${noResourcesSubject} are registered yet.'`,
+        "\t\t);",
+        "\t\treturn;",
+        "\t}",
+    ].join("\n");
+}
+const NO_RESOURCES_GUARD_PATTERN = /if \(\s*restBlocks\.length === 0(?:\s*&&\s*standaloneContracts\.length === 0)?(?:\s*&&\s*postMetaContracts\.length === 0)?\s*&&\s*restResources\.length === 0(?:\s*&&\s*aiFeatures\.length === 0)?\s*\) \{[\s\S]*?\n\t\treturn;\n\t\}/u;
+/**
+ * Patch `scripts/sync-rest-contracts.ts` after sync-project wiring so AI feature REST artifacts join the split sync flow.
+ */
+export async function ensureAiFeatureSyncRestAnchors(workspace) {
+    const syncRestScriptPath = path.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+    await patchFile(syncRestScriptPath, (source) => {
+        let nextSource = replaceBlockConfigImportForAiFeatures(source, syncRestScriptPath);
+        const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
+        const restResourcesAnchor = "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );";
+        const consoleLogPattern = /\n\tconsole\.log\(\n\t\toptions\.check/u;
+        nextSource = replaceRequiredSyncRestSource(nextSource, "function isWorkspaceAiFeature(", helperInsertionAnchor, [
+            "function isWorkspaceAiFeature(",
+            "\tfeature: WorkspaceAiFeatureConfig",
+            "): feature is WorkspaceAiFeatureConfig & {",
+            "\taiSchemaFile: string;",
+            "\tclientFile: string;",
+            "\topenApiFile: string;",
+            "\trestManifest: NonNullable< WorkspaceAiFeatureConfig[ 'restManifest' ] >;",
+            "\ttypesFile: string;",
+            "\tvalidatorsFile: string;",
+            "} {",
+            "\treturn (",
+            "\t\ttypeof feature.aiSchemaFile === 'string' &&",
+            "\t\ttypeof feature.clientFile === 'string' &&",
+            "\t\ttypeof feature.openApiFile === 'string' &&",
+            "\t\ttypeof feature.typesFile === 'string' &&",
+            "\t\ttypeof feature.validatorsFile === 'string' &&",
+            "\t\ttypeof feature.restManifest === 'object' &&",
+            "\t\tfeature.restManifest !== null &&",
+            "\t\ttypeof feature.restManifest.contracts === 'object' &&",
+            "\t\tfeature.restManifest.contracts !== null",
+            "\t);",
+            "}",
+            "",
+            "async function assertTypeArtifactsCurrent",
+        ].join("\n"), "type artifact assertion helper", syncRestScriptPath);
+        nextSource = replaceRequiredSyncRestSource(nextSource, "const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );", restResourcesAnchor, [
+            "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );",
+            "const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );",
+        ].join("\n"), "rest resource filter", syncRestScriptPath);
+        nextSource = replaceRequiredSyncRestSource(nextSource, "aiFeatures.length === 0", NO_RESOURCES_GUARD_PATTERN, buildAiFeatureNoResourcesGuard({
+            hasPostMeta: nextSource.includes("const postMetaContracts = POST_META.filter( isWorkspacePostMetaContract );"),
+            hasStandaloneContracts: nextSource.includes("const standaloneContracts = CONTRACTS.filter( isWorkspaceStandaloneContract );"),
+        }), "no-resources guard", syncRestScriptPath);
+        nextSource = replaceRequiredSyncRestSource(nextSource, "for ( const feature of aiFeatures ) {", consoleLogPattern, [
+            "",
+            "\tfor ( const feature of aiFeatures ) {",
+            "\t\tconst contracts = feature.restManifest.contracts;",
+            "",
+            "\t\tfor ( const [ baseName, contract ] of Object.entries( contracts ) ) {",
+            "\t\t\tawait syncTypeSchemas(",
+            "\t\t\t\t{",
+            "\t\t\t\t\tjsonSchemaFile: path.join(",
+            "\t\t\t\t\t\tpath.dirname( feature.typesFile ),",
+            "\t\t\t\t\t\t'api-schemas',",
+            "\t\t\t\t\t\t`${ baseName }.schema.json`",
+            "\t\t\t\t\t),",
+            "\t\t\t\t\topenApiFile: path.join(",
+            "\t\t\t\t\t\tpath.dirname( feature.typesFile ),",
+            "\t\t\t\t\t\t'api-schemas',",
+            "\t\t\t\t\t\t`${ baseName }.openapi.json`",
+            "\t\t\t\t\t),",
+            "\t\t\t\t\tsourceTypeName: contract.sourceTypeName,",
+            "\t\t\t\t\ttypesFile: feature.typesFile,",
+            "\t\t\t\t},",
+            "\t\t\t\t{",
+            "\t\t\t\t\tcheck: options.check,",
+            "\t\t\t\t}",
+            "\t\t\t);",
+            "\t\t}",
+            "",
+            "\t\tawait syncRestOpenApi(",
+            "\t\t\t{",
+            "\t\t\t\tmanifest: feature.restManifest,",
+            "\t\t\t\topenApiFile: feature.openApiFile,",
+            "\t\t\t\ttypesFile: feature.typesFile,",
+            "\t\t\t},",
+            "\t\t\t{",
+            "\t\t\t\tcheck: options.check,",
+            "\t\t\t}",
+            "\t\t);",
+            "",
+            "\t\tawait syncEndpointClient(",
+            "\t\t\t{",
+            "\t\t\t\tclientFile: feature.clientFile,",
+            "\t\t\t\tmanifest: feature.restManifest,",
+            "\t\t\t\ttypesFile: feature.typesFile,",
+            "\t\t\t\tvalidatorsFile: feature.validatorsFile,",
+            "\t\t\t},",
+            "\t\t\t{",
+            "\t\t\t\tcheck: options.check,",
+            "\t\t\t}",
+            "\t\t);",
+            "\t}",
+            "",
+            "\tconsole.log(",
+            "\t\toptions.check",
+        ].join("\n"), "final sync summary", syncRestScriptPath);
+        nextSource = replaceAiFeatureSyncSummaryCopy(nextSource, syncRestScriptPath);
+        return nextSource;
+    });
+}

package/dist/runtime/add/cli-add-workspace-ai-sync-script-source.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate the `scripts/sync-ai-features.ts` source that projects AI-safe schemas for workspace features.
+ */
+export declare function buildAiFeatureSyncScriptSource(): string;