@wp-typia/project-tools 0.19.3 → 0.20.1

package/dist/runtime/wordpress-ai.d.ts

@@ -0,0 +1,122 @@
+import type { EndpointManifestDefinition, EndpointManifestEndpointDefinition } from '@wp-typia/block-runtime/metadata-core';
+import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition, type JsonSchemaDocument } from './schema-core.js';
+import { type AbilitySpecCatalog } from './ability-spec.js';
+export type { AbilityAnnotationSpec, AbilityCategorySpec, AbilityMcpProjectionSpec, AbilityMetaSpec, AbilitySpec, AbilitySpecCatalog, } from './ability-spec.js';
+/**
+ * Represents one projected WordPress-native ability derived from an endpoint
+ * manifest plus an AbilitySpec definition.
+ */
+export interface ProjectedWordPressAbilityDefinition {
+    /** Normalized auth intent derived from the endpoint manifest. */
+    authIntent: EndpointAuthIntent;
+    /** Optional auth mode propagated from the manifest when present. */
+    authMode?: EndpointManifestEndpointDefinition['authMode'];
+    /** Shared category identifier resolved from the AbilitySpec catalog. */
+    category: string;
+    /** Human-readable summary shown to ability discovery consumers. */
+    description: string;
+    /** PHP callback that executes the ability. */
+    executeCallback: string;
+    /** Stable generated ability identifier. */
+    id: string;
+    /** Optional projected input schema, or null when no input exists. */
+    inputSchema: Record<string, unknown> | null;
+    /** Display label propagated from the AbilitySpec layer. */
+    label: string;
+    /** WordPress-owned metadata preserved in the projected document. */
+    meta: Record<string, unknown>;
+    /** HTTP method from the source endpoint manifest. */
+    method: EndpointManifestEndpointDefinition['method'];
+    /** Source operation identifier from the endpoint manifest. */
+    operationId: string;
+    /** Projected AI response schema shared by the document. */
+    outputSchema: Record<string, unknown>;
+    /** HTTP path from the source endpoint manifest. */
+    path: string;
+    /** PHP permission callback that gates the ability. */
+    permissionCallback: string;
+    /** Optional WordPress auth metadata preserved for downstream adapters. */
+    wordpressAuth?: EndpointWordPressAuthDefinition;
+}
+/**
+ * Bundles a single-category WordPress AI abilities document together with the
+ * metadata that describes how it was generated.
+ */
+export interface ProjectedWordPressAbilitiesDocument {
+    /** Ability definitions generated from the current manifest and AbilitySpec map. */
+    abilities: ProjectedWordPressAbilityDefinition[];
+    /** Shared category metadata for the generated document. */
+    category: {
+        id: string;
+        label: string;
+    };
+    /** Source metadata that points downstream consumers at the generated schema. */
+    generatedFrom: {
+        blockSlug: string;
+        responseSchemaPath: string;
+        schemaProfile: 'ai-structured-output';
+    };
+}
+/**
+ * Carries the projected input schema plus endpoint metadata into an optional
+ * transform hook.
+ */
+export interface WordPressAiInputSchemaTransformContext {
+    /** Name of the input contract being transformed. */
+    contractName: string;
+    /** Source endpoint that requested the input schema. */
+    endpoint: EndpointManifestEndpointDefinition;
+    /** Already-projected AI-friendly input schema. */
+    schema: JsonSchemaDocument & Record<string, unknown>;
+}
+interface BuildWordPressAbilitiesDocumentOptions {
+    abilityCatalog: AbilitySpecCatalog;
+    buildAbilityId?: (operationId: string) => string;
+    generatedFrom: ProjectedWordPressAbilitiesDocument['generatedFrom'];
+    loadInputSchema?: (endpoint: EndpointManifestEndpointDefinition, contractName: string) => Promise<JsonSchemaDocument & Record<string, unknown>>;
+    manifest: EndpointManifestDefinition;
+    outputSchema: Record<string, unknown>;
+    transformInputSchema?: (context: WordPressAiInputSchemaTransformContext) => JsonSchemaDocument & Record<string, unknown>;
+}
+interface BuildWordPressAiArtifactsOptions extends Omit<BuildWordPressAbilitiesDocumentOptions, 'outputSchema'> {
+    responseSchema: JsonSchemaDocument & Record<string, unknown>;
+}
+/**
+ * Projects a canonical schema into the AI structured-output profile used by
+ * WordPress AI artifact generation.
+ *
+ * @param schema Canonical JSON Schema document from the manifest-owned source.
+ * @returns The projected AI-friendly schema document.
+ */
+export declare function projectWordPressAiSchema(schema: JsonSchemaDocument & Record<string, unknown>): JsonSchemaDocument & Record<string, unknown>;
+/**
+ * Builds a WordPress abilities document from a manifest-first REST surface and
+ * a matching AbilitySpec catalog.
+ *
+ * Input schemas are loaded lazily per endpoint only when an input contract
+ * exists, and `transformInputSchema` runs after the schema has already been
+ * projected into the AI structured-output profile.
+ *
+ * @param options Manifest, ability catalog, and projected output schema inputs.
+ * @returns The generated WordPress abilities document.
+ * @throws When an endpoint is missing an AbilitySpec.
+ * @throws When categories are missing, inconsistent, or span multiple documents.
+ * @throws When an endpoint references a missing input contract or no loader was supplied.
+ */
+export declare function buildWordPressAbilitiesDocument({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, outputSchema, transformInputSchema, }: BuildWordPressAbilitiesDocumentOptions): Promise<ProjectedWordPressAbilitiesDocument>;
+/**
+ * Builds the projected AI response schema together with its companion
+ * WordPress abilities document.
+ *
+ * All endpoints must share the same response contract and category so the
+ * generated artifacts stay aligned with one manifest-owned response surface.
+ *
+ * @param options Manifest, ability catalog, and response schema inputs.
+ * @returns The projected AI response schema and generated abilities document.
+ * @throws When the manifest has no endpoints.
+ * @throws When the shared response contract is missing or inconsistent.
+ */
+export declare function buildWordPressAiArtifacts({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, responseSchema, transformInputSchema, }: BuildWordPressAiArtifactsOptions): Promise<{
+    abilitiesDocument: ProjectedWordPressAbilitiesDocument;
+    aiResponseSchema: Record<string, unknown>;
+}>;

