@wp-typia/project-tools 0.22.2 → 0.22.4

package/dist/runtime/cli-doctor-workspace-features.js

@@ -0,0 +1,383 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EDITOR_PLUGIN_SLOT_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, resolveEditorPluginSlotAlias, } from "./cli-add-shared.js";
+import { checkExistingFiles, createDoctorCheck, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { escapeRegex } from "./php-utils.js";
+function getWorkspaceRestResourceRequiredFiles(restResource) {
+    const schemaNames = new Set();
+    if (restResource.methods.includes("list")) {
+        schemaNames.add("list-query");
+        schemaNames.add("list-response");
+    }
+    if (restResource.methods.includes("read")) {
+        schemaNames.add("read-query");
+        schemaNames.add("read-response");
+    }
+    if (restResource.methods.includes("create")) {
+        schemaNames.add("create-request");
+        schemaNames.add("create-response");
+    }
+    if (restResource.methods.includes("update")) {
+        schemaNames.add("update-query");
+        schemaNames.add("update-request");
+        schemaNames.add("update-response");
+    }
+    if (restResource.methods.includes("delete")) {
+        schemaNames.add("delete-query");
+        schemaNames.add("delete-response");
+    }
+    return Array.from(new Set([
+        restResource.apiFile,
+        ...Array.from(schemaNames, (schemaName) => path.join(path.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+        restResource.clientFile,
+        restResource.dataFile,
+        restResource.openApiFile,
+        restResource.phpFile,
+        restResource.typesFile,
+        restResource.validatorsFile,
+    ]));
+}
+function checkWorkspaceRestResourceConfig(restResource) {
+    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(restResource.namespace);
+    const hasMethods = restResource.methods.length > 0 &&
+        restResource.methods.every((method) => REST_RESOURCE_METHOD_IDS.includes(method));
+    return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasMethods ? "pass" : "fail", hasNamespace && hasMethods
+        ? `REST resource namespace ${restResource.namespace} with methods ${restResource.methods.join(", ")}`
+        : "REST resource namespace or methods are invalid");
+}
+function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("REST resource bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const registerFunctionName = `${phpPrefix}_register_rest_resources`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const hasServerGlob = source.includes(WORKSPACE_REST_RESOURCE_GLOB);
+    const hasRegisterHook = source.includes(registerHook);
+    return createDoctorCheck("REST resource bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
+        ? "REST resource PHP loader hook is present"
+        : "Missing REST resource PHP require glob or init hook");
+}
+function getWorkspaceAbilityRequiredFiles(ability) {
+    return Array.from(new Set([
+        ability.clientFile,
+        ability.configFile,
+        ability.dataFile,
+        ability.inputSchemaFile,
+        ability.outputSchemaFile,
+        ability.phpFile,
+        ability.typesFile,
+    ]));
+}
+function checkWorkspaceAbilityConfig(projectDir, ability) {
+    const configPath = path.join(projectDir, ability.configFile);
+    if (!fs.existsSync(configPath)) {
+        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
+    }
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        const abilityId = typeof config.abilityId === "string" ? config.abilityId.trim() : "";
+        const categorySlug = typeof config.category?.slug === "string"
+            ? config.category.slug.trim()
+            : "";
+        const hasValidAbilityId = /^[a-z0-9-]+\/[a-z0-9-]+$/u.test(abilityId);
+        const hasValidCategorySlug = /^[a-z0-9-]+$/u.test(categorySlug);
+        return createDoctorCheck(`Ability config ${ability.slug}`, hasValidAbilityId && hasValidCategorySlug ? "pass" : "fail", hasValidAbilityId && hasValidCategorySlug
+            ? `Ability id ${abilityId} in category ${categorySlug} is valid`
+            : "Ability config must define a valid abilityId (`namespace/ability-name`) and category.slug.");
+    }
+    catch (error) {
+        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", error instanceof Error ? error.message : String(error));
+    }
+}
+function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Ability bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
+    const enqueueFunctionName = `${phpPrefix}_enqueue_workflow_abilities`;
+    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const adminEnqueueHook = `add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );`;
+    const editorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
+    const hasLoaderHook = source.includes(loadHook);
+    const hasAdminEnqueueHook = source.includes(adminEnqueueHook);
+    const hasEditorEnqueueHook = source.includes(editorEnqueueHook);
+    const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
+    const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
+    const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
+    const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
+    return createDoctorCheck("Ability bootstrap", hasLoaderHook &&
+        hasAdminEnqueueHook &&
+        hasEditorEnqueueHook &&
+        hasServerGlob &&
+        hasEditorScript &&
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
+        ? "pass"
+        : "fail", hasLoaderHook &&
+        hasAdminEnqueueHook &&
+        hasEditorEnqueueHook &&
+        hasServerGlob &&
+        hasEditorScript &&
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
+        ? "Ability loader and admin/editor script-module bootstrap hooks are present"
+        : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
+}
+function checkWorkspaceAbilityIndex(projectDir, abilities) {
+    const indexRelativePath = [
+        path.join("src", "abilities", "index.ts"),
+        path.join("src", "abilities", "index.js"),
+    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingExports = abilities.filter((ability) => {
+        const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex(ability.slug)}\\/client['"\`]`, "mu");
+        return !exportPattern.test(source);
+    });
+    return createDoctorCheck("Abilities index", missingExports.length === 0 ? "pass" : "fail", missingExports.length === 0
+        ? "Ability client helpers are aggregated"
+        : `Missing ability exports for: ${missingExports.map((entry) => entry.slug).join(", ")}`);
+}
+function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
+    return Array.from(new Set([
+        aiFeature.aiSchemaFile,
+        aiFeature.apiFile,
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+        aiFeature.clientFile,
+        aiFeature.dataFile,
+        aiFeature.openApiFile,
+        aiFeature.phpFile,
+        aiFeature.typesFile,
+        aiFeature.validatorsFile,
+    ]));
+}
+function checkWorkspaceAiFeatureConfig(aiFeature) {
+    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(aiFeature.namespace);
+    return createDoctorCheck(`AI feature config ${aiFeature.slug}`, hasNamespace ? "pass" : "fail", hasNamespace
+        ? `AI feature namespace ${aiFeature.namespace} is valid`
+        : "AI feature namespace is invalid");
+}
+function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("AI feature bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const registerFunctionName = `${phpPrefix}_register_ai_features`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const hasServerGlob = source.includes(WORKSPACE_AI_FEATURE_GLOB);
+    const hasRegisterHook = source.includes(registerHook);
+    return createDoctorCheck("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
+        ? "AI feature PHP loader hook is present"
+        : "Missing AI feature PHP require glob or init hook");
+}
+function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
+    const editorPluginDir = path.join("src", "editor-plugins", editorPlugin.slug);
+    const surfaceFile = editorPlugin.slot === "PluginSidebar"
+        ? path.join(editorPluginDir, "Sidebar.tsx")
+        : path.join(editorPluginDir, "Surface.tsx");
+    return Array.from(new Set([
+        editorPlugin.file,
+        surfaceFile,
+        path.join(editorPluginDir, "data.ts"),
+        path.join(editorPluginDir, "types.ts"),
+        path.join(editorPluginDir, "style.scss"),
+    ]));
+}
+function checkWorkspaceEditorPluginConfig(editorPlugin) {
+    const normalizedSlot = resolveEditorPluginSlotAlias(editorPlugin.slot);
+    const isValidSlot = Boolean(normalizedSlot);
+    return createDoctorCheck(`Editor plugin config ${editorPlugin.slug}`, isValidSlot ? "pass" : "fail", isValidSlot
+        ? `Editor plugin slot ${editorPlugin.slot} is supported as ${normalizedSlot}`
+        : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")} or legacy aliases PluginSidebar, PluginDocumentSettingPanel.`);
+}
+function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Editor plugin bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
+    const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
+    const hasEditorEnqueueHook = source.includes(enqueueHook);
+    const hasEditorScript = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT);
+    const hasEditorAsset = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET);
+    const hasEditorStyle = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE);
+    return createDoctorCheck("Editor plugin bootstrap", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle ? "pass" : "fail", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle
+        ? "Editor plugin enqueue hook is present"
+        : "Missing editor plugin enqueue hook or build/editor-plugins script/style asset references");
+}
+function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
+    const indexRelativePath = [
+        path.join("src", "editor-plugins", "index.ts"),
+        path.join("src", "editor-plugins", "index.js"),
+    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingImports = editorPlugins.filter((editorPlugin) => {
+        const importPattern = new RegExp(`['"\`]\\./${escapeRegex(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
+        return !importPattern.test(source);
+    });
+    return createDoctorCheck("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
+        ? "Editor plugin registrations are aggregated"
+        : `Missing editor plugin imports for: ${missingImports
+            .map((entry) => entry.slug)
+            .join(", ")}`);
+}
+function getWorkspaceAdminViewRequiredFiles(adminView) {
+    const adminViewDir = path.join("src", "admin-views", adminView.slug);
+    return Array.from(new Set([
+        adminView.file,
+        adminView.phpFile,
+        path.join(adminViewDir, "Screen.tsx"),
+        path.join(adminViewDir, "config.ts"),
+        path.join(adminViewDir, "data.ts"),
+        path.join(adminViewDir, "style.scss"),
+        path.join(adminViewDir, "types.ts"),
+    ]));
+}
+function checkWorkspaceAdminViewConfig(adminView, inventory) {
+    if (adminView.source === undefined) {
+        return createDoctorCheck(`Admin view config ${adminView.slug}`, "pass", "Admin view uses a replaceable local fetcher");
+    }
+    const source = adminView.source.trim();
+    const restSourceMatch = /^rest-resource:([a-z][a-z0-9-]*)$/u.exec(source);
+    const coreDataSourceMatch = /^core-data:(postType|taxonomy)\/([a-z0-9][a-z0-9_-]*)$/u.exec(source);
+    const restResourceSlug = restSourceMatch?.[1];
+    const restResource = restResourceSlug
+        ? inventory.restResources.find((entry) => entry.slug === restResourceSlug)
+        : undefined;
+    const isValid = Boolean(restResource?.methods.includes("list")) || Boolean(coreDataSourceMatch);
+    return createDoctorCheck(`Admin view config ${adminView.slug}`, isValid ? "pass" : "fail", isValid
+        ? `Admin view source ${source} is list-capable`
+        : "Admin view source must use rest-resource:<slug> with a list-capable REST resource or core-data:<postType|taxonomy>/<name>");
+}
+function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Admin view bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const loadFunctionName = `${phpPrefix}_load_admin_views`;
+    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const hasLoaderHook = source.includes(loadHook);
+    const hasServerGlob = source.includes(WORKSPACE_ADMIN_VIEW_GLOB);
+    return createDoctorCheck("Admin view bootstrap", hasLoaderHook && hasServerGlob ? "pass" : "fail", hasLoaderHook && hasServerGlob
+        ? "Admin view PHP loader hook is present"
+        : "Missing admin view PHP require glob or plugins_loaded hook");
+}
+function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
+    const indexRelativePath = [
+        path.join("src", "admin-views", "index.ts"),
+        path.join("src", "admin-views", "index.js"),
+    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingImports = adminViews.filter((adminView) => {
+        const importPattern = new RegExp(`['"\`]\\./${escapeRegex(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
+        return !importPattern.test(source);
+    });
+    return createDoctorCheck("Admin views index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
+        ? "Admin view registrations are aggregated"
+        : `Missing admin view imports for: ${missingImports
+            .map((entry) => entry.slug)
+            .join(", ")}`);
+}
+function checkWorkspaceAdminViewPhp(projectDir, adminView) {
+    const phpPath = path.join(projectDir, adminView.phpFile);
+    if (!fs.existsSync(phpPath)) {
+        return createDoctorCheck(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
+    }
+    const source = fs.readFileSync(phpPath, "utf8");
+    const hasAdminMenu = source.includes("add_submenu_page");
+    const hasAdminEnqueue = source.includes("admin_enqueue_scripts");
+    const hasScript = source.includes(WORKSPACE_ADMIN_VIEW_SCRIPT);
+    const hasAsset = source.includes(WORKSPACE_ADMIN_VIEW_ASSET);
+    const hasStyle = source.includes(WORKSPACE_ADMIN_VIEW_STYLE);
+    const hasComponentsStyleDependency = source.includes("'wp-components'");
+    return createDoctorCheck(`Admin view PHP ${adminView.slug}`, hasAdminMenu &&
+        hasAdminEnqueue &&
+        hasScript &&
+        hasAsset &&
+        hasStyle &&
+        hasComponentsStyleDependency
+        ? "pass"
+        : "fail", hasAdminMenu &&
+        hasAdminEnqueue &&
+        hasScript &&
+        hasAsset &&
+        hasStyle &&
+        hasComponentsStyleDependency
+        ? "Admin menu, script, style, and wp-components style dependency are wired"
+        : "Missing admin menu, enqueue hook, build/admin-views asset reference, or wp-components style dependency");
+}
+/**
+ * Collect workspace doctor checks for REST resources, abilities, AI features, editor plugins, and admin views.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @returns Ordered `DoctorCheck[]` rows for extracted workspace feature diagnostics.
+ */
+export function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
+    const checks = [];
+    if (inventory.restResources.length > 0) {
+        checks.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const restResource of inventory.restResources) {
+        checks.push(checkWorkspaceRestResourceConfig(restResource));
+        checks.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
+    }
+    if (inventory.abilities.length > 0) {
+        checks.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+        checks.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));
+    }
+    for (const ability of inventory.abilities) {
+        checks.push(checkWorkspaceAbilityConfig(workspace.projectDir, ability));
+        checks.push(checkExistingFiles(workspace.projectDir, `Ability ${ability.slug}`, getWorkspaceAbilityRequiredFiles(ability)));
+    }
+    if (inventory.aiFeatures.length > 0) {
+        checks.push(checkWorkspaceAiFeatureBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const aiFeature of inventory.aiFeatures) {
+        checks.push(checkWorkspaceAiFeatureConfig(aiFeature));
+        checks.push(checkExistingFiles(workspace.projectDir, `AI feature ${aiFeature.slug}`, getWorkspaceAiFeatureRequiredFiles(aiFeature)));
+    }
+    if (inventory.editorPlugins.length > 0) {
+        checks.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+        checks.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, inventory.editorPlugins));
+    }
+    for (const editorPlugin of inventory.editorPlugins) {
+        checks.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
+        checks.push(checkWorkspaceEditorPluginConfig(editorPlugin));
+    }
+    if (inventory.adminViews.length > 0) {
+        checks.push(checkWorkspaceAdminViewBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+        checks.push(checkWorkspaceAdminViewIndex(workspace.projectDir, inventory.adminViews));
+    }
+    for (const adminView of inventory.adminViews) {
+        checks.push(checkWorkspaceAdminViewConfig(adminView, inventory));
+        checks.push(checkExistingFiles(workspace.projectDir, `Admin view ${adminView.slug}`, getWorkspaceAdminViewRequiredFiles(adminView)));
+        checks.push(checkWorkspaceAdminViewPhp(workspace.projectDir, adminView));
+    }
+    return checks;
+}

