wp-typia 0.22.2 → 0.22.4

package/dist-bunli/{command-list-d3dcvzg2.js → command-list-wsaa4t2p.js}

@@ -18,7 +18,7 @@ import {
   package_default,
   prefersStructuredCliOutput,
   resolveCommandOptionValues
-} from "./cli-n6hgvysz.js";
+} from "./cli-gsj6vyn5.js";
 import {
   Result,
   TaggedError,
@@ -32,9 +32,6 @@ import {
   useRuntime
 } from "./cli-hv2yedw2.js";
 import"./cli-ac2ebaf8.js";
-import {
-  formatPackageExecCommand
-} from "./cli-sj5mtyzj.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -42,6 +39,12 @@ import {
   CLI_DIAGNOSTIC_CODES,
   createCliDiagnosticCodeError
 } from "./cli-p95wr1q8.js";
+import {
+  formatInstallCommand,
+  formatPackageExecCommand,
+  formatRunScript,
+  inferPackageManagerId
+} from "./cli-6bhfzq5e.js";
 import {
   __require,
   __toESM
@@ -71,6 +74,62 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
 `));
 }
 
+// src/cli-string-flags.ts
+function readOptionalCliStringFlagValue(flags, name, mode) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+    }
+    return;
+  }
+  return mode === "strict" ? value : trimmed;
+}
+function readOptionalLooseStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "loose");
+}
+function readOptionalStrictStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "strict");
+}
+function requireStrictStringFlag(flags, name, message) {
+  const value = readOptionalStrictStringFlag(flags, name);
+  if (!value) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return value;
+}
+function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
+  const leftValue = readOptionalStrictStringFlag(flags, leftName);
+  const rightValue = readOptionalStrictStringFlag(flags, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
+
+// src/external-layer-prompt-options.ts
+function formatExternalLayerSelectHint(option2) {
+  const details = [
+    option2.description,
+    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" \xB7 ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option2) => ({
+    hint: formatExternalLayerSelectHint(option2),
+    label: option2.id,
+    value: option2.id
+  }));
+}
+
 // src/add-kind-registry.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
@@ -129,51 +188,12 @@ var NAME_NAMESPACE_VISIBLE_FIELDS = [
   "name",
   "namespace"
 ];
-function readOptionalStringFlag(flags, name) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  return value;
-}
-function requireStringFlag(flags, name, message) {
-  const value = readOptionalStringFlag(flags, name);
-  if (!value) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return value;
-}
-function readOptionalPairedStringFlags(flags, leftName, rightName, message) {
-  const leftValue = readOptionalStringFlag(flags, leftName);
-  const rightValue = readOptionalStringFlag(flags, rightName);
-  if (Boolean(leftValue) !== Boolean(rightValue)) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
 function requireAddKindName(context, message) {
   if (!context.name) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
   }
   return context.name;
 }
-function formatExternalLayerSelectHint(option2) {
-  const details = [
-    option2.description,
-    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions(options) {
-  return options.map((option2) => ({
-    hint: formatExternalLayerSelectHint(option2),
-    label: option2.id,
-    value: option2.id
-  }));
-}
 function defineAddKindRegistryEntry(entry) {
   return entry;
 }
@@ -189,6 +209,18 @@ function createNamedExecutionPlan(context, options) {
 function isAddPersistenceTemplate(template) {
   return template === "persistence" || template === "compound";
 }
+function formatAddBlockTemplateIds(addRuntime) {
+  return addRuntime.ADD_BLOCK_TEMPLATE_IDS.join(", ");
+}
+function assertAddBlockTemplateId(context, templateId) {
+  if (context.addRuntime.isAddBlockTemplateId(templateId)) {
+    return templateId;
+  }
+  if (templateId === "query-loop") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+  }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
+}
 var ADD_KIND_REGISTRY = {
   "admin-view": defineAddKindRegistryEntry({
     completion: {
@@ -207,7 +239,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Admin view name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
-      const source = readOptionalStringFlag(context.flags, "source");
+      const source = readOptionalStrictStringFlag(context.flags, "source");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
           adminViewName: name2,
@@ -247,7 +279,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Binding source name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const [blockName, attributeName] = readOptionalPairedStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+      const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
           attributeName,
@@ -287,15 +319,16 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Block name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
-      const externalLayerId = readOptionalStringFlag(context.flags, "external-layer-id");
-      const externalLayerSource = readOptionalStringFlag(context.flags, "external-layer-source");
+      const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
+      const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
       const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
       const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-      const alternateRenderTargets = readOptionalStringFlag(context.flags, "alternate-render-targets");
-      const dataStorageMode = readOptionalStringFlag(context.flags, "data-storage");
-      const innerBlocksPreset = readOptionalStringFlag(context.flags, "inner-blocks-preset");
-      const persistencePolicy = readOptionalStringFlag(context.flags, "persistence-policy");
-      let resolvedTemplateId = readOptionalStringFlag(context.flags, "template");
+      const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
+      const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
+      const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
+      const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
+      const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
+      let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
       if (!resolvedTemplateId && context.isInteractiveSession) {
         const templatePrompt = await context.getOrCreatePrompt();
         resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
@@ -392,7 +425,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Editor plugin name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
-      const slot = readOptionalStringFlag(context.flags, "slot");
+      const slot = readOptionalStrictStringFlag(context.flags, "slot");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
           cwd,
@@ -430,8 +463,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Target block",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-      const anchorBlockName = requireStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      const position = requireStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+      const anchorBlockName = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+      const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
           anchorBlockName,
@@ -501,7 +534,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Style name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
           blockName: blockSlug,
@@ -539,8 +572,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Transform name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = requireStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
-      const toBlockName = requireStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+      const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+      const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
           cwd,
@@ -581,8 +614,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "REST resource name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
-      const methods = readOptionalStringFlag(context.flags, "methods");
-      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      const methods = readOptionalStrictStringFlag(context.flags, "methods");
+      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
           cwd,
@@ -621,7 +654,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "AI feature name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
-      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
           aiFeatureName: name2,
@@ -660,7 +693,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Variation name",
     async prepareExecution(context) {
       const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
           blockName: blockSlug,
@@ -811,7 +844,7 @@ async function simulateWorkspaceAddDryRun({
   cwd,
   execute
 }) {
-  const { resolveWorkspaceProject } = await import("./workspace-project-gxb499cp.js");
+  const { resolveWorkspaceProject } = await import("./workspace-project-7826tewa.js");
   const workspace = resolveWorkspaceProject(cwd);
   const relativeCwd = path.relative(workspace.projectDir, path.resolve(cwd));
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-add-plan-");
@@ -831,10 +864,6 @@ async function simulateWorkspaceAddDryRun({
   }
 }
 
-// src/runtime-bridge-output.ts
-import fs3 from "fs";
-import path2 from "path";
-
 // src/output-markers.ts
 var UNICODE_OUTPUT_MARKERS = {
   dryRun: "\uD83E\uDDEA",
@@ -1080,32 +1109,6 @@ function buildInitCompletionPayload(plan, markerOptions) {
     warningLines: plan.notes
   };
 }
-function inferProjectPackageManager(projectDir) {
-  try {
-    const packageJsonPath = path2.join(projectDir, "package.json");
-    if (fs3.existsSync(packageJsonPath)) {
-      const manifest = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
-      if (manifest.packageManager?.startsWith("bun@"))
-        return "bun";
-      if (manifest.packageManager?.startsWith("pnpm@"))
-        return "pnpm";
-      if (manifest.packageManager?.startsWith("yarn@"))
-        return "yarn";
-      if (manifest.packageManager?.startsWith("npm@"))
-        return "npm";
-    }
-  } catch {}
-  if (fs3.existsSync(path2.join(projectDir, "bun.lock")) || fs3.existsSync(path2.join(projectDir, "bun.lockb"))) {
-    return "bun";
-  }
-  if (fs3.existsSync(path2.join(projectDir, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs3.existsSync(path2.join(projectDir, "yarn.lock")) || fs3.existsSync(path2.join(projectDir, ".yarnrc.yml"))) {
-    return "yarn";
-  }
-  return "npm";
-}
 function buildMigrationCompletionPayload(options, markerOptions) {
   const summaryLines = options.lines.filter((line) => line.trim().length > 0);
   return {
@@ -1115,7 +1118,7 @@ function buildMigrationCompletionPayload(options, markerOptions) {
 }
 function buildAddCompletionPayload(options, markerOptions) {
   const verificationLines = [
-    formatPackageExecCommand(options.packageManager ?? inferProjectPackageManager(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
+    formatPackageExecCommand(options.packageManager ?? inferPackageManagerId(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
   ];
   const verificationNote = "Run doctor via your package manager for a quick inventory and generated-artifact check after the add workflow.";
   const completion = buildAddKindCompletionDetails(options.kind, {
@@ -1165,20 +1168,6 @@ function printBlock(lines, printLine) {
     printLine(line);
   }
 }
-function formatExternalLayerSelectHint2(option2) {
-  const details = [
-    option2.description,
-    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions2(options) {
-  return options.map((option2) => ({
-    hint: formatExternalLayerSelectHint2(option2),
-    label: option2.id,
-    value: option2.id
-  }));
-}
 
 // src/runtime-capabilities.ts
 function isInteractiveTerminal({
@@ -1194,8 +1183,8 @@ function supportsInteractiveTui(options = {}) {
 }
 // src/runtime-bridge-sync.ts
 import { spawnSync } from "child_process";
-import fs4 from "fs";
-import path3 from "path";
+import fs3 from "fs";
+import path2 from "path";
 var SYNC_INSTALL_MARKERS = [
   "node_modules",
   ".pnp.cjs",
@@ -1212,64 +1201,15 @@ function resolveSyncExecutionTarget(subcommand) {
   }
   throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
 }
-function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
-  const args = extraArgs.trim();
-  if (packageManagerId === "bun") {
-    return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
-  }
-  if (packageManagerId === "npm") {
-    return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
-  }
-  if (packageManagerId === "pnpm") {
-    return args ? `pnpm run ${scriptName} ${args}` : `pnpm run ${scriptName}`;
-  }
-  return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
-}
-function formatInstallCommand(packageManagerId) {
-  switch (packageManagerId) {
-    case "bun":
-      return "bun install";
-    case "pnpm":
-      return "pnpm install";
-    case "yarn":
-      return "yarn install";
-    default:
-      return "npm install";
-  }
-}
 function getSyncRootError(cwd) {
   return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
 }
-function inferSyncPackageManager(cwd, packageManagerField) {
-  const field = String(packageManagerField ?? "");
-  if (field.startsWith("bun@"))
-    return "bun";
-  if (field.startsWith("npm@"))
-    return "npm";
-  if (field.startsWith("pnpm@"))
-    return "pnpm";
-  if (field.startsWith("yarn@"))
-    return "yarn";
-  if (fs4.existsSync(path3.join(cwd, "bun.lock")) || fs4.existsSync(path3.join(cwd, "bun.lockb"))) {
-    return "bun";
-  }
-  if (fs4.existsSync(path3.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs4.existsSync(path3.join(cwd, "yarn.lock")) || fs4.existsSync(path3.join(cwd, ".pnp.cjs")) || fs4.existsSync(path3.join(cwd, ".pnp.loader.mjs")) || fs4.existsSync(path3.join(cwd, ".yarnrc.yml"))) {
-    return "yarn";
-  }
-  if (fs4.existsSync(path3.join(cwd, "package-lock.json")) || fs4.existsSync(path3.join(cwd, "npm-shrinkwrap.json"))) {
-    return "npm";
-  }
-  return "npm";
-}
 function resolveSyncProjectContext(cwd) {
-  const packageJsonPath = path3.join(cwd, "package.json");
-  if (!fs4.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(cwd, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
     throw getSyncRootError(cwd);
   }
-  const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
   const scripts = packageJson.scripts ?? {};
   const syncScripts = {
     sync: typeof scripts.sync === "string" ? {
@@ -1295,17 +1235,17 @@ function resolveSyncProjectContext(cwd) {
   return {
     cwd,
     packageJsonPath,
-    packageManager: inferSyncPackageManager(cwd, packageJson.packageManager),
+    packageManager: inferPackageManagerId(cwd, packageJson.packageManager),
     scripts: syncScripts
   };
 }
 function findInstalledDependencyMarkerDir(projectDir) {
-  let currentDir = path3.resolve(projectDir);
+  let currentDir = path2.resolve(projectDir);
   while (true) {
-    if (SYNC_INSTALL_MARKERS.some((marker) => fs4.existsSync(path3.join(currentDir, marker)))) {
+    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path2.join(currentDir, marker)))) {
       return currentDir;
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path2.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -1440,14 +1380,14 @@ async function executeSyncCommand({
 }
 
 // src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("./cli-add-s0p4w1wz.js");
+var loadCliAddRuntime = () => import("./cli-add-6s6kzf7x.js");
 var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-5dvztm7q.js");
-var loadCliDoctorRuntime = () => import("./cli-doctor-6dchxz12.js");
-var loadCliInitRuntime = () => import("./cli-init-r6h1xchq.js");
+var loadCliDoctorRuntime = () => import("./cli-doctor-70zd5m3b.js");
+var loadCliInitRuntime = () => import("./cli-init-kjjyky1y.js");
 var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-f023yxc5.js");
+var loadCliScaffoldRuntime = () => import("./cli-scaffold-f57ccf5v.js");
 var loadCliTemplatesRuntime = () => import("./cli-templates-9t2a7zqd.js");
-var loadMigrationsRuntime = () => import("./migrations-pg5b9fh4.js");
+var loadMigrationsRuntime = () => import("./migrations-vw502qf9.js");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError } = await loadCliDiagnosticsRuntime();
   return createCliCommandError({ command, error });
@@ -1461,17 +1401,6 @@ function shouldWrapCliCommandError(options) {
   }
   return true;
 }
-function readOptionalLooseStringFlag(flags, name) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
 function pushFlag(argv, name, value) {
   if (value === undefined || value === null || value === false) {
     return;
@@ -1613,7 +1542,7 @@ async function executeCreateCommand({
       promptText: activePrompt ? (message, defaultValue, validate) => activePrompt.text(message, defaultValue, validate) : undefined,
       queryPostType: readOptionalLooseStringFlag(flags, "query-post-type"),
       selectDataStorage: activePrompt ? () => activePrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1) : undefined,
-      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions2(options), 1) : undefined,
+      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
       selectPackageManager: activePrompt ? () => activePrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1) : undefined,
       selectPersistencePolicy: activePrompt ? () => activePrompt.select("Select a persistence policy", [...PERSISTENCE_POLICY_PROMPT_OPTIONS], 1) : undefined,
       selectTemplate: activePrompt ? () => activePrompt.select("Select a template", getTemplateSelectOptions(), 1) : undefined,
@@ -2406,7 +2335,7 @@ var doctorCommand = defineCommand({
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     if (prefersStructuredOutput) {
       const [{ getDoctorChecks }, { getDoctorFailureDetailLines }] = await Promise.all([
-        import("./cli-doctor-6dchxz12.js"),
+        import("./cli-doctor-70zd5m3b.js"),
         import("./cli-diagnostics-5dvztm7q.js")
       ]);
       const checks = await getDoctorChecks(args.cwd);
@@ -2464,8 +2393,8 @@ var initCommand = defineCommand({
 });
 
 // src/mcp.ts
-import fs5 from "fs/promises";
-import path4 from "path";
+import fs4 from "fs/promises";
+import path3 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -2484,7 +2413,7 @@ class McpToolsProviderError extends TaggedError("McpToolsProviderError")() {
 function jsonSchemaToZodSchema(schema, options = {}) {
   return convertSchema(schema, options, "$");
 }
-function convertSchema(schema, options, path4) {
+function convertSchema(schema, options, path3) {
   const { coerce = true } = options;
   if (!schema || typeof schema !== "object") {
     return Result.ok(exports_external.unknown());
@@ -2499,49 +2428,49 @@ function convertSchema(schema, options, path4) {
         return Result.ok(exports_external.enum(enumValues));
       }
       const literals = enumValues.map((v) => exports_external.literal(v));
-      return unionFromSchemas(literals, path4);
+      return unionFromSchemas(literals, path3);
     }
   }
   if (schema.anyOf && schema.anyOf.length > 0) {
-    const schemas = mapSchemas(schema.anyOf, options, `${path4}.anyOf`);
+    const schemas = mapSchemas(schema.anyOf, options, `${path3}.anyOf`);
     if (Result.isError(schemas)) {
       return schemas;
     }
-    return unionFromSchemas(schemas.value, `${path4}.anyOf`);
+    return unionFromSchemas(schemas.value, `${path3}.anyOf`);
   }
   if (schema.oneOf && schema.oneOf.length > 0) {
-    const schemas = mapSchemas(schema.oneOf, options, `${path4}.oneOf`);
+    const schemas = mapSchemas(schema.oneOf, options, `${path3}.oneOf`);
     if (Result.isError(schemas)) {
       return schemas;
     }
-    return unionFromSchemas(schemas.value, `${path4}.oneOf`);
+    return unionFromSchemas(schemas.value, `${path3}.oneOf`);
   }
   const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
   switch (schemaType) {
     case "string":
-      return buildStringSchema(schema, path4);
+      return buildStringSchema(schema, path3);
     case "number":
     case "integer":
       return Result.ok(buildNumberSchema(schema, coerce));
     case "boolean":
       return Result.ok(buildBooleanSchema());
     case "array":
-      return buildArraySchema(schema, options, path4);
+      return buildArraySchema(schema, options, path3);
     case "object":
-      return buildObjectSchema(schema, options, path4);
+      return buildObjectSchema(schema, options, path3);
     case "null":
       return Result.ok(exports_external.null());
     default:
       if (schema.properties) {
-        return buildObjectSchema(schema, options, path4);
+        return buildObjectSchema(schema, options, path3);
       }
       if (schema.items) {
-        return buildArraySchema(schema, options, path4);
+        return buildArraySchema(schema, options, path3);
       }
       return Result.ok(exports_external.unknown());
   }
 }
-function buildStringSchema(schema, path4) {
+function buildStringSchema(schema, path3) {
   let zodSchema = exports_external.string();
   if (schema.minLength !== undefined) {
     zodSchema = zodSchema.min(schema.minLength);
@@ -2554,7 +2483,7 @@ function buildStringSchema(schema, path4) {
     const regexResult = Result.try({
       try: () => new RegExp(pattern),
       catch: (cause) => new SchemaConversionError({
-        path: path4,
+        path: path3,
         message: `Invalid regex pattern "${pattern}"`,
         cause
       })
@@ -2611,19 +2540,19 @@ function buildNumberSchema(schema, coerce) {
 function buildBooleanSchema() {
   return exports_external.boolean();
 }
-function buildArraySchema(schema, options, path4) {
+function buildArraySchema(schema, options, path3) {
   let itemSchema = exports_external.unknown();
   if (schema.items) {
     if (Array.isArray(schema.items)) {
       if (schema.items.length > 0) {
-        const itemResult = convertSchema(schema.items[0], options, `${path4}.items[0]`);
+        const itemResult = convertSchema(schema.items[0], options, `${path3}.items[0]`);
         if (Result.isError(itemResult)) {
           return itemResult;
         }
         itemSchema = itemResult.value;
       }
     } else {
-      const itemResult = convertSchema(schema.items, options, `${path4}.items`);
+      const itemResult = convertSchema(schema.items, options, `${path3}.items`);
       if (Result.isError(itemResult)) {
         return itemResult;
       }
@@ -2639,14 +2568,14 @@ function buildArraySchema(schema, options, path4) {
   }
   return Result.ok(zodSchema);
 }
-function buildObjectSchema(schema, options, path4) {
+function buildObjectSchema(schema, options, path3) {
   if (!schema.properties) {
     return Result.ok(exports_external.record(exports_external.string(), exports_external.unknown()));
   }
   const shape = {};
   const requiredFields = new Set(schema.required || []);
   for (const [propName, propSchema] of Object.entries(schema.properties)) {
-    const propResult = convertSchema(propSchema, options, `${path4}.properties.${propName}`);
+    const propResult = convertSchema(propSchema, options, `${path3}.properties.${propName}`);
     if (Result.isError(propResult)) {
       return propResult;
     }
@@ -2661,10 +2590,10 @@ function buildObjectSchema(schema, options, path4) {
   }
   return Result.ok(exports_external.object(shape));
 }
-function mapSchemas(schemas, options, path4) {
+function mapSchemas(schemas, options, path3) {
   const zodSchemas = [];
   for (let index = 0;index < schemas.length; index += 1) {
-    const converted = convertSchema(schemas[index], options, `${path4}[${index}]`);
+    const converted = convertSchema(schemas[index], options, `${path3}[${index}]`);
     if (Result.isError(converted)) {
       return converted;
     }
@@ -2672,11 +2601,11 @@ function mapSchemas(schemas, options, path4) {
   }
   return Result.ok(zodSchemas);
 }
-function unionFromSchemas(schemas, path4) {
+function unionFromSchemas(schemas, path3) {
   if (schemas.length === 0) {
     return Result.err(new SchemaConversionError({
-      path: path4,
-      message: `Cannot create union from an empty schema set at ${path4}`,
+      path: path3,
+      message: `Cannot create union from an empty schema set at ${path3}`,
       cause: new Error("Empty schema union")
     }));
   }
@@ -2993,8 +2922,8 @@ function isToolGroup(value) {
   return isObject(value) && typeof value.namespace === "string" && Array.isArray(value.tools) && value.tools.every(isTool);
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path4.resolve(cwd, source.path);
-  const raw = await fs5.readFile(schemaPath, "utf8");
+  const schemaPath = path3.resolve(cwd, source.path);
+  const raw = await fs4.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
     return parsed;
@@ -3010,7 +2939,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path4.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -3032,8 +2961,8 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path4.join(cwd, ".
       throw convert.error;
     }
   }
-  await fs5.mkdir(outputDir, { recursive: true });
-  await fs5.writeFile(path4.join(outputDir, "registry.json"), `${JSON.stringify(registry, null, 2)}
+  await fs4.mkdir(outputDir, { recursive: true });
+  await fs4.writeFile(path3.join(outputDir, "registry.json"), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
   return {
     commandCount: registry.reduce((count, group) => count + group.tools.length, 0),
@@ -3272,4 +3201,4 @@ export {
   wpTypiaCommands
 };
 
-//# debugId=844373B8B205795464756E2164756E21
+//# debugId=72FB605118CF0EEA64756E2164756E21