@pho9ubenaa/siro 0.2.0 → 0.4.0

package/dist/cli.mjs

@@ -1,215 +1,134 @@
 #!/usr/bin/env node
-import { C as isPM, E as UsageError, O as SiroError, S as SEVERITIES, k as asAbsPath, m as BUILTIN_REPORTER_NAMES, n as lintCommand, p as isNodeError, t as nodeIO, v as version, w as isSeverity, x as PMS } from "./node-io-Cb8nixgE.mjs";
+import { C as SUPPORTED_NODE_RANGE, D as isNodeError, M as UsageError, O as asAbsPath, S as isSeverity, T as assertDirectory, _ as PROJECT_TYPES, b as SEVERITIES, c as DEFAULT_REPORTER_NAME, f as version, j as SiroError, l as JSON_REPORTER_NAME, m as loadConfig, n as lintCommand, s as BUILTIN_REPORTER_NAMES, t as nodeIO, v as isProjectType, w as isSupportedNodeVersion, x as isPM, y as PMS } from "./node-io-BdyNbvzO.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { cac } from "cac";
-
-//#region src/cli/commands.ts
-/**
-* Canonical list of siro CLI sub-commands. Shared between `cli.ts` (the
-* dispatcher / arg parser) and `cli/help.ts` (the help-text renderer) so a
-* new command added here propagates to both via the derived `CommandName`
-* union — there is no second place to remember to update.
-*/
-const COMMANDS = ["lint", "check"];
-const isCommandName = (value) => COMMANDS.some((cmd) => cmd === value);
-
-//#endregion
-//#region src/cli/flags.ts
-const ARGS_OFFSET$1 = 2;
-/** Flags that consume the following argv token; pre-cac scanners skip that token. */
-const VALUE_FLAGS = new Set(Object.entries({
-	json: { takesValue: false },
-	pm: { takesValue: true },
-	reporter: { takesValue: true },
-	severity: { takesValue: true }
-}).filter(([, meta]) => meta.takesValue).map(([name]) => name));
-const LINT_FLAGS = [
-	"pm",
-	"reporter",
-	"json",
-	"severity"
-];
-const FLAG_SCOPES = {
-	check: LINT_FLAGS,
-	lint: LINT_FLAGS
-};
-const GLOBAL_FLAGS = ["version", "help"];
-const CAC_KEYS = [
-	"v",
-	"h",
-	"--"
-];
-const flagsFor = (command) => new Set([
-	...FLAG_SCOPES[command],
-	...GLOBAL_FLAGS,
-	...CAC_KEYS
-]);
-const collectAllFlags = () => {
-	const all = [];
-	for (const command of COMMANDS) for (const flag of flagsFor(command)) all.push(flag);
-	return new Set(all);
-};
-const KNOWN_FLAGS = collectAllFlags();
-/**
-* Whether a `--name value` flag consumes the following argv token. Only the
-* separate-token form of a value-taking flag does (`--name=value` carries its
-* own value), AND only when the next token isn't itself a `-`-prefixed flag —
-* so `--reporter --help` leaves `--help` for the help/version detectors rather
-* than eating it as the reporter value. Shared by both pre-cac scanners so the
-* skip predicate stays in one place.
-*/
-const consumesNext = (token, next) => token.startsWith("--") && !token.includes("=") && VALUE_FLAGS.has(token.slice(ARGS_OFFSET$1)) && typeof next !== "undefined" && !next.startsWith("-");
-
-//#endregion
-//#region src/cli/scanners.ts
-const STEP$1 = 1;
-const isHelpFlag = (token) => token === "--help" || token === "-h";
-const processHelpToken = (token, next, state) => {
-	if (token === "--") return "break";
-	if (isHelpFlag(token)) state.asksHelp = true;
-	else if (consumesNext(token, next)) state.index += STEP$1;
-	else if (!token.startsWith("-") && state.first === "") state.first = token;
-	return "continue";
-};
-const scanHelpTokens = (argv) => {
-	const state = {
-		asksHelp: false,
-		first: "",
-		index: 0
-	};
-	for (; state.index < argv.length; state.index += STEP$1) {
-		const token = argv[state.index];
-		if (typeof token === "string" && processHelpToken(token, argv[state.index + STEP$1], state) === "break") break;
-	}
-	return {
-		asksHelp: state.asksHelp,
-		first: state.first || [].pop()
-	};
-};
-const resolveTarget = (first) => {
-	if (typeof first !== "undefined" && isCommandName(first)) return first;
-};
-/**
-* Detect a --help / -h flag in argv before cac sees it (cac would otherwise
-* write to console.log itself). Returns the target command (when the first
-* positional names one) or 'root' for the top-level help.
-*/
-const detectHelpFlag = (argv) => {
-	const { asksHelp, first } = scanHelpTokens(argv);
-	if (!asksHelp) return [].pop();
-	return { target: resolveTarget(first) };
-};
-/**
-* Detect `--version` / `-v` ahead of cac for the same reason `detectHelpFlag`
-* exists. The `--` separator stops the scan so a trailing `--version` is left
-* for the (rejected) passthrough handler rather than flipping to the version
-* branch — siro forwards to no wrapped tool, so non-empty passthrough is a
-* usage error (see parseArgs).
-*/
-const detectVersionFlag = (argv) => {
-	for (let index = 0; index < argv.length; index += STEP$1) {
-		const token = argv[index];
-		if (typeof token === "string") {
-			if (token === "--") return false;
-			if (token === "--version" || token === "-v") return true;
-			if (consumesNext(token, argv[index + STEP$1])) index += STEP$1;
-		}
-	}
-	return false;
-};
-
-//#endregion
+import { parseArgs } from "node:util";
 //#region src/cli/parsers.ts