package/dist/runtime/cli-doctor-workspace-package.d.ts

@@ -0,0 +1,18 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+import type { WorkspacePackageJson, WorkspaceProject } from "./workspace-project.js";
+/**
+ * Validate the package metadata that makes a project an official workspace.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
+ */
+export declare function getWorkspacePackageMetadataCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): DoctorCheck;
+/**
+ * Report whether a workspace configured for migrations exposes the expected doctor inputs.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
+ */
+export declare function getMigrationWorkspaceHintCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): DoctorCheck | null;

package/dist/runtime/cli-doctor-workspace-package.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createDoctorCheck, getWorkspaceBootstrapRelativePath, } from "./cli-doctor-workspace-shared.js";
+import { WORKSPACE_TEMPLATE_PACKAGE } from "./workspace-project.js";
+/**
+ * Validate the package metadata that makes a project an official workspace.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
+ */
+export function getWorkspacePackageMetadataCheck(workspace, packageJson) {
+    const issues = [];
+    const packageName = packageJson.name;
+    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
+    const wpTypia = packageJson.wpTypia;
+    if (typeof packageName !== "string" || packageName.length === 0) {
+        issues.push("package.json must define a string name for workspace bootstrap resolution");
+    }
+    if (wpTypia?.projectType !== "workspace") {
+        issues.push('wpTypia.projectType must be "workspace"');
+    }
+    if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+        issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+    }
+    if (wpTypia?.namespace !== workspace.workspace.namespace) {
+        issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
+    }
+    if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
+        issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
+        issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
+    }
+    if (!fs.existsSync(path.join(workspace.projectDir, bootstrapRelativePath))) {
+        issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+    }
+    return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}`
+        : issues.join("; "));
+}
+/**
+ * Report whether a workspace configured for migrations exposes the expected doctor inputs.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
+ */
+export function getMigrationWorkspaceHintCheck(workspace, packageJson) {
+    const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
+    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
+    const hasMigrationConfig = fs.existsSync(path.join(workspace.projectDir, migrationConfigRelativePath));
+    if (!hasMigrationScript && !hasMigrationConfig) {
+        return null;
+    }
+    return createDoctorCheck("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig
+        ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks"
+        : `Missing ${migrationConfigRelativePath} for the configured migration workspace`);
+}

package/dist/runtime/cli-doctor-workspace-shared.d.ts

@@ -0,0 +1,69 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/** Glob pattern for generated binding-source PHP entrypoints. */
+export declare const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+/** Relative path to the generated binding editor bundle. */
+export declare const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+/** Relative path to the generated binding asset manifest. */
+export declare const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+/** Glob pattern for generated REST resource PHP entrypoints. */
+export declare const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated ability PHP entrypoints. */
+export declare const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
+/** Relative path to the generated ability editor bundle. */
+export declare const WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+/** Relative path to the generated ability asset manifest. */
+export declare const WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+/** Glob pattern for generated AI feature PHP entrypoints. */
+export declare const WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
+/** Glob pattern for generated admin view PHP entrypoints. */
+export declare const WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
+/** Relative path to the generated admin view editor bundle. */
+export declare const WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
+/** Relative path to the generated admin view asset manifest. */
+export declare const WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
+/** Relative path to the generated admin view stylesheet. */
+export declare const WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
+/** Relative path to the generated editor plugin bundle. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+/** Relative path to the generated editor plugin asset manifest. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+/** Relative path to the generated editor plugin stylesheet. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+/** Canonical generated artifact filenames expected in each workspace block directory. */
+export declare const WORKSPACE_GENERATED_BLOCK_ARTIFACTS: readonly ["block.json", "typia.manifest.json", "typia.schema.json", "typia-validator.php", "typia.openapi.json"];
+/** Pattern for full block names in `namespace/slug` format. */
+export declare const WORKSPACE_FULL_BLOCK_NAME_PATTERN: RegExp;
+/**
+ * Create a doctor result row with an optional stable diagnostic code.
+ *
+ * @param label Human-readable doctor row label.
+ * @param status Pass, warn, or fail status for the row.
+ * @param detail Detailed remediation or success text for CLI output.
+ * @param code Optional stable machine-readable diagnostic code.
+ * @returns A normalized `DoctorCheck` object for CLI rendering.
+ */
+export declare function createDoctorCheck(label: string, status: DoctorCheck["status"], detail: string, code?: string): DoctorCheck;
+/**
+ * Create the standard workspace-doctor scope row.
+ *
+ * @param status Pass or fail scope status for the doctor run.
+ * @param detail Scope summary describing what diagnostics ran.
+ * @returns A `DoctorCheck` row labelled `Doctor scope`.
+ */
+export declare function createDoctorScopeCheck(status: DoctorCheck["status"], detail: string): DoctorCheck;
+/**
+ * Resolve the expected workspace bootstrap file from a package name.
+ *
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Relative PHP bootstrap filename for the workspace root.
+ */
+export declare function getWorkspaceBootstrapRelativePath(packageName: string): string;
+/**
+ * Verify that every referenced relative file exists inside a workspace.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param label Doctor row label for the file set being checked.
+ * @param filePaths Relative file paths to validate.
+ * @returns A passing or failing `DoctorCheck` describing any missing files.
+ */
+export declare function checkExistingFiles(projectDir: string, label: string, filePaths: Array<string | undefined>): DoctorCheck;

package/dist/runtime/cli-doctor-workspace-shared.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Glob pattern for generated binding-source PHP entrypoints. */
+export const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+/** Relative path to the generated binding editor bundle. */
+export const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+/** Relative path to the generated binding asset manifest. */
+export const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+/** Glob pattern for generated REST resource PHP entrypoints. */
+export const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated ability PHP entrypoints. */
+export const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
+/** Relative path to the generated ability editor bundle. */
+export const WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+/** Relative path to the generated ability asset manifest. */
+export const WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+/** Glob pattern for generated AI feature PHP entrypoints. */
+export const WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
+/** Glob pattern for generated admin view PHP entrypoints. */
+export const WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
+/** Relative path to the generated admin view editor bundle. */
+export const WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
+/** Relative path to the generated admin view asset manifest. */
+export const WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
+/** Relative path to the generated admin view stylesheet. */
+export const WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
+/** Relative path to the generated editor plugin bundle. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+/** Relative path to the generated editor plugin asset manifest. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+/** Relative path to the generated editor plugin stylesheet. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+/** Canonical generated artifact filenames expected in each workspace block directory. */
+export const WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+    "block.json",
+    "typia.manifest.json",
+    "typia.schema.json",
+    "typia-validator.php",
+    "typia.openapi.json",
+];
+/** Pattern for full block names in `namespace/slug` format. */
+export const WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+/**
+ * Create a doctor result row with an optional stable diagnostic code.
+ *
+ * @param label Human-readable doctor row label.
+ * @param status Pass, warn, or fail status for the row.
+ * @param detail Detailed remediation or success text for CLI output.
+ * @param code Optional stable machine-readable diagnostic code.
+ * @returns A normalized `DoctorCheck` object for CLI rendering.
+ */
+export function createDoctorCheck(label, status, detail, code) {
+    return code ? { code, detail, label, status } : { detail, label, status };
+}
+/**
+ * Create the standard workspace-doctor scope row.
+ *
+ * @param status Pass or fail scope status for the doctor run.
+ * @param detail Scope summary describing what diagnostics ran.
+ * @returns A `DoctorCheck` row labelled `Doctor scope`.
+ */
+export function createDoctorScopeCheck(status, detail) {
+    return createDoctorCheck("Doctor scope", status, detail);
+}
+/**
+ * Resolve the expected workspace bootstrap file from a package name.
+ *
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Relative PHP bootstrap filename for the workspace root.
+ */
+export function getWorkspaceBootstrapRelativePath(packageName) {
+    return `${packageName.split("/").pop() ?? packageName}.php`;
+}
+/**
+ * Verify that every referenced relative file exists inside a workspace.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param label Doctor row label for the file set being checked.
+ * @param filePaths Relative file paths to validate.
+ * @returns A passing or failing `DoctorCheck` describing any missing files.
+ */
+export function checkExistingFiles(projectDir, label, filePaths) {
+    const missing = filePaths
+        .filter((filePath) => typeof filePath === "string")
+        .filter((filePath) => !fs.existsSync(path.join(projectDir, filePath)));
+    return createDoctorCheck(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
+}