politty 0.6.0 → 0.7.0

package/dist/{runner--Zn4KN9B.js → runner-D43SkHt5.js}

@@ -1848,28 +1848,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
@@ -2331,6 +2364,25 @@ async function runMain(command, options = {}) {
 		effectiveOptions = rest;
 	}
 	const globalExtracted = extractAndValidateGlobal(effectiveOptions);
+	if (effectiveOptions.onUnknownSubcommand && !isInternalSubcommandInvocation(command, argv, globalExtractedForBypass)) {
+		const knownSubCommands = 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) {
@@ -2348,6 +2400,7 @@ async function runMain(command, options = {}) {
 		logger: effectiveOptions.logger,
 		globalArgs: effectiveOptions.globalArgs,
 		prompt: effectiveOptions.prompt,
+		onUnknownSubcommand: effectiveOptions.onUnknownSubcommand,
 		_globalExtracted: globalExtracted,
 		_globalCleanup: effectiveOptions.cleanup,
 		_context: {
@@ -2364,11 +2417,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 = {}) {
@@ -2392,6 +2456,43 @@ async function runCommandInternal(command, argv, options = {}) {
 			...options._parsedGlobalArgs,
 			...parseResult.rawGlobalArgs
 		};
+		const nestedCommandPath = context.commandPath ?? [];
+		if (options.onUnknownSubcommand && nestedCommandPath.length > 0) {
+			const knownSubCommands = 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 = listSubCommands(command);
@@ -2604,4 +2705,4 @@ function extractAndValidateGlobal(options) {
 
 //#endregion
 export { renderMarkdown as C, styles as D, setColorEnabled as E, symbols as O, renderInline as S, logger as T, DuplicateFieldError as _, parseArgv as a, ReservedAliasError as b, validateCommand as c, validateDuplicateFields as d, validateDuplicateNegations as f, DuplicateAliasError as g, CaseVariantCollisionError as h, formatValidationErrors as i, createDualCaseProxy as k, validateCrossSchemaCollisions as l, validateReservedAliases as m, runMain as n, formatCommandValidationErrors as o, validatePositionalConfig as p, runner_exports as r, validateCaseVariantCollisions as s, runCommand as t, validateDuplicateAliases as u, DuplicateNegationError as v, isColorEnabled as w, generateHelp as x, PositionalConfigError as y };
-//# sourceMappingURL=runner--Zn4KN9B.js.map
+//# sourceMappingURL=runner-D43SkHt5.js.map