@wp-typia/project-tools 0.16.11 → 0.16.12

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

@@ -1,22 +1,12 @@
 import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { resolveWorkspaceProject, } from "./workspace-project.js";
-import { appendWorkspaceInventoryEntries, readWorkspaceInventory, } from "./workspace-inventory.js";
-import { toKebabCase, toTitleCase, } from "./string-case.js";
-import { assertBindingSourceDoesNotExist, assertPatternDoesNotExist, assertValidGeneratedSlug, assertValidHookAnchor, assertValidHookedBlockPosition, assertVariationDoesNotExist, getMutableBlockHooks, getWorkspaceBootstrapPath, normalizeBlockSlug, patchFile, quoteTsString, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { resolveWorkspaceProject } from "./workspace-project.js";
+import { appendWorkspaceInventoryEntries, readWorkspaceInventory } from "./workspace-inventory.js";
+import { toKebabCase, toTitleCase } from "./string-case.js";
+import { assertValidGeneratedSlug, assertValidHookAnchor, assertValidHookedBlockPosition, assertVariationDoesNotExist, getMutableBlockHooks, normalizeBlockSlug, patchFile, quoteTsString, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
 const VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
 const VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
-const PATTERN_BOOTSTRAP_CATEGORY = "register_block_pattern_category";
-const BINDING_SOURCE_SERVER_GLOB = "/src/bindings/*/server.php";
-const BINDING_SOURCE_EDITOR_SCRIPT = "build/bindings/index.js";
-const BINDING_SOURCE_EDITOR_ASSET = "build/bindings/index.asset.php";
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function quotePhpString(value) {
-    return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
-}
 function buildVariationConfigEntry(blockSlug, variationSlug) {
     return [
         "\t{",
@@ -26,23 +16,6 @@ function buildVariationConfigEntry(blockSlug, variationSlug) {
         "\t},",
     ].join("\n");
 }
-function buildPatternConfigEntry(patternSlug) {
-    return [
-        "\t{",
-        `\t\tfile: ${quoteTsString(`src/patterns/${patternSlug}.php`)},`,
-        `\t\tslug: ${quoteTsString(patternSlug)},`,
-        "\t},",
-    ].join("\n");
-}
-function buildBindingSourceConfigEntry(bindingSourceSlug) {
-    return [
-        "\t{",
-        `\t\teditorFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/editor.ts`)},`,
-        `\t\tserverFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/server.php`)},`,
-        `\t\tslug: ${quoteTsString(bindingSourceSlug)},`,
-        "\t},",
-    ].join("\n");
-}
 function buildVariationConstName(variationSlug) {
     const identifierSegments = toKebabCase(variationSlug)
         .split("-")
@@ -105,124 +78,6 @@ export function registerWorkspaceVariations() {
 }
 `;
 }
-function buildPatternSource(patternSlug, namespace, textDomain) {
-    const patternTitle = toTitleCase(patternSlug);
-    return `<?php
-if ( ! defined( 'ABSPATH' ) ) {
-\treturn;
-}
-
-register_block_pattern(
-\t'${namespace}/${patternSlug}',
-\tarray(
-\t\t'title'       => __( ${JSON.stringify(patternTitle)}, '${textDomain}' ),
-\t\t'description' => __( ${JSON.stringify(`A starter pattern for ${patternTitle}.`)}, '${textDomain}' ),
-\t\t'categories'  => array( '${namespace}' ),
-\t\t'content'     => '<!-- wp:paragraph --><p>' . esc_html__( 'Describe this pattern here.', '${textDomain}' ) . '</p><!-- /wp:paragraph -->',
-\t)
-);
-`;
-}
-function buildBindingSourceServerSource(bindingSourceSlug, phpPrefix, namespace, textDomain) {
-    const bindingSourceTitle = toTitleCase(bindingSourceSlug);
-    const bindingSourcePhpId = bindingSourceSlug.replace(/-/g, "_");
-    const bindingSourceValueFunctionName = `${phpPrefix}_${bindingSourcePhpId}_binding_source_values`;
-    const bindingSourceResolveFunctionName = `${phpPrefix}_${bindingSourcePhpId}_resolve_binding_source_value`;
-    const starterValue = `${bindingSourceTitle} starter value`;
-    return `<?php
-if ( ! defined( 'ABSPATH' ) ) {
-\treturn;
-}
-
-if ( ! function_exists( 'register_block_bindings_source' ) ) {
-\treturn;
-}
-
-if ( ! function_exists( '${bindingSourceValueFunctionName}' ) ) {
-\tfunction ${bindingSourceValueFunctionName}() : array {
-\t\treturn array(
-\t\t\t${quotePhpString(bindingSourceSlug)} => ${quotePhpString(starterValue)},
-\t\t);
-\t}
-}
-
-if ( ! function_exists( '${bindingSourceResolveFunctionName}' ) ) {
-\tfunction ${bindingSourceResolveFunctionName}( array $source_args ) : string {
-\t\t$field = isset( $source_args['field'] ) && is_string( $source_args['field'] )
-\t\t\t? $source_args['field']
-\t\t\t: '${bindingSourceSlug}';
-\t\t$binding_source_values = ${bindingSourceValueFunctionName}();
-\t\t$value = $binding_source_values[ $field ] ?? '';
-
-\t\treturn is_string( $value ) ? $value : '';
-\t}
-}
-
-register_block_bindings_source(
-\t${quotePhpString(`${namespace}/${bindingSourceSlug}`)},
-\tarray(
-\t\t'label' => __( ${quotePhpString(bindingSourceTitle)}, ${quotePhpString(textDomain)} ),
-\t\t'get_value_callback' => ${quotePhpString(bindingSourceResolveFunctionName)},
-\t)
-);
-`;
-}
-function buildBindingSourceEditorSource(bindingSourceSlug, namespace, textDomain) {
-    const bindingSourceTitle = toTitleCase(bindingSourceSlug);
-    const starterValue = `${bindingSourceTitle} starter value`;
-    return `import { registerBlockBindingsSource } from '@wordpress/blocks';
-import { __ } from '@wordpress/i18n';
-
-interface BindingSourceRegistration {
-\targs?: {
-\t\tfield?: string;
-\t};
-}
-
-const BINDING_SOURCE_VALUES: Record<string, string> = {
-\t${quoteTsString(bindingSourceSlug)}: ${quoteTsString(starterValue)},
-};
-
-function resolveBindingSourceValue( field: string ): string {
-\treturn BINDING_SOURCE_VALUES[ field ] ?? '';
-}
-
-registerBlockBindingsSource( {
-\tname: ${quoteTsString(`${namespace}/${bindingSourceSlug}`)},
-\tlabel: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
-\tgetFieldsList() {
-\t\treturn [
-\t\t\t{
-\t\t\t\tlabel: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
-\t\t\t\ttype: 'string',
-\t\t\t\targs: {
-\t\t\t\t\tfield: ${quoteTsString(bindingSourceSlug)},
-\t\t\t\t},
-\t\t\t},
-\t\t];
-\t},
-\tgetValues( { bindings } ) {
-\t\tconst values: Record<string, string> = {};
-\t\tfor ( const [ attributeName, binding ] of Object.entries(
-\t\t\tbindings as Record<string, BindingSourceRegistration>
-\t\t) ) {
-\t\t\tconst field =
-\t\t\t\ttypeof binding?.args?.field === 'string'
-\t\t\t\t\t? binding.args.field
-\t\t\t\t\t: ${quoteTsString(bindingSourceSlug)};
-\t\t\tvalues[ attributeName ] = resolveBindingSourceValue( field );
-\t\t}
-\t\treturn values;
-\t},
-} );
-`;
-}
-function buildBindingSourceIndexSource(bindingSourceSlugs) {
-    const importLines = bindingSourceSlugs
-        .map((bindingSourceSlug) => `import './${bindingSourceSlug}/editor';`)
-        .join("\n");
-    return `${importLines}${importLines ? "\n\n" : ""}// wp-typia add binding-source entries\n`;
-}
 async function ensureVariationRegistrationHook(blockIndexPath) {
     await patchFile(blockIndexPath, (source) => {
         let nextSource = source;
@@ -264,159 +119,7 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
     const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
     await fsp.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
-async function ensurePatternBootstrapAnchors(workspace) {
-    const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
-    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-    await patchFile(bootstrapPath, (source) => {
-        let nextSource = source;
-        const patternCategoryFunctionName = `${workspace.workspace.phpPrefix}_register_pattern_category`;
-        const patternRegistrationFunctionName = `${workspace.workspace.phpPrefix}_register_patterns`;
-        const patternCategoryHook = `add_action( 'init', '${patternCategoryFunctionName}' );`;
-        const patternRegistrationHook = `add_action( 'init', '${patternRegistrationFunctionName}', 20 );`;
-        const patternFunctions = `
-
-function ${patternCategoryFunctionName}() {
-\tif ( function_exists( 'register_block_pattern_category' ) ) {
-\t\tregister_block_pattern_category(
-\t\t\t'${workspace.workspace.namespace}',
-\t\t\tarray(
-\t\t\t\t'label' => __( ${JSON.stringify(`${toTitleCase(workspaceBaseName)} Patterns`)}, '${workspace.workspace.textDomain}' ),
-\t\t\t)
-\t\t);
-\t}
-}
-
-function ${patternRegistrationFunctionName}() {
-\tforeach ( glob( __DIR__ . '/src/patterns/*.php' ) ?: array() as $pattern_module ) {
-\t\trequire $pattern_module;
-\t}
-}
-`;
-        if (!nextSource.includes(PATTERN_BOOTSTRAP_CATEGORY)) {
-            const insertionAnchors = [
-                /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-                /\?>\s*$/u,
-            ];
-            let inserted = false;
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${patternFunctions}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    inserted = true;
-                    break;
-                }
-            }
-            if (!inserted) {
-                nextSource = `${nextSource.trimEnd()}\n${patternFunctions}\n`;
-            }
-        }
-        if (!nextSource.includes(patternCategoryFunctionName) ||
-            !nextSource.includes(patternRegistrationFunctionName)) {
-            throw new Error(`Unable to inject pattern bootstrap functions into ${path.basename(bootstrapPath)}.`);
-        }
-        if (!nextSource.includes(patternCategoryHook)) {
-            nextSource = `${nextSource.trimEnd()}\n${patternCategoryHook}\n`;
-        }
-        if (!nextSource.includes(patternRegistrationHook)) {
-            nextSource = `${nextSource.trimEnd()}\n${patternRegistrationHook}\n`;
-        }
-        return nextSource;
-    });
-}
-async function ensureBindingSourceBootstrapAnchors(workspace) {
-    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-    await patchFile(bootstrapPath, (source) => {
-        let nextSource = source;
-        const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
-        const bindingRegistrationFunctionName = `${workspace.workspace.phpPrefix}_register_binding_sources`;
-        const bindingEditorEnqueueFunctionName = `${workspace.workspace.phpPrefix}_enqueue_binding_sources_editor`;
-        const bindingRegistrationHook = `add_action( 'init', '${bindingRegistrationFunctionName}', 20 );`;
-        const bindingEditorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${bindingEditorEnqueueFunctionName}' );`;
-        const bindingRegistrationFunction = `
-
-function ${bindingRegistrationFunctionName}() {
-\tforeach ( glob( __DIR__ . '${BINDING_SOURCE_SERVER_GLOB}' ) ?: array() as $binding_source_module ) {
-\t\trequire_once $binding_source_module;
-\t}
-}
-`;
-        const bindingEditorEnqueueFunction = `
-
-function ${bindingEditorEnqueueFunctionName}() {
-\t$script_path = __DIR__ . '/${BINDING_SOURCE_EDITOR_SCRIPT}';
-\t$asset_path  = __DIR__ . '/${BINDING_SOURCE_EDITOR_ASSET}';
-
-\tif ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
-\t\treturn;
-\t}
-
-\t$asset = require $asset_path;
-\tif ( ! is_array( $asset ) ) {
-\t\t$asset = array();
-\t}
-
-\twp_enqueue_script(
-\t\t'${workspaceBaseName}-binding-sources',
-\t\tplugins_url( '${BINDING_SOURCE_EDITOR_SCRIPT}', __FILE__ ),
-\t\tisset( $asset['dependencies'] ) && is_array( $asset['dependencies'] ) ? $asset['dependencies'] : array(),
-\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
-\t\ttrue
-\t);
-}
-`;
-        const insertionAnchors = [
-            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-            /\?>\s*$/u,
-        ];
-        const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u").test(nextSource);
-        const insertPhpSnippet = (snippet) => {
-            for (const anchor of insertionAnchors) {
-                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
-                if (candidate !== nextSource) {
-                    nextSource = candidate;
-                    return;
-                }
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        const appendPhpSnippet = (snippet) => {
-            const closingTagPattern = /\?>\s*$/u;
-            if (closingTagPattern.test(nextSource)) {
-                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
-                return;
-            }
-            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
-        };
-        if (!hasPhpFunctionDefinition(bindingRegistrationFunctionName)) {
-            insertPhpSnippet(bindingRegistrationFunction);
-        }
-        if (!hasPhpFunctionDefinition(bindingEditorEnqueueFunctionName)) {
-            insertPhpSnippet(bindingEditorEnqueueFunction);
-        }
-        if (!nextSource.includes(bindingRegistrationHook)) {
-            appendPhpSnippet(bindingRegistrationHook);
-        }
-        if (!nextSource.includes(bindingEditorEnqueueHook)) {
-            appendPhpSnippet(bindingEditorEnqueueHook);
-        }
-        return nextSource;
-    });
-}
-function resolveBindingSourceRegistryPath(projectDir) {
-    const bindingsDir = path.join(projectDir, "src", "bindings");
-    return [path.join(bindingsDir, "index.ts"), path.join(bindingsDir, "index.js")].find((candidatePath) => fs.existsSync(candidatePath)) ?? path.join(bindingsDir, "index.ts");
-}
-async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-    const bindingsDir = path.join(projectDir, "src", "bindings");
-    const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
-    await fsp.mkdir(bindingsDir, { recursive: true });
-    const existingBindingSourceSlugs = fs
-        .readdirSync(bindingsDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name);
-    const nextBindingSourceSlugs = Array.from(new Set([...existingBindingSourceSlugs, bindingSourceSlug])).sort();
-    await fsp.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
-}
+export { runAddBindingSourceCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
 /**
  * Add one variation entry to an existing workspace block.
  *
@@ -473,100 +176,6 @@ export async function runAddVariationCommand({ blockName, cwd = process.cwd(), v
         throw error;
     }
 }
-/**
- * Add one PHP block pattern shell to an official workspace project.
- *
- * @param options Command options for the pattern scaffold workflow.
- * @param options.cwd Working directory used to resolve the nearest official workspace.
- * Defaults to `process.cwd()`.
- * @param options.patternName Human-entered pattern name that will be normalized
- * and validated before files are written.
- * @returns A promise that resolves with the normalized `patternSlug` and
- * owning `projectDir` after the pattern file and inventory entry have been
- * written successfully.
- * @throws {Error} When the command is run outside an official workspace, when
- * the pattern slug is invalid, or when a conflicting file or inventory entry
- * already exists.
- */
-export async function runAddPatternCommand({ cwd = process.cwd(), patternName, }) {
-    const workspace = resolveWorkspaceProject(cwd);
-    const patternSlug = assertValidGeneratedSlug("Pattern name", normalizeBlockSlug(patternName), "wp-typia add pattern <name>");
-    const inventory = readWorkspaceInventory(workspace.projectDir);
-    assertPatternDoesNotExist(workspace.projectDir, patternSlug, inventory);
-    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
-    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-    const patternFilePath = path.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
-    const mutationSnapshot = {
-        fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
-        snapshotDirs: [],
-        targetPaths: [patternFilePath],
-    };
-    try {
-        await fsp.mkdir(path.dirname(patternFilePath), { recursive: true });
-        await ensurePatternBootstrapAnchors(workspace);
-        await fsp.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
-        await appendWorkspaceInventoryEntries(workspace.projectDir, {
-            patternEntries: [buildPatternConfigEntry(patternSlug)],
-        });
-        return {
-            patternSlug,
-            projectDir: workspace.projectDir,
-        };
-    }
-    catch (error) {
-        await rollbackWorkspaceMutation(mutationSnapshot);
-        throw error;
-    }
-}
-/**
- * Add one block binding source scaffold to an official workspace project.
- *
- * @param options Command options for the binding-source scaffold workflow.
- * @param options.bindingSourceName Human-entered binding source name that will
- * be normalized and validated before files are written.
- * @param options.cwd Working directory used to resolve the nearest official
- * workspace. Defaults to `process.cwd()`.
- * @returns A promise that resolves with the normalized `bindingSourceSlug` and
- * owning `projectDir` after the server/editor files and inventory entry have
- * been written successfully.
- * @throws {Error} When the command is run outside an official workspace, when
- * the slug is invalid, or when a conflicting file or inventory entry exists.
- */
-export async function runAddBindingSourceCommand({ bindingSourceName, cwd = process.cwd(), }) {
-    const workspace = resolveWorkspaceProject(cwd);
-    const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name>");
-    const inventory = readWorkspaceInventory(workspace.projectDir);
-    assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
-    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
-    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-    const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-    const bindingSourceDir = path.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-    const serverFilePath = path.join(bindingSourceDir, "server.php");
-    const editorFilePath = path.join(bindingSourceDir, "editor.ts");
-    const mutationSnapshot = {
-        fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath, bindingsIndexPath]),
-        snapshotDirs: [],
-        targetPaths: [bindingSourceDir],
-    };
-    try {
-        await fsp.mkdir(bindingSourceDir, { recursive: true });
-        await ensureBindingSourceBootstrapAnchors(workspace);
-        await fsp.writeFile(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.phpPrefix, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
-        await fsp.writeFile(editorFilePath, buildBindingSourceEditorSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
-        await writeBindingSourceRegistry(workspace.projectDir, bindingSourceSlug);
-        await appendWorkspaceInventoryEntries(workspace.projectDir, {
-            bindingSourceEntries: [buildBindingSourceConfigEntry(bindingSourceSlug)],
-        });
-        return {
-            bindingSourceSlug,
-            projectDir: workspace.projectDir,
-        };
-    }
-    catch (error) {
-        await rollbackWorkspaceMutation(mutationSnapshot);
-        throw error;
-    }
-}
 /**
  * Add one `blockHooks` entry to an existing official workspace block.
  *

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

@@ -0,0 +1,12 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/**
+ * Collect environment-scoped doctor checks for the current working directory.
+ *
+ * The returned rows cover Bun/Node/git availability, writability of the
+ * current working directory and OS temp directory, and built-in or external
+ * template asset integrity in display order.
+ *
+ * @param cwd Working directory validated for writability.
+ * @returns Ordered environment check rows ready for CLI rendering.
+ */
+export declare function getEnvironmentDoctorChecks(cwd: string): Promise<DoctorCheck[]>;

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

@@ -0,0 +1,123 @@
+import { execFileSync } from "node:child_process";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getBuiltInTemplateLayerDirs, isOmittableBuiltInTemplateLayerDir, } from "./template-builtins.js";
+import { isBuiltInTemplateId, listTemplates } from "./template-registry.js";
+function readCommandVersion(command, args = ["--version"]) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function compareMajorVersion(actualVersion, minimumMajor) {
+    const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+    return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+async function checkWritableDirectory(directory) {
+    try {
+        await access(directory, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkTempDirectory() {
+    const tempFile = path.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+    try {
+        await writeFile(tempFile, "ok", "utf8");
+        await rm(tempFile, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createDoctorCheck(label, status, detail) {
+    return { detail, label, status };
+}
+function getTemplateDoctorChecks() {
+    const checks = [];
+    for (const template of listTemplates()) {
+        if (!isBuiltInTemplateId(template.id)) {
+            const templateDirExists = fs.existsSync(template.templateDir);
+            const hasAssets = templateDirExists &&
+                fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+            checks.push({
+                status: !templateDirExists || hasAssets ? "pass" : "fail",
+                label: `Template ${template.id}`,
+                detail: !templateDirExists
+                    ? "External template metadata only; local overlay package is not installed."
+                    : hasAssets
+                        ? template.templateDir
+                        : "Missing core template assets",
+            });
+            continue;
+        }
+        const builtInTemplateId = template.id;
+        const layerDirs = builtInTemplateId === "persistence"
+            ? Array.from(new Set([
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "authenticated" }),
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "public" }),
+            ]))
+            : builtInTemplateId === "compound"
+                ? Array.from(new Set([
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId),
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
+                        persistenceEnabled: true,
+                        persistencePolicy: "authenticated",
+                    }),
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
+                        persistenceEnabled: true,
+                        persistencePolicy: "public",
+                    }),
+                ]))
+                : getBuiltInTemplateLayerDirs(builtInTemplateId);
+        const missingRequiredLayer = layerDirs.some((layerDir) => !fs.existsSync(layerDir) &&
+            !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
+        const existingLayerDirs = layerDirs.filter((layerDir) => fs.existsSync(layerDir));
+        const hasAssets = !missingRequiredLayer &&
+            existingLayerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "package.json.mustache"))) &&
+            existingLayerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "src")));
+        checks.push({
+            status: hasAssets ? "pass" : "fail",
+            label: `Template ${template.id}`,
+            detail: hasAssets
+                ? existingLayerDirs.join(" + ")
+                : "Missing core template assets",
+        });
+    }
+    return checks;
+}
+/**
+ * Collect environment-scoped doctor checks for the current working directory.
+ *
+ * The returned rows cover Bun/Node/git availability, writability of the
+ * current working directory and OS temp directory, and built-in or external
+ * template asset integrity in display order.
+ *
+ * @param cwd Working directory validated for writability.
+ * @returns Ordered environment check rows ready for CLI rendering.
+ */
+export async function getEnvironmentDoctorChecks(cwd) {
+    const bunVersion = readCommandVersion("bun");
+    const nodeVersion = readCommandVersion("node");
+    const gitVersion = readCommandVersion("git");
+    const cwdWritable = await checkWritableDirectory(cwd);
+    const tempWritable = await checkTempDirectory();
+    return [
+        createDoctorCheck("Bun", bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail", bunVersion ? `Detected ${bunVersion}` : "Not available"),
+        createDoctorCheck("Node", nodeVersion && compareMajorVersion(nodeVersion, 20) ? "pass" : "fail", nodeVersion ? `Detected ${nodeVersion}` : "Not available"),
+        createDoctorCheck("git", gitVersion ? "pass" : "fail", gitVersion ?? "Not available"),
+        createDoctorCheck("Current directory", cwdWritable ? "pass" : "fail", cwdWritable ? "Writable" : "Not writable"),
+        createDoctorCheck("Temp directory", tempWritable ? "pass" : "fail", tempWritable ? "Writable" : "Not writable"),
+        ...getTemplateDoctorChecks(),
+    ];
+}

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

@@ -0,0 +1,14 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/**
+ * Collect workspace-scoped doctor checks for the given working directory.
+ *
+ * When the directory is not an official workspace, the function returns an
+ * empty array or a single failing "Workspace package metadata" row describing
+ * the reason. When workspace resolution or metadata parsing throws, the
+ * corresponding failing row is returned early and the remaining checks are
+ * skipped.
+ *
+ * @param cwd Working directory expected to host an official workspace.
+ * @returns Ordered workspace check rows ready for CLI rendering.
+ */
+export declare function getWorkspaceDoctorChecks(cwd: string): DoctorCheck[];