package/dist/runtime/wordpress-ai.js

@@ -0,0 +1,177 @@
+import { normalizeEndpointAuthDefinition, projectJsonSchemaDocument, } from './schema-core.js';
+import { resolveAbilityCategorySpec, } from './ability-spec.js';
+function getEndpointInputContractName(endpoint) {
+    if (endpoint.method !== 'GET' &&
+        endpoint.bodyContract &&
+        endpoint.queryContract) {
+        throw new Error(`Endpoint "${endpoint.operationId}" defines both bodyContract and queryContract; WordPress AI input projection is ambiguous.`);
+    }
+    if (endpoint.method === 'GET') {
+        return endpoint.queryContract ?? null;
+    }
+    return endpoint.bodyContract ?? endpoint.queryContract ?? null;
+}
+function toAbilityId(categoryId, operationId) {
+    return `${categoryId}/${operationId
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase()}`;
+}
+/**
+ * Projects a canonical schema into the AI structured-output profile used by
+ * WordPress AI artifact generation.
+ *
+ * @param schema Canonical JSON Schema document from the manifest-owned source.
+ * @returns The projected AI-friendly schema document.
+ */
+export function projectWordPressAiSchema(schema) {
+    return projectJsonSchemaDocument(schema, {
+        profile: 'ai-structured-output',
+    });
+}
+function assertAbilityMetaKeys(abilitySpec, operationId) {
+    if (!abilitySpec.meta) {
+        return;
+    }
+    if ('annotations' in abilitySpec.meta) {
+        throw new Error(`Operation "${operationId}" cannot set AbilitySpec.meta.annotations directly; use AbilitySpec.annotations instead.`);
+    }
+    if ('show_in_rest' in abilitySpec.meta) {
+        throw new Error(`Operation "${operationId}" cannot set AbilitySpec.meta.show_in_rest directly; use AbilitySpec.showInRest instead.`);
+    }
+}
+/**
+ * Builds a WordPress abilities document from a manifest-first REST surface and
+ * a matching AbilitySpec catalog.
+ *
+ * Input schemas are loaded lazily per endpoint only when an input contract
+ * exists, and `transformInputSchema` runs after the schema has already been
+ * projected into the AI structured-output profile.
+ *
+ * @param options Manifest, ability catalog, and projected output schema inputs.
+ * @returns The generated WordPress abilities document.
+ * @throws When an endpoint is missing an AbilitySpec.
+ * @throws When categories are missing, inconsistent, or span multiple documents.
+ * @throws When an endpoint references a missing input contract or no loader was supplied.
+ */
+export async function buildWordPressAbilitiesDocument({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, outputSchema, transformInputSchema, }) {
+    const resolvedEndpoints = manifest.endpoints.map((endpoint) => {
+        const abilitySpec = abilityCatalog.abilities[endpoint.operationId];
+        if (!abilitySpec) {
+            throw new Error(`Missing AbilitySpec for operationId "${endpoint.operationId}".`);
+        }
+        assertAbilityMetaKeys(abilitySpec, endpoint.operationId);
+        return {
+            abilitySpec,
+            category: resolveAbilityCategorySpec(abilitySpec, abilityCatalog.categories, endpoint.operationId),
+            endpoint,
+        };
+    });
+    const documentCategory = resolvedEndpoints[0]?.category ?? null;
+    if (!documentCategory) {
+        throw new Error('WordPress AI projection requires at least one endpoint before it can resolve an AbilitySpec category.');
+    }
+    for (const resolvedEndpoint of resolvedEndpoints) {
+        if (resolvedEndpoint.category.id !== documentCategory.id) {
+            throw new Error(`Operation "${resolvedEndpoint.endpoint.operationId}" uses AbilitySpec category "${resolvedEndpoint.category.id}" but WordPress AI projections currently support one shared category per document.`);
+        }
+    }
+    const abilities = await Promise.all(resolvedEndpoints.map(async ({ abilitySpec, category, endpoint }) => {
+        const inputContractName = getEndpointInputContractName(endpoint);
+        let inputSchema = null;
+        if (inputContractName) {
+            if (!manifest.contracts[inputContractName]) {
+                throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${inputContractName}".`);
+            }
+            if (!loadInputSchema) {
+                throw new Error(`Missing input schema loader for operationId "${endpoint.operationId}".`);
+            }
+            const projectedInputSchema = projectWordPressAiSchema(await loadInputSchema(endpoint, inputContractName));
+            inputSchema = transformInputSchema
+                ? transformInputSchema({
+                    contractName: inputContractName,
+                    endpoint,
+                    schema: projectedInputSchema,
+                })
+                : projectedInputSchema;
+        }
+        const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
+        return {
+            authIntent: normalizedAuth.auth,
+            ...(normalizedAuth.authMode
+                ? { authMode: normalizedAuth.authMode }
+                : {}),
+            category: category.id,
+            description: endpoint.summary ?? abilitySpec.label,
+            executeCallback: abilitySpec.executeCallback,
+            id: (buildAbilityId ??
+                ((operationId) => toAbilityId(category.id, operationId)))(endpoint.operationId),
+            inputSchema,
+            label: abilitySpec.label,
+            meta: {
+                ...(abilitySpec.meta ?? {}),
+                ...(abilitySpec.annotations
+                    ? {
+                        annotations: abilitySpec.annotations,
+                    }
+                    : {}),
+                show_in_rest: abilitySpec.showInRest ?? true,
+            },
+            method: endpoint.method,
+            operationId: endpoint.operationId,
+            outputSchema,
+            path: endpoint.path,
+            permissionCallback: abilitySpec.permissionCallback,
+            ...(normalizedAuth.wordpressAuth
+                ? { wordpressAuth: normalizedAuth.wordpressAuth }
+                : {}),
+        };
+    }));
+    return {
+        abilities,
+        category: documentCategory,
+        generatedFrom,
+    };
+}
+/**
+ * Builds the projected AI response schema together with its companion
+ * WordPress abilities document.
+ *
+ * All endpoints must share the same response contract and category so the
+ * generated artifacts stay aligned with one manifest-owned response surface.
+ *
+ * @param options Manifest, ability catalog, and response schema inputs.
+ * @returns The projected AI response schema and generated abilities document.
+ * @throws When the manifest has no endpoints.
+ * @throws When the shared response contract is missing or inconsistent.
+ */
+export async function buildWordPressAiArtifacts({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, responseSchema, transformInputSchema, }) {
+    if (manifest.endpoints.length === 0) {
+        throw new Error('WordPress AI projection requires at least one endpoint in the manifest.');
+    }
+    const responseContractName = manifest.endpoints[0].responseContract;
+    if (!responseContractName) {
+        throw new Error('The manifest is missing its shared response contract.');
+    }
+    for (const endpoint of manifest.endpoints) {
+        if (endpoint.responseContract !== responseContractName) {
+            throw new Error(`Endpoint "${endpoint.operationId}" uses response contract "${endpoint.responseContract}" but expected shared response contract "${responseContractName}".`);
+        }
+    }
+    if (!manifest.contracts[responseContractName]) {
+        throw new Error(`The manifest references missing response contract "${responseContractName}".`);
+    }
+    const aiResponseSchema = projectWordPressAiSchema(responseSchema);
+    const abilitiesDocument = await buildWordPressAbilitiesDocument({
+        abilityCatalog,
+        buildAbilityId,
+        generatedFrom,
+        loadInputSchema,
+        manifest,
+        outputSchema: aiResponseSchema,
+        transformInputSchema,
+    });
+    return {
+        abilitiesDocument,
+        aiResponseSchema,
+    };
+}

