sverka 0.2.22 → 0.2.24

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/main.ts","../src/output.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;iBAIe;EACf,MAAM;EACN,UAAU;EACV,MAAM;EACN,UAAU;;EAEV,MAAM;;;qBAIK;;;;;;YAOD,mBAAmB,uBAAuB;;YAG1C;;qBAWC,iBAAiB;WACnB,MAAM;WACN,UAAU;WACD;EAEhB,YAAA,iBACA,MAAM,cACN,UAAU,UACV;;;;;UChCa;EACf,SAAS;;;;;;;wBAuZW,KAAK,gBAAgB,OAAO,WAAW;;;;KC7ajD,aAAa;;;;;;qBAOZ,+BAA+B;;EAM9B,YAAA,KAAK,WAAW,KAAK,WAAW,iBAAe;EAO3D,MAAM;EAKN,UAAU;EAKV,MAAM;EAIN,UAAU;;EAKV,MAAM;;;;;;wBAwDQ,mBACd,QAAQ,aACR,KAAK,WACL,KAAK,YACJ;;;;;wBAYa,iBACd,QAAQ,aACR,MAAM,eACL"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/main.ts","../src/output.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;iBAIe;EACf,MAAM;EACN,UAAU;EACV,MAAM;EACN,UAAU;;EAEV,MAAM;;;qBAIK;;;;;;YAOD,mBAAmB,uBAAuB;;YAG1C;;qBAWC,iBAAiB;WACnB,MAAM;WACN,UAAU;WACD;EAEhB,YAAA,iBACA,MAAM,cACN,UAAU,UACV;;;;;UC9Ba;EACf,SAAS;;;;;;;wBA6cW,KAAK,gBAAgB,OAAO,WAAW;;;;KCrejD,aAAa;;;;;;qBAOZ,+BAA+B;;EAM9B,YAAA,KAAK,WAAW,KAAK,WAAW,iBAAe;EAO3D,MAAM;EAKN,UAAU;EAKV,MAAM;EAIN,UAAU;;EAKV,MAAM;;;;;;wBAwDQ,mBACd,QAAQ,aACR,KAAK,WACL,KAAK,YACJ;;;;;wBAYa,iBACd,QAAQ,aACR,MAAM,eACL"}

package/dist/index.mjs

@@ -10,7 +10,7 @@ import { mkdir, open, readFile, realpath, writeFile } from "node:fs/promises";
 import { Entry, Pipeline, Project, ShellStep, collectConstructWarnings, manual, synthesize, validateGraph } from "@sverka/workflow";
 import { bindRunPlan, createPlanner } from "@sverka/sdk";
 import { DEFAULT_POLICY, createBuiltinResolver, evaluatePolicy, loadBaseline, normalizeSarif, serializeSarif, synthesizeCheckSteps } from "@sverka/verification";
-import { createDockerDriver, createEngine, createHostDriver } from "@sverka/runtime";
+import { AGENT_ENV, collectAgentWrites, createDockerDriver, createEngine, createHostDriver, noAgentDriverError, resolveAgentDrivers, resolveAgentEngine } from "@sverka/runtime";
 import { spawnSync } from "node:child_process";
 import { watch } from "chokidar";
 import { compileGithub, compileGitlab } from "@sverka/compiler";
