sverka 0.2.15 → 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;;;;;;;wBAiZW,KAAK,gBAAgB,OAAO,WAAW;;;;KCvajD,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

@@ -7,7 +7,7 @@ import { constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSy
 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.html !== null ? `  report: ${report.html}  (sverka view to open)` : `  report: ${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) {
@@ -2228,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)"
@@ -2395,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;