@devdogsuga/devtools 0.1.34 → 0.1.36

package/dist/{failure-log-BBPGejQv.js → failure-log-B5GG_8T1.js}

@@ -2,8 +2,103 @@ import { a as ownVersion } from "./root-C2OmZDwD.js";
 import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir, platform, release } from "node:os";
+//#region ../cli-core/src/args.ts
+/**
+* Positional arguments, with flag values excluded.
+*
+* Its own module because of one bug it prevents. The first positional is the
+* subcommand, and `pull`, `push` and `audit` do very different things to live
+* credentials. A naive `filter((a) => !a.startsWith("--"))` reads a flag's
+* VALUE as a positional, so `env --file notes.env audit` fails loudly:
+* `notes.env` is not a subcommand and the command refuses. The quiet version
+* is the one that matters:
+*
+*     env --file push audit
+*
+* which runs `push`, writing to Bitwarden and GitHub, when the caller asked
+* for `audit`, which writes nothing at all.
+*/
+/**
+* Flags that consume the token after them.
+*/
+const VALUE_FLAGS = /* @__PURE__ */ new Set([
+	"--access-token",
+	"--format",
+	"--out",
+	"--version",
+	"--app",
+	"--apps",
+	"--base-url",
+	"--file",
+	"--source",
+	"--target",
+	"--tier",
+	"--cron",
+	"--kind",
+	"--workflow",
+	"--params",
+	"--port",
+	"--preview-url",
+	"--db-url",
+	"--user",
+	"--filter",
+	"--shell"
+]);
+function positionals(argv) {
+	const found = [];
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (!arg.startsWith("-")) {
+			found.push(arg);
+			continue;
+		}
+		const next = argv[i + 1];
+		if (VALUE_FLAGS.has(arg) && next !== void 0 && !next.startsWith("-")) i += 1;
+	}
+	return found;
+}
+/**
+* The value after `flag`, or `undefined` when the flag is absent or is
+* followed by another flag instead of a value.
+*/
+function flagValue(rest, flag) {
+	const index = rest.indexOf(flag);
+	if (index === -1) return void 0;
+	const value = rest[index + 1];
+	return value && !value.startsWith("--") ? value : void 0;
+}
+//#endregion
 //#region ../cli-core/src/catalog.ts
 /**
+* The command catalog: types, shared option shapes and the lookups over a
+* composed tree.
+*
+* A CLI's command tree is data. Each domain declares its own commands in its
+* `catalog.ts` (names, summaries and option shapes, nothing that runs), the
+* CLI's `src/catalog.ts` composes those into groups, and `createCatalog`
+* wraps the result. Three readers consume it:
+*
+*   * `help.ts` renders it, one level at a time.
+*   * `menu.ts` walks its interactive commands and options without a second
+*     list to keep in step.
+*   * `completions.ts` enumerates it, and contributor documentation uses the
+*     same group and command vocabulary.
+*
+* It is deliberately inert: no imports of anything that runs (`args.ts` is
+* data too), so the launcher can read it (for `envFree`) before the session's
+* environment is entered.
+* The CLI's dispatcher owns the handlers, and the wizard turns a walk of this
+* tree into an argv and hands it to that same dispatcher, which keeps menu and
+* CLI behavior aligned by construction rather than by review.
+*
+* ## What a summary is for
+*
+* Every `summary` is one line and is the ONLY thing `--help` prints for a
+* command at the level above it. Rationale, target tables, credential lookup
+* order and deploy internals live in `docs/`, not here: `--help` is a map, and
+* a map that reprints the territory is the thing this replaced.
+*/
+/**
 * How each scope reads, in the two places that draw it.
 *
 * `menu` sits inline in a hint, so it is one word. `help` heads a block of
@@ -44,22 +139,54 @@ const YES = {
 	flag: "--yes",
 	summary: "Skip the confirmations."
 };
-function walk(roots, path) {
+/** The node a typed token names among `nodes`, by its name or an alias. */
+function named(nodes, token) {
+	for (const node of nodes) {
+		if (node.name === token) return { node };
+		const alias = node.aliases?.find((candidate) => candidate.name === token);
+		if (alias) return {
+			node,
+			alias
+		};
+	}
+}
+/** Each step of a path, resolved through aliases; `null` at the first miss. */
+function resolve$1(roots, path) {
 	let nodes = roots;
-	let found = null;
-	for (const name of path) {
-		const next = nodes.find((node) => node.name === name);
-		if (!next) return null;
-		found = next;
-		nodes = next.subcommands ?? [];
+	const steps = [];
+	for (const token of path) {
+		const step = named(nodes, token);
+		if (!step) return null;
+		steps.push(step);
+		nodes = step.node.subcommands ?? [];
+	}
+	return steps;
+}
+function walk(roots, path) {
+	return resolve$1(roots, path)?.at(-1)?.node ?? null;
+}
+/**
+* Refuses a tree where one token could name two siblings. An alias that
+* shadowed another command would make which one runs depend on declaration
+* order, the kind of thing nobody finds until it has run the wrong one.
+*/
+function assertUnambiguous(nodes, prefix) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		for (const token of [node.name, ...(node.aliases ?? []).map((a) => a.name)]) {
+			if (seen.has(token)) throw new Error(`Command tree: "${[...prefix, token].join(" ")}" names two commands.`);
+			seen.add(token);
+		}
+		assertUnambiguous(node.subcommands ?? [], [...prefix, node.name]);
 	}