@@ -190,17 +190,31 @@ async function registerConfigHooks() {
 /**
 * Find a sverka.config.ts or sverka.config.js file in the given root.
 * Returns the absolute path or null if not found.
+* Spec 37/54: when no config exists, fall back to `.sverka/*.md` files
+* (markdown authoring) — sorted, first file wins.
 */
 async function findConfig(root) {
 	for (const candidate of [
 		"sverka.config.ts",
+		"sverka.config.mts",
 		"sverka.config.js",
 		"sverka.config.mjs"
 	]) {
 		const path = join(root, candidate);
 		if (existsSync(path)) return path;
 	}
-	return null;
+	return findMarkdownConfig(root);
+}
+/** First `.sverka/*.md` file under root (sorted), or null. */
+function findMarkdownConfig(root) {
+	const dir = join(root, ".sverka");
+	let names;
+	try {
+		names = readdirSync(dir).filter((n) => n.endsWith(".md")).sort();
+	} catch {
+		return null;
+	}
+	return names.length > 0 ? join(dir, names[0]) : null;
 }
 /**
 * Resolve the effective config path from global flags.
@@ -236,6 +250,12 @@ function assertConstructLike(value) {
 async function loadConfig(configPath) {
 	const absPath = isAbsolute(configPath) ? configPath : resolve(process.cwd(), configPath);
 	if (!existsSync(absPath)) throw new CliError(`config not found: ${absPath}`, "MISSING_ARG", ExitCode.UsageError);
+	if (absPath.endsWith(".md")) try {
+		const { loadMarkdownFile } = await import("@sverka/sdk");
+		return await loadMarkdownFile(absPath);
+	} catch (e) {
+		throw new CliError(`failed to load config: ${e instanceof Error ? e.message : String(e)}`, "SDK_ERROR", ExitCode.RuntimeError, e);
+	}
 	let mod;
 	try {
 		await registerConfigHooks();
@@ -975,6 +995,7 @@ async function runCommand(args, global, output, start) {
 	const artifactDir = join(global.root, ".sverka", "artifacts");
 	const { events, runStatus, renderer } = await consumeEvents(createEngine({
 		drivers: buildDrivers(executor),
+		agentDrivers: resolveAgentDrivers(process$1.env),
 		maxConcurrent: args.jobs ?? 4
 	}), plan, {
 		workspace: global.root,
@@ -2265,6 +2286,218 @@ async function uiCommand(args, global, output, _start) {
 	}
 }
 //#endregion
+//#region src/commands/agent.ts
+const RESULT_FILE = "agent-result.json";
+const WRITES_FILE$1 = "sverka-writes.json";
+async function agentCommand(args, global, output, _start) {
+	const env = process$1.env;
+	const engine = resolveAgentEngine(env);
+	const prompt = env[AGENT_ENV.prompt];
+	if (prompt === void 0 || prompt === "") throw new CliError(`sverka agent: ${AGENT_ENV.prompt} is not set — the compiled agent job provides it`, "MISSING_ARG", ExitCode.UsageError);
+	const outDir = args.outputDir ?? global.root;
+	const mentions = parseMentionList(env[AGENT_ENV.mention]);
+	const commentBody = env["COMMENT_BODY"];
+	if (mentions.length > 0 && commentBody !== void 0 && !mentions.some((m) => commentBody.includes(m))) {
+		output.writeLine(`sverka agent: comment does not contain a configured mention (${mentions.join(", ")}) — skipping`);
+		await writeArtifacts(outDir, {
+			text: "",
+			finishReason: "stop"
+		});
+		return ExitCode.Success;
+	}
+	const driver = resolveAgentDrivers(env).find((d) => d.canExecute(engine));
+	if (driver === void 0) throw noAgentDriverError(engine, `sverka agent, engine '${engine}'`);
+	const model = env[AGENT_ENV.model];
+	const maxTokens = env[AGENT_ENV.maxTokens];
+	const request = {
+		engine,
+		prompt,
+		...model !== void 0 ? { model } : {},
+		...maxTokens !== void 0 ? { maxTokens: parseMaxTokens(maxTokens) } : {}
+	};
+	output.debug(`sverka agent: engine=${engine} driver=${driver.name}`);
+	const result = await driver.executeAgent(request);
+	if (result.finishReason === "error") {
+		output.errorLine("sverka agent: agent finished with reason 'error'");
+		return ExitCode.RuntimeError;
+	}
+	await writeArtifacts(outDir, result, collectAgentWrites(result));
+	if (result.text !== "") output.writeLine(result.text);
+	return ExitCode.Success;
+}
+/**
+* SVERKA_MENTION carries one mention string, or a JSON array when several
+* comment entries with different mentions reach the same job.
+*/
+function parseMentionList(raw) {
+	if (raw === void 0) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((m) => typeof m === "string")) return parsed;
+	} catch {}
+	return [raw];
+}
+function parseMaxTokens(raw) {
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n <= 0) throw new CliError(`sverka agent: ${AGENT_ENV.maxTokens} must be a positive integer, got '${raw}'`, "INVALID_FLAG", ExitCode.UsageError);
+	return n;
+}
+async function writeArtifacts(dir, result, writes = []) {
+	await writeFile(join(dir, RESULT_FILE), JSON.stringify(result, null, 2), "utf-8");
+	await writeFile(join(dir, WRITES_FILE$1), JSON.stringify({ writes }, null, 2), "utf-8");
+}
+//#endregion
+//#region src/commands/apply.ts
+const WRITES_FILE = "sverka-writes.json";
+const DECLARATIONS_ENV = "SVERKA_WRITE_DECLARATIONS";
+/** Write kinds `sverka apply` can execute. Everything else fails loudly. */
+const SUPPORTED_WRITE_KINDS = /* @__PURE__ */ new Set(["comment"]);
+async function applyCommand(args, global, output, _start) {
+	const provider = args.provider ?? detectProvider();
+	const writes = await loadWrites(args.file ?? join(global.root, WRITES_FILE));
+	const declarations = loadDeclarations();
+	const applied = [];
+	for (const write of writes) {
+		if (!declarations.some((d) => d.kind === write.kind)) throw new CliError(`sverka apply: write kind '${write.kind}' is not declared in permissions.write (declarations: ${declarations.map((d) => d.kind).join(", ") || "none"})`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+		if (!SUPPORTED_WRITE_KINDS.has(write.kind)) throw new CliError(`sverka apply: write kind '${write.kind}' is declared but not supported by sverka apply (supported: ${[...SUPPORTED_WRITE_KINDS].join(", ")})`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+		applied.push(await applyWrite(provider, write, declarations));
+	}
+	const summary = applied.length > 0 ? ` — ${applied.join("; ")}` : "";
+	output.writeLine(`sverka apply: applied ${applied.length} write(s) via ${provider}${summary}`);
+	return ExitCode.Success;
+}
+function detectProvider() {
+	if (process$1.env["GITLAB_CI"] !== void 0 || process$1.env["CI_API_V4_URL"]) return "gitlab";
+	if (process$1.env["GITHUB_ACTIONS"] !== void 0) return "github";
+	throw new CliError("sverka apply: --provider is required when CI provider cannot be detected (gitlab|github)", "MISSING_ARG", ExitCode.UsageError);
+}
+async function loadWrites(file) {
+	let raw;
+	try {
+		raw = await readFile(file, "utf-8");
+	} catch {
+		throw new CliError(`sverka apply: writes artifact not found: ${file} — the agent job must produce ${WRITES_FILE}`, "MISSING_ARG", ExitCode.RuntimeError);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (e) {
+		throw new CliError(`sverka apply: ${WRITES_FILE} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	}
+	const items = extractWritesItems(parsed);
+	if (items === void 0) throw new CliError(`sverka apply: ${WRITES_FILE} must be an object with a 'writes' array`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	return items.map((item, i) => {
+		if (typeof item !== "object" || item === null || typeof item.kind !== "string") throw new CliError(`sverka apply: writes[${i}] must be an object with a string 'kind'`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+		return item;
+	});
+}
+/** The artifact is either a bare array or an object with a 'writes' array. */
+function extractWritesItems(parsed) {
+	if (Array.isArray(parsed)) return parsed;
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const w = parsed.writes;
+	return Array.isArray(w) ? w : void 0;
+}
+function loadDeclarations() {
+	const raw = process$1.env[DECLARATIONS_ENV];
+	if (raw === void 0 || raw === "") throw new CliError(`sverka apply: ${DECLARATIONS_ENV} is not set — the __apply job declares it from permissions.write`, "MISSING_ARG", ExitCode.RuntimeError);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (e) {
+		throw new CliError(`sverka apply: ${DECLARATIONS_ENV} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	}
+	if (!Array.isArray(parsed)) throw new CliError(`sverka apply: ${DECLARATIONS_ENV} must be a JSON array of write declarations`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	return parsed;
+}
+async function applyWrite(provider, write, declarations) {
+	if (write.kind === "comment") return provider === "gitlab" ? applyGitlabComment(write, declarations) : applyGithubComment(write);
+	throw new CliError(`sverka apply: write kind '${write.kind}' is not supported`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+}
+function requireBody(write) {
+	if (typeof write.body !== "string" || write.body === "") throw new CliError("sverka apply: comment write requires a non-empty 'body' string", "PACKAGE_ERROR", ExitCode.RuntimeError);
+	return write.body;
+}
+/**
+* The object kind a comment write targets. `write.on` wins when present
+* (and must be a known kind — anything else fails loudly rather than
+* silently falling back); otherwise the triggering context decides: a
+* forwarded MR_IID means the comment fired on a merge request.
+*/
+function resolveCommentTarget(write) {
+	if (write.on === "issue" || write.on === "merge_request") return write.on;
+	if (write.on !== void 0) throw new CliError(`sverka apply: comment write 'on' must be issue|merge_request, got '${JSON.stringify(write.on)}'`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	return process$1.env["MR_IID"] !== void 0 ? "merge_request" : "issue";
+}
+/**
+* Resolve the target iid for a comment write. When the triggering context
+* supplies an iid (the webhook forwarded MR_IID/ISSUE_IID), it wins — a
+* write.iid that disagrees is model output trying to redirect the comment
+* to another target, which fails loudly.
+*/
+function requireIid(write, envKeys) {
+	const contextRaw = envKeys.map((k) => process$1.env[k]).find((v) => v !== void 0 && v !== "");
+	if (contextRaw !== void 0) {
+		const ctx = Number(contextRaw);
+		if (!Number.isInteger(ctx) || ctx <= 0) throw new CliError(`sverka apply: context iid '${contextRaw}' is not a positive integer`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+		if (write.iid !== void 0 && Number(write.iid) !== ctx) throw new CliError(`sverka apply: write iid '${JSON.stringify(write.iid)}' does not match the triggering context iid ${ctx}`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+		return ctx;
+	}
+	if (write.iid === void 0) throw new CliError(`sverka apply: comment write needs a target iid (${envKeys.join(" or ")} env var, or an 'iid' field)`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	const n = Number(write.iid);
+	if (!Number.isInteger(n) || n <= 0) throw new CliError(`sverka apply: comment write iid must be a positive integer, got '${JSON.stringify(write.iid)}'`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	return n;
+}
+async function applyGitlabComment(write, declarations) {
+	const { api, project, token } = gitlabApplyEnv();
+	const body = requireBody(write);
+	const on = resolveCommentTarget(write);
+	if (!declarations.some((d) => d.kind === "comment" && d.target === on)) throw new CliError(`sverka apply: comment write targets '${on}' but no declaration declares it (declared comment targets: ${declarations.filter((d) => d.kind === "comment").map((d) => d.target).join(", ") || "none"})`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	const iid = requireIid(write, on === "merge_request" ? ["MR_IID"] : ["ISSUE_IID", "SVERKA_ISSUE_IID"]);
+	await postJson(`${api}${on === "merge_request" ? `/projects/${encodeURIComponent(project)}/merge_requests/${iid}/notes` : `/projects/${encodeURIComponent(project)}/issues/${iid}/notes`}`, token, { body }, "PRIVATE-TOKEN");
+	return `comment on ${on} !${iid}`;
+}
+/** Provider-supplied env for a GitLab apply call — all CI-controlled. */
+function gitlabApplyEnv() {
+	const env = process$1.env;
+	const api = env["CI_API_V4_URL"] ?? "https://gitlab.com/api/v4";
+	const project = env["CI_PROJECT_ID"];
+	if (project === void 0 || project === "") throw new CliError("sverka apply: CI_PROJECT_ID is not set — run inside a GitLab job or set it explicitly", "MISSING_ARG", ExitCode.RuntimeError);
+	const token = env["SVERKA_APPLY_TOKEN"] || env["GITLAB_TOKEN"];
+	if (token === void 0 || token === "") throw new CliError("sverka apply: SVERKA_APPLY_TOKEN is not set — scope it to the 'sverka-apply' environment (see engdocs/user/gitlab/agentic.md)", "MISSING_ARG", ExitCode.RuntimeError);
+	return {
+		api,
+		project,
+		token
+	};
+}
+async function applyGithubComment(write) {
+	const env = process$1.env;
+	const api = env["GITHUB_API_URL"] ?? "https://api.github.com";
+	const repo = env["GITHUB_REPOSITORY"];
+	if (repo === void 0 || repo === "") throw new CliError("sverka apply: GITHUB_REPOSITORY is not set — run inside a GitHub Actions job or set it explicitly", "MISSING_ARG", ExitCode.RuntimeError);
+	const token = env["SVERKA_APPLY_TOKEN"] || env["GH_TOKEN"] || env["GITHUB_TOKEN"];
+	if (token === void 0 || token === "") throw new CliError("sverka apply: GH_TOKEN/GITHUB_TOKEN is not set", "MISSING_ARG", ExitCode.RuntimeError);
+	const body = requireBody(write);
+	const issue = requireIid(write, ["SVERKA_ISSUE_IID", "ISSUE_IID"]);
+	await postJson(`${api}/repos/${repo}/issues/${issue}/comments`, token, { body }, "Bearer");
+	return `comment on issue #${issue}`;
+}
+async function postJson(url, token, body, auth) {
+	const headers = { "content-type": "application/json" };
+	if (auth === "PRIVATE-TOKEN") headers["PRIVATE-TOKEN"] = token;
+	else headers["authorization"] = `Bearer ${token}`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(body)
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new CliError(`sverka apply: provider request failed (${res.status} ${res.url}): ${text.slice(0, 300)}`, "PACKAGE_ERROR", ExitCode.RuntimeError);
+	}
+}
+//#endregion
 //#region src/main.ts
 /** Build GlobalFlags from parsed yargs options. */
 function buildGlobalFlags(parsed) {
@@ -2347,13 +2580,9 @@ function addPolicyCommand(y) {
 		demandOption: true
 	}).option("baseline", { type: "string" });
 }
-/** Configure the synth subcommand options. */
+/** Configure the synth subcommand options. Alias for compile — same flags. */
 function addSynthCommand(y) {
-	return y.option("target", {
-		type: "string",
-		demandOption: true,
-		choices: ["github", "gitlab"]
-	});
+	return addCompileCommand(y);
 }
 /** Configure the compile subcommand options. */
 function addCompileCommand(y) {
@@ -2433,7 +2662,17 @@ function buildParser() {
 		type: "boolean",
 		alias: "v",
 		default: false
-	}).command("init", "Create a sverka.config.ts", addInitCommand).command("validate", "Validate a sverka config").command("plan", "Bind Entry + inputs → Run Plan", addPlanCommand).command("graph", "Display the Definition Graph").command("run", "Execute the workflow locally", addRunCommand).command("discover", "Discover and display project context").command("check", "Resolve proposed checks → StepDefinitions").command("policy", "Evaluate findings against policy", addPolicyCommand).command("synth", "Alias for compile — compile to a target CI YAML", addSynthCommand).command("compile", "Compile to a target CI YAML", addCompileCommand).command("mcp-server", "Expose Sverka as an MCP server (stdio)").command("doctor", "Diagnose environment and dependencies").command("view [file]", "Open the latest run report, or view SARIF findings (TUI/HTML)", addViewCommand).command("ui", "Start local web dashboard server", addUiCommand).demandCommand(1, "No command given").strict().fail((msg, err) => {
+	}).command("init", "Create a sverka.config.ts", addInitCommand).command("validate", "Validate a sverka config").command("plan", "Bind Entry + inputs → Run Plan", addPlanCommand).command("graph", "Display the Definition Graph").command("run", "Execute the workflow locally", addRunCommand).command("discover", "Discover and display project context").command("check", "Resolve proposed checks → StepDefinitions").command("policy", "Evaluate findings against policy", addPolicyCommand).command("synth", "Alias for compile — compile to a target CI YAML", addSynthCommand).command("compile", "Compile to a target CI YAML", addCompileCommand).command("mcp-server", "Expose Sverka as an MCP server (stdio)").command("doctor", "Diagnose environment and dependencies").command("view [file]", "Open the latest run report, or view SARIF findings (TUI/HTML)", addViewCommand).command("ui", "Start local web dashboard server", addUiCommand).command("agent", "Run a single agent step from SVERKA_AGENT_* env (CI agent jobs)", (y) => y.option("output-dir", {
+		type: "string",
+		describe: "Directory for agent-result.json + sverka-writes.json (default: root)"
+	})).command("apply", "Validate + apply agent writes artifact (CI __apply jobs)", (y) => y.option("provider", {
+		type: "string",
+		choices: ["gitlab", "github"],
+		describe: "CI provider (auto-detected from CI env when omitted)"
+	}).option("file", {
+		type: "string",
+		describe: "Path to sverka-writes.json (default: <root>/sverka-writes.json)"
+	})).demandCommand(1, "No command given").strict().fail((msg, err) => {
 		if (err) throw err;
 		throw new CliError(msg, "UNKNOWN_COMMAND", ExitCode.UsageError);
 	});
@@ -2455,6 +2694,8 @@ async function dispatch(command, parsed, global, output, start) {
 		case "doctor": return doctorCommand(global, output, start);
 		case "view": return dispatchView(parsed, global, output, start);
 		case "ui": return dispatchUi(parsed, global, output, start);
+		case "agent": return dispatchAgent(parsed, global, output, start);
+		case "apply": return dispatchApply(parsed, global, output, start);
 		default: throw new CliError(`unknown command: ${command}`, "UNKNOWN_COMMAND", ExitCode.UsageError);
 	}
 }
@@ -2499,7 +2740,11 @@ function dispatchPolicy(parsed, global, output, start) {
 	return policyCommand(args, global, output, start);
 }
 function dispatchSynth(parsed, global, output, start) {
-	return synthCommand({ target: parsed.target === "gitlab" ? "gitlab" : "github" }, global, output, start);
+	const args = { target: parsed.target === "gitlab" ? "gitlab" : "github" };
+	if (typeof parsed.output === "string") args.output = parsed.output;
+	if (typeof parsed.outputDir === "string") args.outputDir = parsed.outputDir;
+	if (parsed.pin === true) args.pin = true;
+	return synthCommand(args, global, output, start);
 }
 function dispatchCompile(parsed, global, output, start) {
 	const args = { target: parsed.target === "gitlab" ? "gitlab" : "github" };
@@ -2520,6 +2765,17 @@ function dispatchUi(parsed, global, output, start) {
 	if (typeof parsed.host === "string") args.host = parsed.host;
 	return uiCommand(args, global, output, start);
 }
+function dispatchAgent(parsed, global, output, start) {
+	const args = {};
+	if (typeof parsed.outputDir === "string") args.outputDir = parsed.outputDir;
+	return agentCommand(args, global, output, start);
+}
+function dispatchApply(parsed, global, output, start) {
+	const args = {};
+	if (parsed.provider === "gitlab" || parsed.provider === "github") args.provider = parsed.provider;
+	if (typeof parsed.file === "string") args.file = parsed.file;
+	return applyCommand(args, global, output, start);
+}
 /**
 * The main CLI entry point.
 * @param argv Command-line arguments (excluding node and script path).