sverka 0.2.14 → 0.2.16

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;;;;;;;wBAgZW,KAAK,gBAAgB,OAAO,WAAW;;;;KCtajD,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;;;;;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"}

package/dist/index.mjs

@@ -3,11 +3,11 @@ import * as nodeModule from "node:module";
 import { register } from "node:module";
 import process$1 from "node:process";
 import yargs from "yargs";
-import { constants, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { mkdir, open, readFile, realpath, writeFile } from "node:fs/promises";
-import { collectConstructWarnings, synthesize, validateGraph } from "@sverka/workflow";
+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";
@@ -720,6 +720,48 @@ async function graphCommand(global, output, start) {
 	return ExitCode.Success;
 }
 //#endregion
+//#region src/internal/implicit.ts
+/** Load the graph `sverka run` should execute: the real config when one
+*  exists on disk (or --config names one), else the implicit detected
+*  pipeline. */
+async function loadRunGraph(global) {
+	if (global.config === null && await findConfig(global.root) === null) return implicitGraph(global.root);
+	const { graph, warnings } = await loadProjectGraph(global);
+	return {
+		graph,
+		warnings
+	};
+}
+async function implicitGraph(root) {
+	const checks = await detectProjectChecks(root);
+	if (checks.length === 0) throw new CliError("no config found and no checks detected (run `sverka init` to create one)", "MISSING_ARG", ExitCode.UsageError);
+	const project = new Project("default");
+	const pipeline = new Pipeline(project, "default");
+	const steps = checks.map((check) => new ShellStep(pipeline, check.checkId, shellStepProps(check)));
+	const entry = new Entry(pipeline, "run", {
+		trigger: manual(),
+		roots: steps.map((step) => step.node.id)
+	});
+	return {
+		graph: synthesize(project),
+		warnings: collectConstructWarnings(project),
+		detected: entry.roots
+	};
+}
+/** Detected check → ShellStep props. A SARIF-on-stdout check keeps the
+*  `fromStdout` artifact declaration `init --detect` generates, so the
+*  implicit run feeds findings collection the same way. */
+function shellStepProps(check) {
+	return {
+		command: check.command,
+		runtime: { mode: "host" },
+		...check.sarifOutput !== void 0 ? { outputs: { [check.sarifOutput]: {
+			type: "artifact",
+			fromStdout: true
+		} } } : {}
+	};
+}
+//#endregion
 //#region src/internal/runtime-check.ts
 /**
 * Check if a binary is available on PATH by spawning `<binary> --version`.
@@ -922,7 +964,8 @@ async function runCommand(args, global, output, start) {
 	const fmt = resolveFormats(args, global);
 	output.debug(`run: root=${global.root} executor=${executor} entry=${args.entryId ?? "(first)"} format=${global.format}`);
 	assertExecutorAvailable(executor);
-	const { graph, warnings } = await loadProjectGraph(global);
+	const { graph, warnings, detected } = await loadRunGraph(global);
+	if (detected !== void 0) output.errorLine(`no sverka.config — running ${detected.length} detected checks (${detected.join(", ")})`);
 	for (const warning of warnings) output.errorLine(`warning: ${warning}`);
 	const entryId = resolveEntryId(graph, args.entryId);
 	const plan = bindRunPlan({
@@ -947,13 +990,11 @@ async function runCommand(args, global, output, start) {
 		durationMs,
 		evalResult: evaluation.summary,
 		artifactDir,
-		sinceMs: start
+		sinceMs: start,
+		...detected !== void 0 ? { detected } : {},
+		...args.report !== void 0 ? { report: args.report } : {}
 	}, events, output);
-	if (fmt.isHtml && renderer) {
-		const reportPath = args.output ?? join(global.root, ".sverka", "report.html");
-		output.writeLine(`Wrote HTML report to ${reportPath}`);
-	}
-	if (renderer && "waitUntilExit" in renderer) await renderer.waitUntilExit();
+	await finalizeRenderer(fmt, renderer, args, global, output);
 	if (evaluation.collectionFailed) return evaluation.exitCode;
 	writeRunOutput({
 		planId: plan.id,
@@ -963,12 +1004,36 @@ async function runCommand(args, global, output, start) {
 		global,
 		output,
 		evalResult: evaluation.summary,
-		report
+		report,
+		...detected !== void 0 ? { detected } : {}
 	});
-	if (report !== void 0 && global.format === "text") output.writeLine(`  report: ${report.html ?? report.json}`);
+	printReportTail(report, args.report, global, output);
 	if (evaluation.exitCode !== 0) return evaluation.exitCode;
 	return exitCodeForStatus(runStatus);
 }
+/** Post-run: announce the HTML report path (sarif/web print their own),
+*  then keep interactive renderers mounted until the user quits. */
+async function finalizeRenderer(fmt, renderer, args, global, output) {
+	if (fmt.isHtml && renderer) {
+		const reportPath = args.output ?? join(global.root, ".sverka", "report.html");
+		output.writeLine(`Wrote HTML report to ${reportPath}`);
+	}
+	if (renderer && "waitUntilExit" in renderer) await renderer.waitUntilExit();
+}
+/** Human-mode tail (Spec 53): findings summary, then the report location —
+*  the report is discoverable, not hidden. The `sverka view` hint applies
+*  only when report.html sits at the default path — view resolves
+*  .sverka/runs/<latest>/report.html, not a --report relocation. */
+function printReportTail(report, reportFlag, global, output) {
+	if (report === void 0 || global.format !== "text") return;
+	output.writeLine(`  findings: ${report.findings}`);
+	if (report.html === null) {
+		output.writeLine(`  report: ${report.json}`);
+		return;
+	}
+	const hint = reportFlag !== void 0 ? "(open in a browser)" : "(sverka view to open)";
+	output.writeLine(`  report: ${report.html}  ${hint}`);
+}
 /** Derive output modes — `--format html`, or `--output` without
 *  sarif/web, implies HTML; evaluation runs for any structured format. */
 function resolveFormats(args, global) {
@@ -1018,11 +1083,14 @@ async function writeReportSafe(ctx, events, output) {
 			durationMs: ctx.durationMs,
 			evalResult: ctx.evalResult,
 			artifactDir: ctx.artifactDir,
-			sinceMs: ctx.sinceMs
+			sinceMs: ctx.sinceMs,
+			...ctx.detected !== void 0 ? { detected: ctx.detected } : {},
+			...ctx.report !== void 0 ? { reportPath: ctx.report } : {}
 		});
 		return {
 			html: artifacts.htmlPath,
-			json: join(artifacts.dir, "report.json")
+			json: join(artifacts.dir, "report.json"),
+			findings: artifacts.findingsCount
 		};
 	} catch (err) {
 		if (err instanceof CliError) throw err;
@@ -1049,9 +1117,10 @@ async function runWatch(args, global, output) {
 		const configPath = global.config === null ? null : resolve(global.root, global.config);
 		const extraPaths = configPath !== null && !configPath.startsWith(`${resolve(global.root)}/`) ? [configPath] : [];
 		const ignored = [];
-		if (args.output !== void 0) {
-			const out = resolve(global.root, args.output);
-			if (out.startsWith(`${resolve(global.root)}/`)) ignored.push(out);
+		for (const file of [args.output, args.report]) {
+			if (file === void 0) continue;
+			const abs = resolve(global.root, file);
+			if (abs.startsWith(`${resolve(global.root)}/`)) ignored.push(abs);
 		}
 		return await watchLoop({
 			root: global.root,
@@ -1259,6 +1328,7 @@ function writeRunOutput(opts) {
 				planId,
 				status: runStatus,
 				steps,
+				...opts.detected !== void 0 ? { detected: opts.detected } : {},
 				...evalResult ? {
 					findings: evalResult.findings.length,
 					verdict: evalResult.verdict,
@@ -1266,7 +1336,8 @@ function writeRunOutput(opts) {
 				} : {},
 				...report !== void 0 ? { report: {
 					json: report.json,
-					...report.html !== null ? { html: report.html } : {}
+					...report.html !== null ? { html: report.html } : {},
+					findings: report.findings
 				} } : {}
 			},
 			durationMs
@@ -1341,26 +1412,27 @@ async function collectRunFindings(opts, warnings) {
 }
 /** Best-effort report.html — a render failure never fails the run; it is
 *  recorded in the report's `warnings` instead of being dropped silently. */
-async function writeReportHtml(dir, findings, warnings) {
+async function writeReportHtml(htmlPath, findings, warnings) {
 	try {
 		const { generateSarifHtml } = await import("@sverka/sarif-viewer-web");
-		const candidate = join(dir, "report.html");
-		writeFileSync(candidate, generateSarifHtml(findings), "utf-8");
-		return candidate;
+		mkdirSync(dirname(htmlPath), { recursive: true });
+		writeFileSync(htmlPath, generateSarifHtml(findings), "utf-8");
+		return htmlPath;
 	} catch (e) {
 		warnings.push(`report.html generation failed: ${e instanceof Error ? e.message : String(e)}`);
 		return null;
 	}
 }
-function runReportPayload(opts, warnings) {
+function runReportPayload(opts, findingsCount, warnings) {
 	return {
 		schema: "sverka.run/v1",
 		data: {
 			planId: opts.planId,
 			status: opts.runStatus,
 			steps: boundStepOutput(summarizeSteps(opts.events)),
+			...opts.detected !== void 0 ? { detected: opts.detected } : {},
+			findings: findingsCount,
 			...opts.evalResult ? {
-				findings: opts.evalResult.findings.length,
 				verdict: opts.evalResult.verdict,
 				summary: opts.evalResult.summary
 			} : {},
@@ -1375,11 +1447,13 @@ function runReportPayload(opts, warnings) {
 async function writeRunArtifacts(opts) {
 	const dir = reportDir(opts.root, opts.runId);
 	const warnings = [];
-	const htmlPath = await writeReportHtml(dir, await collectRunFindings(opts, warnings), warnings);
-	writeFileSync(join(dir, "report.json"), JSON.stringify(runReportPayload(opts, warnings), null, 2), "utf-8");
+	const findings = await collectRunFindings(opts, warnings);
+	const htmlPath = await writeReportHtml(opts.reportPath !== void 0 ? resolveUnderRoot(opts.root, opts.reportPath) : join(dir, "report.html"), findings, warnings);
+	writeFileSync(join(dir, "report.json"), JSON.stringify(runReportPayload(opts, findings.length, warnings), null, 2), "utf-8");
 	return {
 		dir,
-		htmlPath
+		htmlPath,
+		findingsCount: findings.length
 	};
 }
 function exitCodeForStatus(runStatus) {
@@ -2007,6 +2081,77 @@ function runCheck(name, binary, required) {
 	}
 }
 //#endregion
+//#region src/internal/open-report.ts
+/** Newest `.sverka/runs/<runId>/report.html` under root, by file mtime.
+*  Returns undefined when no run report exists. */
+function findLatestReportHtml(root) {
+	let names;
+	try {
+		names = readdirSync(join(root, ".sverka", "runs"));
+	} catch {
+		return;
+	}
+	let best;
+	for (const name of names) {
+		const candidate = join(root, ".sverka", "runs", name, "report.html");
+		let stat;
+		try {
+			stat = statSync(candidate);
+		} catch (e) {
+			const code = e.code;
+			if (code === "ENOENT" || code === "ENOTDIR") continue;
+			throw e;
+		}
+		if (stat.isFile() && (best === void 0 || stat.mtimeMs > best.mtimeMs)) best = {
+			path: candidate,
+			mtimeMs: stat.mtimeMs
+		};
+	}
+	return best?.path;
+}
+/** WSL exposes Windows browsers through wslu, not xdg-open. */
+function isWsl() {
+	if (process$1.platform !== "linux") return false;
+	try {
+		return readFileSync("/proc/sys/kernel/osrelease", "utf8").toLowerCase().includes("microsoft");
+	} catch {
+		return false;
+	}
+}
+function openerCandidates(path) {
+	if (process$1.platform === "darwin") return [["open", [path]]];
+	if (process$1.platform === "win32") return [[
+		"cmd",
+		[
+			"/c",
+			"start",
+			"\"\"",
+			"\"%SVERKA_VIEW_TARGET%\""
+		],
+		{
+			windowsVerbatimArguments: true,
+			env: {
+				...process$1.env,
+				SVERKA_VIEW_TARGET: path
+			}
+		}
+	]];
+	return isWsl() ? [["wslview", [path]], ["xdg-open", [path]]] : [["xdg-open", [path]]];
+}
+/** Open a file with the platform's default handler. Returns false when no
+*  opener binary exists or every attempt failed — callers print the path. */
+function openReportInBrowser(path) {
+	for (const [cmd, args, options] of openerCandidates(path)) {
+		const res = spawnSync(cmd, args, {
+			stdio: "ignore",
+			timeout: 5e3,
+			...options
+		});
+		if (res.error === void 0 && res.status === 0) return true;
+	}
+	return false;
+}
+//#endregion
 //#region src/commands/view.ts
 /**
 * View SARIF findings in the terminal TUI or generate an HTML report.
@@ -2024,10 +2169,7 @@ async function viewCommand(args, global, output, start) {
 			output.errorLine("sverka view: stdin is empty.");
 			return ExitCode.RuntimeError;
 		}
-	} else {
-		output.errorLine("sverka view: no input. Provide a SARIF file argument or pipe SARIF via stdin.");
-		return ExitCode.UsageError;
-	}
+	} else return openLatestReport(global, output);
 	let sarif;
 	try {
 		sarif = JSON.parse(sarifJson);
@@ -2038,6 +2180,18 @@ async function viewCommand(args, global, output, start) {
 	if (args.format === "web") return renderWeb(sarif, args, output);
 	return renderTui(sarif, output);
 }
+/** Interactive with no input — open the latest run report (Spec 53:
+*  `sverka run` tails with `report: <path>  (sverka view to open)`). */
+function openLatestReport(global, output) {
+	const report = findLatestReportHtml(global.root);
+	if (report === void 0) {
+		output.errorLine("sverka view: no input. Provide a SARIF file argument, pipe SARIF via stdin, or run `sverka run` first — no run report found under .sverka/runs/.");
+		return ExitCode.UsageError;
+	}
+	output.writeLine(`report: ${report}`);
+	if (!openReportInBrowser(report)) output.errorLine("sverka view: could not open a browser — open the report path above manually.");
+	return ExitCode.Success;
+}
 /** Launch the TUI viewer using @sverka/sarif-viewer-tui. */
 async function renderTui(sarif, output) {
 	try {
@@ -2148,6 +2302,9 @@ function addRunCommand(y) {
 		type: "string",
 		alias: "o",
 		describe: "Output file path for HTML report (implies --format html)"
+	}).option("report", {
+		type: "string",
+		describe: "Relocate the per-run HTML report (report.json stays under .sverka/runs/)"
 	}).option("tui", {
 		type: "boolean",
 		describe: "Interactive terminal UI (off by default; opt-in only)"
@@ -2206,7 +2363,7 @@ function addCompileCommand(y) {
 function addViewCommand(y) {
 	return y.positional("file", {
 		type: "string",
-		describe: "Path to a .sarif file (reads from stdin if omitted)"
+		describe: "Path to a .sarif file (piped stdin when omitted; bare `view` opens the latest run report)"
 	}).option("format", {
 		type: "string",
 		alias: "f",
@@ -2261,7 +2418,7 @@ 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]", "View SARIF findings in TUI or generate HTML report", 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).demandCommand(1, "No command given").strict().fail((msg, err) => {
 		if (err) throw err;
 		throw new CliError(msg, "UNKNOWN_COMMAND", ExitCode.UsageError);
 	});
@@ -2315,6 +2472,7 @@ function dispatchRun(parsed, global, output, start) {
 	}
 	if (typeof parsed.entry === "string") args.entryId = parsed.entry;
 	if (typeof parsed.output === "string") args.output = parsed.output;
+	if (typeof parsed.report === "string") args.report = parsed.report;
 	if (parsed.tui === true) args.tui = true;
 	if (parsed.tui === false) args.tui = false;
 	if (parsed.watch === true) args.watch = true;