-	return found;
 }
 function createCatalog(trees) {
 	const groups = trees.groups;
 	const ciGroups = trees.ciGroups ?? [];
 	const topLevel = groups.flatMap((group) => group.commands);
 	const ciTopLevel = ciGroups.flatMap((group) => group.commands);
+	assertUnambiguous(topLevel, []);
+	assertUnambiguous(ciTopLevel, []);
 	const subcommandNames = (path) => (walk(topLevel, path)?.subcommands ?? []).map((node) => node.name);
 	return {
 		usage: trees.usage,
@@ -71,6 +198,26 @@ function createCatalog(trees) {
 		findCommand: (path) => walk(topLevel, path),
 		findCiCommand: (path) => walk(ciTopLevel, path),
 		groupOf: (name) => groups.find((group) => group.commands.some((command) => command.name === name)),
+		canonicalPath: (path) => resolve$1(topLevel, path)?.map((step) => step.node.name) ?? null,
+		canonicalArgv: (argv) => {
+			const out = [...argv];
+			const implied = [];
+			let nodes = topLevel;
+			for (let i = 0; i < out.length; i += 1) {
+				const arg = out[i];
+				if (arg.startsWith("-")) {
+					const next = out[i + 1];
+					if (VALUE_FLAGS.has(arg) && next !== void 0 && !next.startsWith("-")) i += 1;
+					continue;
+				}
+				const step = named(nodes, arg);
+				if (!step) break;
+				out[i] = step.node.name;
+				implied.push(...step.alias?.implies ?? []);
+				nodes = step.node.subcommands ?? [];
+			}
+			return [...out, ...implied];
+		},
 		subcommandNames,
 		subcommandCiNames: (path) => (walk(ciTopLevel, path)?.subcommands ?? []).map((node) => node.name),
 		subcommandList: (path) => {
@@ -253,4 +400,4 @@ function installFailureLog(options) {
 	});
 }
 //#endregion
-export { cliName as a, YES as c, suppressFailureLog as i, createCatalog as l, noteError as n, JSON_FLAG as o, noteRan as r, SCOPES as s, installFailureLog as t };
+export { cliName as a, YES as c, positionals as d, suppressFailureLog as i, createCatalog as l, noteError as n, JSON_FLAG as o, noteRan as r, SCOPES as s, installFailureLog as t, flagValue as u };

package/dist/launch.js

@@ -1,9 +1,9 @@
-import { a as cliName, t as installFailureLog } from "./failure-log-BBPGejQv.js";
-import { C as catalog, S as unwrap, _ as setMenuEnvHook, d as nonEmpty, g as realEnvEntryDeps, h as enterSessionEnvironment, t as bareGroupStartPath, w as helpPath, y as errorMessage } from "./menu-DnqlX22U.js";
-import { b as setDryRun, m as formatCommand, v as isDryRun, y as resolveDryRun } from "./supabase-project-0knM0mqd.js";
+import { a as cliName, t as installFailureLog } from "./failure-log-B5GG_8T1.js";
+import { C as helpPath, S as catalog, g as setMenuEnvHook, h as realEnvEntryDeps, m as enterSessionEnvironment, n as bareGroupStartPath, u as nonEmpty, v as errorMessage, x as unwrap } from "./menu-C7gh8v-s.js";
+import { b as setDryRun, m as formatCommand, v as isDryRun, y as resolveDryRun } from "./supabase-project-B7JMicl-.js";
 import { n as discoverRepoRoot, r as findRepoRoot, t as RepoNotFoundError } from "./root-C2OmZDwD.js";
 import { i as loadEnvSession, r as loadEnvLoad } from "./peers-RBplwovA.js";
-import { d as hasYes, f as isNonInteractive, m as stripTierFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as stripNoEnvFlag, s as lastSentryEventId } from "./telemetry-El7OainP.js";
+import { d as hasYes, f as isNonInteractive, m as stripTierFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as stripNoEnvFlag, s as lastSentryEventId } from "./telemetry-Do13RFhc.js";
 import { confirm, select } from "@clack/prompts";
 //#region ../cli-core/src/session.ts
 /**
@@ -155,7 +155,7 @@ function skipsEnvEntry(rest) {
 /** The offer's stack start (`env-entry.ts` holds the TTY prompt, this holds
 * the lifecycle command), imported lazily like the rest of the commands. */
 async function startStack() {
-	const { runStackCommand } = await import("./stack-Bx-55oi_.js");
+	const { runStackCommand } = await import("./stack-CKiRU68w.js");
 	return runStackCommand("start");
 }
 /**
@@ -166,7 +166,7 @@ async function startStack() {
 * post-tier-resolution path.
 */
 async function dispatch(argv) {
-	const { main } = await import("./cli-Bb-Lzg-l.js");
+	const { main } = await import("./cli-DvADNoml.js");
 	try {
 		await main(argv);
 	} catch (err) {