package/dist/runtime/workspace-inventory.d.ts

@@ -38,6 +38,44 @@ export interface WorkspaceRestResourceInventoryEntry {
     typesFile: string;
     validatorsFile: string;
 }
+/**
+ * Ability entry parsed from `scripts/block-config.ts`.
+ *
+ * Each file path stays relative to the workspace root so doctor checks, schema
+ * sync scripts, and generated admin/editor helpers can resolve typed workflow
+ * artifacts without guessing their locations.
+ */
+export interface WorkspaceAbilityInventoryEntry {
+    clientFile: string;
+    configFile: string;
+    dataFile: string;
+    inputSchemaFile: string;
+    inputTypeName: string;
+    outputSchemaFile: string;
+    outputTypeName: string;
+    phpFile: string;
+    slug: string;
+    typesFile: string;
+}
+/**
+ * AI-feature entry parsed from `scripts/block-config.ts`.
+ *
+ * Each file path stays relative to the workspace root so doctor checks, add
+ * workflows, and split sync scripts can reason about the REST and AI-safe
+ * artifacts without guessing their locations.
+ */
+export interface WorkspaceAiFeatureInventoryEntry {
+    aiSchemaFile: string;
+    apiFile: string;
+    clientFile: string;
+    dataFile: string;
+    namespace: string;
+    openApiFile: string;
+    phpFile: string;
+    slug: string;
+    typesFile: string;
+    validatorsFile: string;
+}
 /**
  * Editor-plugin entry parsed from `scripts/block-config.ts`.
  *
@@ -54,7 +92,11 @@ export interface WorkspaceInventory {
     bindingSources: WorkspaceBindingSourceInventoryEntry[];
     blockConfigPath: string;
     blocks: WorkspaceBlockInventoryEntry[];
+    abilities: WorkspaceAbilityInventoryEntry[];
+    aiFeatures: WorkspaceAiFeatureInventoryEntry[];
+    hasAbilitiesSection: boolean;
     hasBindingSourcesSection: boolean;
+    hasAiFeaturesSection: boolean;
     hasEditorPluginsSection: boolean;
     hasPatternsSection: boolean;
     hasRestResourcesSection: boolean;
@@ -70,6 +112,8 @@ export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variatio
 export declare const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 export declare const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
 export declare const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+export declare const ABILITY_CONFIG_ENTRY_MARKER = "\t// wp-typia add ability entries";
+export declare const AI_FEATURE_CONFIG_ENTRY_MARKER = "\t// wp-typia add ai-feature entries";
 /**
  * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
  */
