wp-typia 0.22.3 → 0.22.5

package/dist-bunli/{command-list-wzej5c7v.js → command-list-scd6zqp8.js}

@@ -18,7 +18,7 @@ import {
   package_default,
   prefersStructuredCliOutput,
   resolveCommandOptionValues
-} from "./cli-mpgt29xc.js";
+} from "./cli-nzwpmw4y.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
@@ -206,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: {
@@ -312,7 +327,8 @@ var ADD_KIND_REGISTRY = {
       const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
       const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
       const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
-      let resolvedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
+      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) => ({
@@ -828,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-");
@@ -848,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",
@@ -1097,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 {
@@ -1132,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, {
@@ -1197,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",
@@ -1215,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" ? {
@@ -1298,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;
     }
@@ -1443,14 +1380,14 @@ async function executeSyncCommand({
 }
 
 // src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("./cli-add-p3re8act.js");
+var loadCliAddRuntime = () => import("./cli-add-1gqgshf0.js");
 var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-5dvztm7q.js");
-var loadCliDoctorRuntime = () => import("./cli-doctor-cjm4rzbk.js");
-var loadCliInitRuntime = () => import("./cli-init-7gcthyn1.js");
+var loadCliDoctorRuntime = () => import("./cli-doctor-w35s8y9w.js");
+var loadCliInitRuntime = () => import("./cli-init-z8sjmkvc.js");
 var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-x1dp8sz1.js");
+var loadCliScaffoldRuntime = () => import("./cli-scaffold-ad3bd555.js");
 var loadCliTemplatesRuntime = () => import("./cli-templates-9t2a7zqd.js");
-var loadMigrationsRuntime = () => import("./migrations-xfb2h7nf.js");
+var loadMigrationsRuntime = () => import("./migrations-skkzdvhm.js");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError } = await loadCliDiagnosticsRuntime();
   return createCliCommandError({ command, error });
@@ -2398,7 +2335,7 @@ var doctorCommand = defineCommand({
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     if (prefersStructuredOutput) {
       const [{ getDoctorChecks }, { getDoctorFailureDetailLines }] = await Promise.all([
-        import("./cli-doctor-cjm4rzbk.js"),
+        import("./cli-doctor-w35s8y9w.js"),
         import("./cli-diagnostics-5dvztm7q.js")
       ]);
       const checks = await getDoctorChecks(args.cwd);
@@ -2456,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")() {
@@ -2476,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());
@@ -2491,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);
@@ -2546,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
       })
@@ -2603,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;
       }
@@ -2631,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;
     }
@@ -2653,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;
     }
@@ -2664,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")
     }));
   }
@@ -2985,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;
@@ -3002,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,
@@ -3024,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),
@@ -3264,4 +3201,4 @@ export {
   wpTypiaCommands
 };
 
-//# debugId=73FFE6511B0A672B64756E2164756E21
+//# debugId=72FB605118CF0EEA64756E2164756E21

package/dist-bunli/{migrations-xfb2h7nf.js → migrations-skkzdvhm.js}

@@ -15,12 +15,12 @@ import {
   snapshotProjectVersion,
   verifyProjectMigrations,
   wizardProjectMigrations
-} from "./cli-prc42zqd.js";
-import"./cli-gcbre1zs.js";
+} from "./cli-xbzfx7qz.js";
+import"./cli-hb9vpsev.js";
 import"./cli-bq2v559b.js";
-import"./cli-sj5mtyzj.js";
-import"./cli-x0h03qqe.js";
-import"./cli-pd5pqgre.js";
+import"./cli-j30rk466.js";
+import"./cli-btbpt84c.js";
+import"./cli-6bhfzq5e.js";
 import"./cli-xnn9xjcy.js";
 export {
   wizardProjectMigrations,