politty 0.6.0 → 0.8.0

package/dist/{runner-BloFWJEB.cjs → runner-DvFvokV6.cjs}

@@ -1832,28 +1832,61 @@ const BUILTIN_FLAGS = new Set([
 	"--version"
 ]);
 /**
-* Find the first positional argument in argv, properly skipping global flag values.
-* Without globalExtracted, falls back to the first non-flag token.
-*/
-function findFirstPositional(argv, globalExtracted) {
-	if (!globalExtracted) return argv.find((arg) => !arg.startsWith("-"));
-	const lookup = buildGlobalFlagLookup(globalExtracted);
+* Find the index of the first positional argument in argv, properly skipping
+* global flag values. Returns -1 when no positional is present.
+*
+* Mirrors `scanForSubcommand`'s conservative stop conditions: the scan stops
+* (returning -1) on a `--` terminator, a builtin flag (`--help`/`--version`),
+* an unknown long flag, or an unknown/combined short flag. Past such tokens we
+* can't tell a flag *value* from a positional, so continuing would misclassify
+* e.g. `--help plugin` or `--unknown value` and wrongly trip plugin dispatch.
+*
+* Without globalExtracted, no flag is global, so any leading flag halts the
+* scan and a positional is only found when it precedes every flag.
+*/
+function findFirstPositionalIndex(argv, globalExtracted) {
+	const lookup = globalExtracted ? buildGlobalFlagLookup(globalExtracted) : {
+		aliasMap: /* @__PURE__ */ new Map(),
+		booleanFlags: /* @__PURE__ */ new Set(),
+		flagNames: /* @__PURE__ */ new Set(),
+		cliNames: /* @__PURE__ */ new Set(),
+		aliases: /* @__PURE__ */ new Set(),
+		negationMap: /* @__PURE__ */ new Map(),
+		customNegatedFields: /* @__PURE__ */ new Set()
+	};
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
-		if (!arg.startsWith("-")) return arg;
-		if (arg === "--") return void 0;
+		if (!arg.startsWith("-")) return i;
+		if (arg === "--" || BUILTIN_FLAGS.has(arg)) return -1;
 		if (arg.startsWith("--")) {
-			const { resolvedName, isNegated, isGlobal } = resolveGlobalLongOption(arg, lookup);
-			if (isGlobal && shouldConsumeValue(arg, resolvedName, isNegated, argv[i + 1], lookup.booleanFlags)) i++;
-			continue;
+			const { resolvedName, isNegated, isGlobal, isSuppressedNegation } = resolveGlobalLongOption(arg, lookup);
+			if (isGlobal) {
+				if (shouldConsumeValue(arg, resolvedName, isNegated, argv[i + 1], lookup.booleanFlags)) i++;
+				continue;
+			}
+			if (isSuppressedNegation) continue;
+			return -1;
 		}
-		if (arg.length === 2) {
-			const ch = arg[1];
-			if (lookup.aliases.has(ch)) {
-				if (shouldConsumeValue(arg, lookup.aliasMap.get(ch) ?? ch, false, argv[i + 1], lookup.booleanFlags)) i++;
+		const withoutDash = arg.includes("=") ? arg.slice(1, arg.indexOf("=")) : arg.slice(1);
+		if (withoutDash.length === 1) {
+			const resolvedName = lookup.aliasMap.get(withoutDash) ?? withoutDash;
+			if (lookup.aliases.has(withoutDash) || lookup.flagNames.has(resolvedName)) {
+				if (shouldConsumeValue(arg, resolvedName, false, argv[i + 1], lookup.booleanFlags)) i++;
+				continue;
 			}
 		}
+		return -1;
 	}
+	return -1;
+}
+/**
+* Find the first positional argument in argv, properly skipping global flag
+* values. Thin wrapper over {@link findFirstPositionalIndex} — see that
+* function for the scan and stop conditions. Returns `undefined` when none.
+*/
+function findFirstPositional(argv, globalExtracted) {
+	const index = findFirstPositionalIndex(argv, globalExtracted);
+	return index >= 0 ? argv[index] : void 0;
 }
 
 //#endregion
@@ -2315,6 +2348,25 @@ async function runMain(command, options = {}) {
 		effectiveOptions = rest;
 	}
 	const globalExtracted = extractAndValidateGlobal(effectiveOptions);
+	if (effectiveOptions.onUnknownSubcommand && !isInternalSubcommandInvocation(command, argv, globalExtractedForBypass)) {
+		const knownSubCommands = require_schema_extractor.listSubCommandNamesWithAliases(command);
+		if (knownSubCommands.size > 0) {
+			const positionalIndex = findFirstPositionalIndex(argv, globalExtracted);
+			const name = positionalIndex >= 0 ? argv[positionalIndex] : void 0;
+			if (name && !knownSubCommands.has(name)) {
+				const forwardArgs = argv.slice(positionalIndex + 1);
+				const exitCode = await effectiveOptions.onUnknownSubcommand({
+					commandPath: [],
+					name,
+					args: forwardArgs
+				});
+				if (typeof exitCode === "number") {
+					await flushStandardStreams();
+					return process.exit(exitCode);
+				}
+			}
+		}
+	}
 	if (effectiveOptions.setup) try {
 		await effectiveOptions.setup({});
 	} catch (e) {
@@ -2332,6 +2384,7 @@ async function runMain(command, options = {}) {
 		logger: effectiveOptions.logger,
 		globalArgs: effectiveOptions.globalArgs,
 		prompt: effectiveOptions.prompt,
+		onUnknownSubcommand: effectiveOptions.onUnknownSubcommand,
 		_globalExtracted: globalExtracted,
 		_globalCleanup: effectiveOptions.cleanup,
 		_context: {
@@ -2348,11 +2401,22 @@ async function runMain(command, options = {}) {
 			await effectiveOptions.cleanup(cleanupCtx);
 		} catch {}
 	}
-	if (process.stdout.writableLength > 0) await new Promise((resolve) => process.stdout.once("drain", resolve));
-	if (process.stderr.writableLength > 0) await new Promise((resolve) => process.stderr.once("drain", resolve));
+	await flushStandardStreams();
 	process.exit(result.exitCode);
 }
 /**
+* Flush stdout/stderr before exit to prevent truncated output when piped
+* (pipe writes are buffered asynchronously, so exiting early loses data).
+*
+* We await a zero-byte write's callback rather than a `drain` event: `drain`
+* only fires after a `write()` returned `false` (backpressure), so buffered
+* writes that never tripped it would hang. The write callback is ordered after
+* all pending writes, so it resolves once the buffer is flushed.
+*/
+async function flushStandardStreams() {
+	await Promise.all([process.stdout, process.stderr].map((stream) => stream.writableLength > 0 ? new Promise((resolve) => stream.write("", () => resolve())) : Promise.resolve()));
+}
+/**
 * Internal implementation of command running
 */
 async function runCommandInternal(command, argv, options = {}) {
@@ -2376,6 +2440,43 @@ async function runCommandInternal(command, argv, options = {}) {
 			...options._parsedGlobalArgs,
 			...parseResult.rawGlobalArgs
 		};
+		const nestedCommandPath = context.commandPath ?? [];
+		if (options.onUnknownSubcommand && nestedCommandPath.length > 0) {
+			const knownSubCommands = require_schema_extractor.listSubCommandNamesWithAliases(command);
+			if (knownSubCommands.size > 0) {
+				const positionalIndex = findFirstPositionalIndex(argv, options._globalExtracted);
+				const name = positionalIndex >= 0 ? argv[positionalIndex] : void 0;
+				if (name && !knownSubCommands.has(name)) {
+					const forwardArgs = argv.slice(positionalIndex + 1);
+					const exitCode = await options.onUnknownSubcommand({
+						commandPath: nestedCommandPath,
+						name,
+						args: forwardArgs
+					});
+					if (typeof exitCode === "number") {
+						collector?.stop();
+						if (options.handleSignals) {
+							if (options._globalCleanup) try {
+								await options._globalCleanup({ error: void 0 });
+							} catch {}
+							await flushStandardStreams();
+							process.exit(exitCode);
+						}
+						return exitCode === 0 ? {
+							success: true,
+							result: void 0,
+							exitCode: 0,
+							logs: getCurrentLogs()
+						} : {
+							success: false,
+							error: /* @__PURE__ */ new Error(`Plugin "${[...nestedCommandPath, name].join(" ")}" exited with code ${exitCode}`),
+							exitCode,
+							logs: getCurrentLogs()
+						};
+					}
+				}
+			}
+		}
 		if (parseResult.helpRequested || parseResult.helpAllRequested) {
 			let hasUnknownSubcommand = false;
 			const subCmdNames = require_schema_extractor.listSubCommands(command);
@@ -2761,4 +2862,4 @@ Object.defineProperty(exports, 'validateReservedAliases', {
     return validateReservedAliases;
   }
 });
-//# sourceMappingURL=runner-BloFWJEB.cjs.map
+//# sourceMappingURL=runner-DvFvokV6.cjs.map