@@ -107,15 +151,18 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
 /**
  * Update `scripts/block-config.ts` source text with additional inventory entries.
  *
- * Missing `VARIATIONS` and `PATTERNS` sections are created automatically before
- * new entries are appended at their marker comments. When provided,
- * `transformSource` runs before any entries are inserted.
+ * Missing inventory sections for variations, patterns, binding sources, REST
+ * resources, workflow abilities, AI features, and editor plugins are created
+ * automatically before new entries are appended at their marker comments.
+ * When provided, `transformSource` runs before any entries are inserted.
  *
  * @param source Existing `scripts/block-config.ts` source.
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, abilityEntries, aiFeatureEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
+    abilityEntries?: string[];
+    aiFeatureEntries?: string[];
     blockEntries?: string[];
     bindingSourceEntries?: string[];
     editorPluginEntries?: string[];

package/dist/runtime/workspace-inventory.js

@@ -8,6 +8,8 @@ export const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entrie
 export const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 export const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
 export const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+export const ABILITY_CONFIG_ENTRY_MARKER = "\t// wp-typia add ability entries";
+export const AI_FEATURE_CONFIG_ENTRY_MARKER = "\t// wp-typia add ai-feature entries";
 /**
  * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
  */
@@ -77,6 +79,62 @@ export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
 \t// wp-typia add rest-resource entries
 ];
 `;
+const WORKSPACE_COMPATIBILITY_CONFIG_FIELD = `\tcompatibility?: {
+\t\thardMinimums: {
+\t\t\tphp?: string;
+\t\t\twordpress?: string;
+\t\t};
+\t\tmode: 'baseline' | 'optional' | 'required';
+\t\toptionalFeatures: string[];
+\t\trequiredFeatures: string[];
+\t\truntimeGates: string[];
+\t};
+`;
+const ABILITIES_INTERFACE_SECTION = `
+
+export interface WorkspaceAbilityConfig {
+\tclientFile: string;
+${WORKSPACE_COMPATIBILITY_CONFIG_FIELD}\tconfigFile: string;
+\tdataFile: string;
+\tinputSchemaFile: string;
+\tinputTypeName: string;
+\toutputSchemaFile: string;
+\toutputTypeName: string;
+\tphpFile: string;
+\tslug: string;
+\ttypesFile: string;
+}
+`;
+const ABILITIES_CONST_SECTION = `
+
+export const ABILITIES: WorkspaceAbilityConfig[] = [
+\t// wp-typia add ability entries
+];
+`;
+const AI_FEATURES_INTERFACE_SECTION = `
+
+export interface WorkspaceAiFeatureConfig {
+\taiSchemaFile: string;
+\tapiFile: string;
+\tclientFile: string;
+${WORKSPACE_COMPATIBILITY_CONFIG_FIELD}\tdataFile: string;
+\tnamespace: string;
+\topenApiFile: string;
+\tphpFile: string;
+\trestManifest?: ReturnType<
+\t\ttypeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+\t>;
+\tslug: string;
+\ttypesFile: string;
+\tvalidatorsFile: string;
+}
+`;
+const AI_FEATURES_CONST_SECTION = `
+
+export const AI_FEATURES: WorkspaceAiFeatureConfig[] = [
+\t// wp-typia add ai-feature entries
+];
+`;
 const EDITOR_PLUGINS_INTERFACE_SECTION = `
 
 export interface WorkspaceEditorPluginConfig {
@@ -243,6 +301,44 @@ function parseRestResourceEntries(arrayLiteral) {
         };
     });
 }