-const FIRST_INDEX$1 = 0;
-const MIN_NODE_MAJOR = 20;
-const rejectUnknownFlags = (flags, allowed, scope) => {
-	for (const key of Object.keys(flags)) if (!allowed.has(key)) {
-		let where = "";
-		if (scope) where = ` for '${scope}'`;
-		throw new UsageError(`Unknown flag${where}: --${key}`);
-	}
-};
 const parsePmFlag = (raw) => {
 	if (typeof raw === "undefined") return;
 	if (raw === true) throw new UsageError(`--pm requires a value (expected one of: ${PMS.join(", ")})`);
 	if (typeof raw !== "string" || !isPM(raw)) throw new UsageError(`Unknown package manager: ${raw} (expected one of: ${PMS.join(", ")})`);
 	return raw;
 };
+const parseProjectTypeFlag = (raw) => {
+	if (typeof raw === "undefined") return;
+	if (raw === true) throw new UsageError(`--project-type requires a value (expected ${PROJECT_TYPES.join("|")})`);
+	if (typeof raw === "string" && isProjectType(raw)) return raw;
+	throw new UsageError(`Unknown project type: ${String(raw)} (expected ${PROJECT_TYPES.join("|")})`);
+};
 const parseSeverityFlag = (raw) => {
 	if (typeof raw === "undefined") return;
 	if (raw === true) throw new UsageError(`--severity requires a value (expected ${SEVERITIES.join("|")})`);
 	if (typeof raw !== "string" || !isSeverity(raw)) throw new UsageError(`Invalid severity: ${String(raw)} (expected ${SEVERITIES.join("|")})`);
 	return raw;
 };
-const resolveReporter = (flags) => {
-	if (flags.reporter === true) throw new UsageError(`--reporter requires a value (expected one of: ${BUILTIN_REPORTER_NAMES.join(", ")}, or a reporter registered via siro.config.ts)`);
-	if (typeof flags.reporter === "string") {
-		if (flags.json === true) throw new UsageError("Use either --reporter or --json, not both.");
-		return flags.reporter;
-	}
-	if (flags.json === true) return "json";
-	return "pretty";
-};
 const ensureNodeVersion = (nodeVersion) => {
-	const major = Number(nodeVersion.replace(/^v/u, "").split(".")[FIRST_INDEX$1]);
-	if (Number.isFinite(major) && major < MIN_NODE_MAJOR) throw new UsageError(`Node ${MIN_NODE_MAJOR}+ required (you are on ${nodeVersion}). Upgrade your runtime to use siro.`);
+	if (!isSupportedNodeVersion(nodeVersion)) throw new UsageError(`Node ${SUPPORTED_NODE_RANGE} required (you are on ${nodeVersion}). Upgrade your runtime to use siro.`);
 };
-
 //#endregion
