wp-typia 0.21.0 → 0.22.0

package/bin/routing-metadata.generated.d.ts

@@ -2,5 +2,7 @@
 // Do not edit directly.
 
 export declare const fullRuntimeCommands: readonly string[];
+export declare const interactiveRuntimeCommands: readonly string[];
 export declare const longValueOptions: readonly string[];
+export declare const reservedCommands: readonly string[];
 export declare const shortValueOptions: readonly string[];

package/bin/routing-metadata.generated.js

@@ -7,6 +7,11 @@ export const fullRuntimeCommands = Object.freeze([
   'completions',
   'complete',
 ]);
+export const interactiveRuntimeCommands = Object.freeze([
+  'create',
+  'add',
+  'migrate',
+]);
 export const longValueOptions = Object.freeze([
   '--alternate-render-targets',
   '--anchor',
@@ -41,4 +46,19 @@ export const longValueOptions = Object.freeze([
   '--to-migration-version',
   '--variant',
 ]);
+export const reservedCommands = Object.freeze([
+  'create',
+  'init',
+  'sync',
+  'add',
+  'migrate',
+  'templates',
+  'doctor',
+  'mcp',
+  'help',
+  'version',
+  'skills',
+  'completions',
+  'complete',
+]);
 export const shortValueOptions = Object.freeze(['-c', '-p', '-t']);

package/bin/runtime-routing.d.ts

@@ -0,0 +1,34 @@
+type RuntimeRoutingValues = readonly string[] | ReadonlySet<string>;
+
+type RuntimeRoutingMetadata = {
+  longValueOptions: RuntimeRoutingValues;
+  reservedCommands: RuntimeRoutingValues;
+  shortValueOptions: RuntimeRoutingValues;
+};
+
+type RuntimeRoutingStream = {
+  isTTY?: boolean;
+};
+
+export declare function getRuntimeRoutingInvocation(
+  argv: readonly string[],
+  metadata: RuntimeRoutingMetadata,
+): {
+  command: string | undefined;
+  isSinglePositionalAlias: boolean;
+  positionals: string[];
+};
+
+export declare function shouldRouteToFullRuntime(options: {
+  argv: readonly string[];
+  fullRuntimeCommands: RuntimeRoutingValues;
+  hasBuiltRuntime: boolean;
+  hasWorkingBun: boolean;
+  interactiveRuntimeCommands: RuntimeRoutingValues;
+  longValueOptions: RuntimeRoutingValues;
+  reservedCommands: RuntimeRoutingValues;
+  shortValueOptions: RuntimeRoutingValues;
+  stdin?: RuntimeRoutingStream;
+  stdout?: RuntimeRoutingStream;
+  term?: string;
+}): boolean;

package/bin/runtime-routing.js

@@ -0,0 +1,124 @@
+import { collectPositionalIndexes } from './argv-walker.js';
+
+function normalizeSet(values) {
+  return values instanceof Set ? values : new Set(values);
+}
+
+function hasBooleanFlagBeforeTerminator(argv, longFlag, shortFlag) {
+  let matched = false;
+  for (const arg of argv) {
+    if (arg === '--') {
+      break;
+    }
+    if (arg === longFlag || (shortFlag && arg === shortFlag)) {
+      matched = true;
+      continue;
+    }
+    if (arg.startsWith(`${longFlag}=`)) {
+      const value = arg.slice(longFlag.length + 1).toLowerCase();
+      matched = value !== 'false' && value !== '0' && value !== 'no';
+    }
+  }
+
+  return matched;
+}
+
+function hasLongOptionBeforeTerminator(argv, optionName) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--') {
+      return false;
+    }
+    if (arg === optionName || arg.startsWith(`${optionName}=`)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isInteractiveTerminal({ stdin, stdout, term }) {
+  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== 'dumb';
+}
+
+export function getRuntimeRoutingInvocation(argv, metadata) {
+  const positionalIndexes = collectPositionalIndexes(argv, metadata);
+  const positionals = positionalIndexes
+    .map((index) => argv[index])
+    .filter((value) => typeof value === 'string' && value.length > 0);
+  const command = positionals[0];
+  const reservedCommandSet = normalizeSet(metadata.reservedCommands);
+  const isSinglePositionalAlias =
+    Boolean(command) &&
+    positionals.length === 1 &&
+    !reservedCommandSet.has(command);
+
+  return {
+    command,
+    isSinglePositionalAlias,
+    positionals,
+  };
+}
+
+export function shouldRouteToFullRuntime({
+  argv,
+  fullRuntimeCommands,
+  hasBuiltRuntime,
+  hasWorkingBun,
+  interactiveRuntimeCommands,
+  longValueOptions,
+  reservedCommands,
+  shortValueOptions,
+  stdin = process.stdin,
+  stdout = process.stdout,
+  term = process.env.TERM,
+}) {
+  if (!hasWorkingBun || !hasBuiltRuntime) {
+    return false;
+  }
+
+  const fullRuntimeCommandSet = normalizeSet(fullRuntimeCommands);
+  const interactiveRuntimeCommandSet = normalizeSet(interactiveRuntimeCommands);
+  const invocation = getRuntimeRoutingInvocation(argv, {
+    longValueOptions,
+    reservedCommands,
+    shortValueOptions,
+  });
+
+  if (invocation.command && fullRuntimeCommandSet.has(invocation.command)) {
+    return true;
+  }
+
+  if (
+    !isInteractiveTerminal({
+      stdin,
+      stdout,
+      term,
+    })
+  ) {
+    return false;
+  }
+
+  if (
+    invocation.command === 'help' ||
+    invocation.command === 'version' ||
+    hasBooleanFlagBeforeTerminator(argv, '--help', '-h') ||
+    hasBooleanFlagBeforeTerminator(argv, '--version', '-v') ||
+    hasLongOptionBeforeTerminator(argv, '--format') ||
+    hasBooleanFlagBeforeTerminator(argv, '--yes', '-y')
+  ) {
+    return false;
+  }
+
+  if (
+    invocation.command &&
+    interactiveRuntimeCommandSet.has(invocation.command)
+  ) {
+    return true;
+  }
+
+  return (
+    invocation.isSinglePositionalAlias &&
+    interactiveRuntimeCommandSet.has('create')
+  );
+}

package/bin/wp-typia.js

@@ -7,10 +7,15 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import {
   fullRuntimeCommands,
+  interactiveRuntimeCommands,
   longValueOptions,
+  reservedCommands,
   shortValueOptions,
 } from './routing-metadata.generated.js';
-import { findFirstPositional } from './argv-walker.js';
+import {
+  getRuntimeRoutingInvocation,
+  shouldRouteToFullRuntime,
+} from './runtime-routing.js';
 
 const packageRoot = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
@@ -20,7 +25,9 @@ const cliEntrypoint = path.join(packageRoot, 'dist-bunli', 'cli.js');
 const nodeCliEntrypoint = path.join(packageRoot, 'dist-bunli', 'node-cli.js');
 const bunBinary = process.env.BUN_BIN || 'bun';
 const fullRuntimeCommandSet = new Set(fullRuntimeCommands);
+const interactiveRuntimeCommandSet = new Set(interactiveRuntimeCommands);
 const longValueOptionSet = new Set(longValueOptions);
+const reservedCommandSet = new Set(reservedCommands);
 const shortValueOptionSet = new Set(shortValueOptions);
 const buildScriptEntrypoint = path.join(
   packageRoot,
@@ -69,17 +76,29 @@ function ensureBuiltRuntime() {
 }
 
 const argv = process.argv.slice(2);
-const command = findFirstPositional(argv, {
+const { command } = getRuntimeRoutingInvocation(argv, {
   longValueOptions: longValueOptionSet,
+  reservedCommands: reservedCommandSet,
   shortValueOptions: shortValueOptionSet,
 });
-const shouldUseFullRuntime = command
+const commandRequiresFullRuntime = command
   ? fullRuntimeCommandSet.has(command)
   : false;
 const hasBuiltRuntime = ensureBuiltRuntime();
 const hasWorkingBun = isWorkingBunBinary();
+const shouldUseFullRuntime = shouldRouteToFullRuntime({
+  argv,
+  fullRuntimeCommands: fullRuntimeCommandSet,
+  hasBuiltRuntime,
+  hasWorkingBun,
+  interactiveRuntimeCommands: interactiveRuntimeCommandSet,
+  longValueOptions: longValueOptionSet,
+  reservedCommands: reservedCommandSet,
+  shortValueOptions: shortValueOptionSet,
+});
 
-// Keep common help on the human-readable Node fallback even when Bun is present.
+// Keep common help and explicit non-TUI calls on the human-readable Node fallback
+// even when Bun is present.
 if (hasWorkingBun && hasBuiltRuntime && shouldUseFullRuntime) {
   const result = spawnSync(bunBinary, [cliEntrypoint, ...argv], {
     cwd: process.cwd(),
@@ -89,7 +108,7 @@ if (hasWorkingBun && hasBuiltRuntime && shouldUseFullRuntime) {
   process.exit(result.status ?? 1);
 }
 
-if (shouldUseFullRuntime) {
+if (commandRequiresFullRuntime) {
   if (!hasBuiltRuntime) {
     console.error(
       'Error: wp-typia could not locate its built CLI runtime. Reinstall the published package, or run `bun run build` when using a source checkout.',