+function parseAiFeatureEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`AI_FEATURES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        return {
+            aiSchemaFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "aiSchemaFile"),
+            apiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "apiFile"),
+            clientFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "clientFile"),
+            dataFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "dataFile"),
+            namespace: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "namespace"),
+            openApiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "openApiFile"),
+            phpFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "phpFile"),
+            slug: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "slug"),
+            typesFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "typesFile"),
+            validatorsFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "validatorsFile"),
+        };
+    });
+}
+function parseAbilityEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`ABILITIES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        return {
+            clientFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "clientFile"),
+            configFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "configFile"),
+            dataFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "dataFile"),
+            inputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputSchemaFile"),
+            inputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputTypeName"),
+            outputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputSchemaFile"),
+            outputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputTypeName"),
+            phpFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "phpFile"),
+            slug: getRequiredStringProperty("ABILITIES", elementIndex, element, "slug"),
+            typesFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "typesFile"),
+        };
+    });
+}
 function parseEditorPluginEntries(arrayLiteral) {
     return arrayLiteral.elements.map((element, elementIndex) => {
         if (!ts.isObjectLiteralExpression(element)) {
@@ -272,6 +368,8 @@ export function parseWorkspaceInventorySource(source) {
     const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
     const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
     const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
+    const abilityArray = findExportedArrayLiteral(sourceFile, "ABILITIES");
+    const aiFeatureArray = findExportedArrayLiteral(sourceFile, "AI_FEATURES");
     const editorPluginArray = findExportedArrayLiteral(sourceFile, "EDITOR_PLUGINS");
     if (variationArray.found && !variationArray.array) {
         throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
@@ -285,14 +383,24 @@ export function parseWorkspaceInventorySource(source) {
     if (restResourceArray.found && !restResourceArray.array) {
         throw new Error("scripts/block-config.ts must export REST_RESOURCES as an array literal.");
     }
+    if (abilityArray.found && !abilityArray.array) {
+        throw new Error("scripts/block-config.ts must export ABILITIES as an array literal.");
+    }
+    if (aiFeatureArray.found && !aiFeatureArray.array) {
+        throw new Error("scripts/block-config.ts must export AI_FEATURES as an array literal.");
+    }
     if (editorPluginArray.found && !editorPluginArray.array) {
         throw new Error("scripts/block-config.ts must export EDITOR_PLUGINS as an array literal.");
     }
     return {
+        abilities: abilityArray.array ? parseAbilityEntries(abilityArray.array) : [],
+        aiFeatures: aiFeatureArray.array ? parseAiFeatureEntries(aiFeatureArray.array) : [],
         bindingSources: bindingSourceArray.array
             ? parseBindingSourceEntries(bindingSourceArray.array)
             : [],
         blocks: parseBlockEntries(blockArray.array),
+        hasAbilitiesSection: abilityArray.found,
+        hasAiFeaturesSection: aiFeatureArray.found,
         hasBindingSourcesSection: bindingSourceArray.found,
         hasEditorPluginsSection: editorPluginArray.found,
         hasPatternsSection: patternArray.found,
@@ -378,6 +486,18 @@ function ensureWorkspaceInventorySections(source) {
     if (!/export\s+const\s+REST_RESOURCES\b/u.test(nextSource)) {
         nextSource += REST_RESOURCES_CONST_SECTION;
     }
+    if (!/export\s+interface\s+WorkspaceAbilityConfig\b/u.test(nextSource)) {
+        nextSource += ABILITIES_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+ABILITIES\b/u.test(nextSource)) {
+        nextSource += ABILITIES_CONST_SECTION;
+    }
+    if (!/export\s+interface\s+WorkspaceAiFeatureConfig\b/u.test(nextSource)) {
+        nextSource += AI_FEATURES_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+AI_FEATURES\b/u.test(nextSource)) {
+        nextSource += AI_FEATURES_CONST_SECTION;
+    }
     if (!/export\s+interface\s+WorkspaceEditorPluginConfig\b/u.test(nextSource)) {
         nextSource += EDITOR_PLUGINS_INTERFACE_SECTION;
     }
@@ -395,18 +515,47 @@ function appendEntriesAtMarker(source, marker, entries) {
     }
     return source.replace(marker, `${entries.join("\n")}\n${marker}`);
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
+    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+    return source.replace(interfacePattern, (match, start, body, end) => {
+        if (new RegExp(`^[ \t]*${escapeRegex(fieldName)}\\??:`, "mu").test(body)) {
+            return match;
+        }
+        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
+        const formattedFieldSource = `${fieldSource
+            .replace(/\r?\n$/u, "")
+            .split("\n")
+            .join(lineEnding)}${lineEnding}`;
+        const memberPattern = /^[ \t]*([A-Za-z_$][\w$]*)\??:/gmu;
+        for (const member of body.matchAll(memberPattern)) {
+            const memberIndex = member.index;
+            const memberName = member[1];
+            if (memberIndex === undefined || !memberName) {
+                continue;
+            }
+            if (memberName.localeCompare(fieldName) > 0) {
+                return `${start}${body.slice(0, memberIndex)}${formattedFieldSource}${body.slice(memberIndex)}${end}`;
+            }
+        }
+        return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
+    });
+}
 /**
  * Update `scripts/block-config.ts` source text with additional inventory entries.
  *
- * Missing `VARIATIONS` and `PATTERNS` sections are created automatically before
- * new entries are appended at their marker comments. When provided,
- * `transformSource` runs before any entries are inserted.
+ * Missing inventory sections for variations, patterns, binding sources, REST
+ * resources, workflow abilities, AI features, and editor plugins are created
+ * automatically before new entries are appended at their marker comments.
+ * When provided, `transformSource` runs before any entries are inserted.
  *
  * @param source Existing `scripts/block-config.ts` source.
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], editorPluginEntries = [], patternEntries = [], restResourceEntries = [], variationEntries = [], transformSource, } = {}) {
+export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], abilityEntries = [], aiFeatureEntries = [], editorPluginEntries = [], patternEntries = [], restResourceEntries = [], variationEntries = [], transformSource, } = {}) {
     let nextSource = ensureWorkspaceInventorySections(source);
     if (transformSource) {
         nextSource = transformSource(nextSource);
@@ -416,6 +565,10 @@ export function updateWorkspaceInventorySource(source, { blockEntries = [], bind
     nextSource = appendEntriesAtMarker(nextSource, PATTERN_CONFIG_ENTRY_MARKER, patternEntries);
     nextSource = appendEntriesAtMarker(nextSource, BINDING_SOURCE_CONFIG_ENTRY_MARKER, bindingSourceEntries);
     nextSource = appendEntriesAtMarker(nextSource, REST_RESOURCE_CONFIG_ENTRY_MARKER, restResourceEntries);
+    nextSource = appendEntriesAtMarker(nextSource, ABILITY_CONFIG_ENTRY_MARKER, abilityEntries);
+    nextSource = appendEntriesAtMarker(nextSource, AI_FEATURE_CONFIG_ENTRY_MARKER, aiFeatureEntries);
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
     nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
     return nextSource;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -42,6 +42,16 @@
       "import": "./dist/runtime/cli-scaffold.js",
       "default": "./dist/runtime/cli-scaffold.js"
     },
+    "./ai-artifacts": {
+      "types": "./dist/runtime/ai-artifacts.d.ts",
+      "import": "./dist/runtime/ai-artifacts.js",
+      "default": "./dist/runtime/ai-artifacts.js"
+    },
+    "./typia-llm": {
+      "types": "./dist/runtime/typia-llm.d.ts",
+      "import": "./dist/runtime/typia-llm.js",
+      "default": "./dist/runtime/typia-llm.js"
+    },
     "./compound-inner-blocks": {
       "types": "./dist/runtime/compound-inner-blocks.d.ts",
       "import": "./dist/runtime/compound-inner-blocks.js",
@@ -95,7 +105,7 @@
     "prepack": "bun run build && node ./scripts/publish-manifest.mjs prepare",
     "postpack": "node ./scripts/publish-manifest.mjs restore",
     "test": "bun run build && bun test tests/*.test.ts",
-    "test:scaffold-core": "bun run build && bun test tests/block-generator-service.test.ts tests/built-in-block-artifacts.test.ts tests/scaffold-basic.test.ts tests/scaffold-persistence.test.ts tests/template-source.test.ts tests/init-command.test.ts tests/cli-entry.test.ts tests/cli-prompt.test.ts tests/import-policy.test.ts",
+    "test:scaffold-core": "bun run build && bun test tests/block-generator-service.test.ts tests/built-in-block-artifacts.test.ts tests/scaffold-basic.test.ts tests/scaffold-persistence.test.ts tests/template-source.test.ts tests/init-command.test.ts tests/cli-entry.test.ts tests/cli-prompt.test.ts tests/import-policy.test.ts tests/wordpress-ai-spec.test.ts tests/typia-llm.test.ts",
     "test:workspace": "bun run build && bun test tests/workspace-add.test.ts tests/workspace-doctor.test.ts",
     "test:compound": "bun run build && bun test tests/scaffold-compound.test.ts",
     "test:migration-planning": "bun run build && bun test tests/migration-init.test.ts tests/migration-config.test.ts tests/migration-plan-wizard.test.ts",

package/templates/_shared/base/{{slugKebabCase}}.php.mustache

@@ -3,9 +3,9 @@
  * Plugin Name:       {{title}}
  * Description:       {{description}}
  * Version:           0.1.0
- * Requires at least: 6.7
- * Tested up to:      6.9
- * Requires PHP:      8.0
+ * Requires at least: {{requiresAtLeast}}
+ * Tested up to:      {{testedUpTo}}
+ * Requires PHP:      {{requiresPhp}}
  * Author:            {{author}}
  * License:           GPL-2.0-or-later
  * License URI:       https://www.gnu.org/licenses/gpl-2.0.html