-//#region src/cli/cac-bridge.ts
-const FIRST_INDEX = 0;
-const STEP = 1;
-const ARGS_OFFSET = 2;
-const buildCli = () => {
-	const cli = cac("siro");
-	cli.option("--pm <name>", "Target a specific package manager").option("--reporter <name>", `Reporter (${BUILTIN_REPORTER_NAMES.join("|")})`).option("--json", "Shortcut for --reporter json").option("--severity <level>", `Display/fail threshold (${SEVERITIES.join("|")})`).help().version(version);
-	for (const name of COMMANDS) {
-		let desc = `${name} a repository`;
-		if (name === "check") desc = "Alias of lint";
-		cli.command(`${name} [cwd]`, desc);
+//#region src/cli/commands.ts
+const COMMANDS = ["lint", "check"];
+const isCommandName = (value) => COMMANDS.some((cmd) => cmd === value);
+//#endregion
+//#region src/cli/parse-args.ts
+const VALUE_FLAGS = new Set([
+	"pm",
+	"project-type",
+	"reporter",
+	"severity"
+]);
+const BOOLEAN_FLAGS = new Set([
+	"help",
+	"version",
+	"json"
+]);
+const parseCommand = (argv) => {
+	const { tokens } = parseArgs({
+		args: [...argv],
+		options: {
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			version: {
+				type: "boolean",
+				short: "v"
+			}
+		},
+		strict: false,
+		tokens: true
+	});
+	const flags = /* @__PURE__ */ new Map();
+	const positionals = [];
+	let error;
+	for (let index = 0; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (!token) break;
+		if (token.kind === "option-terminator") {
+			if (index + 1 < tokens.length) error ??= "siro takes no passthrough arguments after `--`.";
+			break;
+		}
+		if (token.kind === "positional") {
+			positionals.push(token.value);
+			continue;
+		}
+		if (BOOLEAN_FLAGS.has(token.name)) if (token.value !== void 0) error ??= `Flag ${token.rawName} does not accept a value.`;
+		else {
+			if (token.name === "json" && flags.has("json")) error ??= "--json must be specified only once.";
+			flags.set(token.name, true);
+		}
+		else if (VALUE_FLAGS.has(token.name)) {
+			let value = token.value;
+			const next = tokens[index + 1];
+			if (value === void 0 && next?.kind === "positional" && next.index === token.index + 1) {
+				value = next.value;
+				index += 1;
+			}
+			if (value === void 0 || value === "") error ??= `${token.rawName} requires a value.`;
+			else {
+				if (flags.has(token.name)) error ??= `${token.rawName} must be specified only once.`;
+				flags.set(token.name, value);
+			}
+		} else error ??= `Unknown flag: ${token.rawName}`;
 	}
-	return cli;
-};
-const extractPositionalCwd = (matchedCommand, args) => {
-	if (matchedCommand) return args[FIRST_INDEX];
-	return args[STEP];
-};
-const extractCommandCandidate = (matchedCommand, args) => {
-	if (matchedCommand) return matchedCommand;
-	return args[FIRST_INDEX];
-};
-const extractExtraPositionals = (matchedCommand, args) => {
-	if (matchedCommand) return args.slice(STEP);
-	return args.slice(ARGS_OFFSET);
-};
-const parseCacOutput = (argv) => {
-	const cli = buildCli();
-	const parsed = cli.parse([
-		"node",
-		"siro",
-		...argv
-	], { run: false });
-	const flags = parsed.options;
-	const matchedCommand = cli.matchedCommandName;
-	const positionalCwd = extractPositionalCwd(matchedCommand, parsed.args);
+	const [command, cwd, ...extra] = positionals;
+	if (flags.has("help")) return {
+		kind: "help",
+		target: command && isCommandName(command) ? command : void 0
+	};
+	if (flags.has("version")) return { kind: "version" };
+	if (error) throw new UsageError(error);
+	if (command === void 0) return { kind: "usage" };
+	if (command === "init") return {
+		kind: "usage",
+		reason: "The 'init' command was removed: siro is lint-only. Run `siro lint --reporter json` and review each finding's remediation."
+	};
+	if (!isCommandName(command)) return {
+		kind: "usage",
+		reason: `Unknown command: ${command}`
+	};
+	if (extra.length > 0) throw new UsageError(`Unexpected extra argument: ${extra.join(" ")}`);
+	if (flags.has("reporter") && flags.has("json")) throw new UsageError("Invalid reporter selection: use either --reporter or --json.");
+	const reporter = flags.get("reporter");
 	return {
-		commandCandidate: extractCommandCandidate(matchedCommand, parsed.args),
-		extraPositionals: extractExtraPositionals(matchedCommand, parsed.args),
-		flags,
-		matchedCommand,
-		positionalCwd
+		kind: "lint",
+		cwd: asAbsPath(path.resolve(cwd ?? process.cwd())),
+		pm: parsePmFlag(flags.get("pm")),
+		projectType: parseProjectTypeFlag(flags.get("project-type")),
+		severity: parseSeverityFlag(flags.get("severity")),
+		reporter: typeof reporter === "string" ? reporter : flags.has("json") ? JSON_REPORTER_NAME : DEFAULT_REPORTER_NAME
 	};
 };
-
 //#endregion
 //#region src/cli/help.ts
 const PMS_LIST = PMS.join("|");
 const REPORTERS_LIST = BUILTIN_REPORTER_NAMES.join("|");
+const PROJECT_TYPES_LIST = PROJECT_TYPES.join("|");
 const SEVERITIES_LIST = SEVERITIES.join("|");
 const FLAG_LINES = {
 	json: "  --json               Shortcut for --reporter json",
 	pm: `  --pm <name>          Target a specific package manager (${PMS_LIST})`,
+	projectType: `  --project-type <type>  Project type (${PROJECT_TYPES_LIST}; default auto)`,
 	reporter: `  --reporter <name>    Reporter (${REPORTERS_LIST}; additional reporters can be registered via siro.config.ts)`,
 	severity: `  --severity <level>   Show + fail on findings at or above this level (${SEVERITIES_LIST})`
 };
@@ -224,6 +143,7 @@ const HELP_ROOT = [
 	"",
 	"GLOBAL FLAGS",
 	FLAG_LINES.pm,
+	FLAG_LINES.projectType,
 	"  --version            Print the siro version",
 	"  --help               Show help for siro or a command",
 	"",
@@ -251,6 +171,7 @@ const HELP_LINT = [
 	"",
 	"FLAGS",
 	FLAG_LINES.pm,
+	FLAG_LINES.projectType,
 	FLAG_LINES.reporter,
 	FLAG_LINES.json,
 	FLAG_LINES.severity,
@@ -271,146 +192,63 @@ const renderHelp = (target) => {
 	if (target === "lint" || target === "check") return HELP_LINT;
 	return target;
 };
-
 //#endregion
 //#region src/cli.ts
-const EMPTY = 0;
 const EXIT_SUCCESS = 0;
 const EXIT_USAGE = 2;
 const EXIT_CRASH = 70;
-const rejectPassthrough = (flags) => {
-	const passthrough = flags["--"];
-	if (Array.isArray(passthrough) && passthrough.length > EMPTY) throw new UsageError("siro takes no passthrough arguments after `--`.");
-};
-const resolveCommandCandidate = (commandCandidate) => {
-	if (typeof commandCandidate === "undefined") return { kind: "usage" };
-	if (commandCandidate === "init") return {
-		kind: "usage",
-		reason: "The 'init' command was removed: siro is lint-only. Run `siro lint --reporter json` and apply each finding's `fix` operations with your editor or an agent skill."
-	};
-	if (typeof commandCandidate !== "string" || !isCommandName(commandCandidate)) return {
-		kind: "usage",
-		reason: `Unknown command: ${String(commandCandidate)}`
-	};
-	return {
-		kind: "command",
-		name: commandCandidate
-	};
-};
-const SINGLE = 1;
-const rejectExtraPositionals = (extraPositionals) => {
-	if (extraPositionals.length > EMPTY) {
-		let plural = "";
-		if (extraPositionals.length > SINGLE) plural = "s";
-		throw new UsageError(`Unexpected extra argument${plural}: ${extraPositionals.join(" ")}`);
-	}
-};
-const resolveCwd = (positionalCwd) => {
-	let raw = process.cwd();
-	if (typeof positionalCwd === "string") raw = positionalCwd;
-	return asAbsPath(path.resolve(raw));
-};
-const checkPreScanFlags = (argv) => {
-	const preHelp = detectHelpFlag(argv);
-	if (typeof preHelp !== "undefined") return {
-		kind: "help",
-		target: preHelp.target
-	};
-	if (detectVersionFlag(argv)) return { kind: "version" };
-};
-const buildLintCommand = (flags, positionalCwd, commandCandidate) => {
-	rejectUnknownFlags(flags, flagsFor(commandCandidate), commandCandidate);
-	return {
-		cwd: resolveCwd(positionalCwd),
-		kind: "lint",
-		pm: parsePmFlag(flags.pm),
-		reporter: resolveReporter(flags),
-		severity: parseSeverityFlag(flags.severity)
-	};
-};
-const validateFlags = (flags) => {
-	rejectUnknownFlags(flags, KNOWN_FLAGS);
-	rejectPassthrough(flags);
-};
-const parseArgs = (argv) => {
-	const preScan = checkPreScanFlags(argv);
-	if (typeof preScan !== "undefined") return preScan;
-	const { commandCandidate, extraPositionals, flags, positionalCwd } = parseCacOutput(argv);
-	validateFlags(flags);
-	const resolved = resolveCommandCandidate(commandCandidate);
-	if (resolved.kind === "usage") return resolved;
-	rejectExtraPositionals(extraPositionals);
-	return buildLintCommand(flags, positionalCwd, resolved.name);
-};
-const handleVersion = (io) => {
-	io.stdout(version);
-	return Promise.resolve(EXIT_SUCCESS);
-};
-const handleHelp = (target, io) => {
-	io.stdout(renderHelp(target));
-	return Promise.resolve(EXIT_SUCCESS);
-};
-const handleUsage = (reason, io) => {
-	if (typeof reason !== "undefined") io.stderr(`${reason}\n`);
-	io.stderr(renderHelp());
-	return Promise.resolve(EXIT_USAGE);
-};
 const dispatch = (cmd, io) => {
 	switch (cmd.kind) {
-		case "version": return handleVersion(io);
-		case "help": return handleHelp(cmd.target, io);
-		case "usage": return handleUsage(cmd.reason, io);
-		case "lint": return lintCommand(cmd, io);
+		case "version":
+			io.stdout(version);
+			return EXIT_SUCCESS;
+		case "help":
+			io.stdout(renderHelp(cmd.target));
+			return EXIT_SUCCESS;
+		case "usage":
+			if (cmd.reason) io.stderr(`${cmd.reason}\n`);
+			io.stderr(renderHelp());
+			return EXIT_USAGE;
+		case "lint":
+			assertDirectory(cmd.cwd);
+			return loadConfig(cmd.cwd).then((config) => lintCommand({
+				...cmd,
+				config
+			}, io));
 		default: throw new Error(`Unhandled command kind: ${String(cmd)}`);
 	}
 };
-const handleAsyncError = (error, io) => {
+const handleError = (error, io) => {
 	if (error instanceof SiroError) {
 		io.stderr(error.message);
 		return error.exitCode;
 	}
-	if (isNodeError(error) && typeof error.errno === "number") {
+	if (isNodeError(error) && "errno" in error && typeof error.errno === "number") {
 		io.stderr(`File system error: ${error.message}`);
 		return EXIT_USAGE;
 	}
 	throw error;
 };
-const handleSyncError = (error, io) => {
-	if (error instanceof SiroError) {
-		io.stderr(error.message);
-		return Promise.resolve(error.exitCode);
-	}
-	if (isNodeError(error) && typeof error.errno === "number") {
-		io.stderr(`File system error: ${error.message}`);
-		return Promise.resolve(EXIT_USAGE);
-	}
-	return Promise.reject(error);
-};
-const run = (argv, io = nodeIO) => {
+const run = async (argv, io = nodeIO) => {
 	try {
 		ensureNodeVersion(process.versions.node);
-		return dispatch(parseArgs(argv), io).catch((error) => handleAsyncError(error, io));
+		return await dispatch(parseCommand(argv), io);
 	} catch (error) {
-		return handleSyncError(error, io);
+		return handleError(error, io);
 	}
 };
-const onRunFulfilled = (code) => {
-	process.exitCode = code;
-};
-const onRunRejected = (error) => {
-	let errStr = String(error);
-	if (error instanceof Error) errStr = error.stack ?? error.message;
-	process.stderr.write(`${errStr}\n`);
-	process.exitCode = EXIT_CRASH;
+const runMain = async (argv) => {
+	try {
+		process.exitCode = await run(argv);
+	} catch (error) {
+		const errStr = error instanceof Error ? error.stack ?? error.message : String(error);
+		process.stderr.write(`${errStr}\n`);
+		process.exitCode = EXIT_CRASH;
+	}
 };
-const ARGV_SKIP = 2;
 const [, invokedPath] = process.argv;
-if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) try {
-	onRunFulfilled(await run(process.argv.slice(ARGV_SKIP)));
-} catch (error) {
-	onRunRejected(error);
-}
-
+if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) await runMain(process.argv.slice(2));
 //#endregion
-export { run };
+export { run, runMain };
+
 //# sourceMappingURL=cli.mjs.map