@sverka/compiler 0.1.14 → 0.1.15

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { stringify } from "yaml";
+import { parse, stringify } from "yaml";
 import { expandPipelineCalls } from "@sverka/workflow";
 //#region src/plugin/errors.ts
 var PluginError = class extends Error {
@@ -3233,6 +3233,599 @@ function compileGitlab(graph) {
 	return new GitlabTarget().compile(graph);
 }
 //#endregion
-export { PluginError, analyzeCapabilities, compileGithub, compileGitlab, createPluginRegistry, defineSverkaPlugin, detectCapabilities, loadBundledRegistry, pinActionRef };
+//#region src/github/importer.ts
+/**
+* Import a GitHub Actions workflow YAML string into a Definition Graph.
+* Lossy: unmappable constructs produce diagnostics.
+*/
+function importGithub(source) {
+	return importGithubWithDiagnostics(source).graph;
+}
+/**
+* Import a GitHub Actions workflow YAML string with diagnostics.
+*/
+function importGithubWithDiagnostics(source) {
+	const diagnostics = [];
+	let doc;
+	try {
+		doc = parse(source);
+	} catch (err) {
+		throw new GithubTargetError(`failed to parse GitHub workflow YAML: ${err instanceof Error ? err.message : String(err)}`, "IMPORT_FAILED");
+	}
+	if (!doc || typeof doc !== "object") throw new GithubTargetError("GitHub workflow YAML is not a valid object", "IMPORT_FAILED");
+	const projectId = "imported";
+	const steps = [];
+	const entries = [];
+	const trigger = parseTrigger(doc.on, diagnostics);
+	const jobs = doc.jobs;
+	if (jobs) for (const [jobId, job] of Object.entries(jobs)) {
+		if (job === null || typeof job !== "object") {
+			diagnostics.push({
+				severity: "warn",
+				message: `job '${jobId}' is not a valid object, skipping`
+			});
+			continue;
+		}
+		steps.push(parseJob(jobId, job, diagnostics));
+	}
+	if (steps.length > 0) entries.push({
+		id: "ci/default",
+		trigger,
+		roots: steps.map((s) => s.id)
+	});
+	return {
+		graph: { project: {
+			id: projectId,
+			pipelines: [{
+				id: "ci",
+				inputs: {},
+				entries,
+				steps,
+				outputs: []
+			}]
+		} },
+		diagnostics
+	};
+}
+/**
+* Parse the `on:` field of a GitHub workflow into a Sverka Trigger.
+*/
+function parseTrigger(onField, diagnostics) {
+	if (typeof onField === "string") return parseStringTrigger(onField);
+	if (onField && typeof onField === "object") return parseObjectTrigger(onField, diagnostics);
+	return { kind: "push" };
+}
+function parseStringTrigger(onField) {
+	if (onField === "push") return { kind: "push" };
+	if (onField === "pull_request") return { kind: "changeRequest" };
+	return { kind: "manual" };
+}
+function parseObjectTrigger(on, diagnostics) {
+	if ("push" in on) return { kind: "push" };
+	if ("pull_request" in on) return { kind: "changeRequest" };
+	if ("workflow_dispatch" in on) return { kind: "manual" };
+	if ("schedule" in on) {
+		diagnostics.push({
+			severity: "info",
+			message: "schedule trigger imported as manual"
+		});
+		return { kind: "manual" };
+	}
+	return { kind: "manual" };
+}
+/**
+* Parse a single GitHub job into a Sverka StepDefinition.
+*/
+function parseJob(jobId, job, diagnostics) {
+	const stepId = `ci/${jobId}`;
+	const operations = [];
+	const dependencies = [];
+	parseJobNeeds(job, dependencies);
+	const jobSteps = job.steps;
+	if (jobSteps) for (const step of jobSteps) parseJobStep(jobId, step, operations, diagnostics);
+	recordJobDiagnostics(jobId, job, diagnostics);
+	const runtime = {};
+	const runner = parseRunsOn(job["runs-on"]);
+	return {
+		id: stepId,
+		runtime,
+		operations,
+		inputs: [],
+		outputs: [],
+		dependencies,
+		...runner !== void 0 ? { runner } : {}
+	};
+}
+/**
+* Parse a job's `needs` field into dependencies.
+*/
+function parseJobNeeds(job, dependencies) {
+	if (typeof job.needs === "string") dependencies.push({
+		kind: "control",
+		producer: `ci/${job.needs}`
+	});
+	else if (Array.isArray(job.needs)) {
+		for (const need of job.needs) if (typeof need === "string") dependencies.push({
+			kind: "control",
+			producer: `ci/${need}`
+		});
+	}
+}
+/**
+* Parse a single GitHub step into one or more operations.
+*/
+function parseJobStep(jobId, step, operations, diagnostics) {
+	if (typeof step.run === "string") {
+		operations.push({
+			kind: "shell",
+			command: step.run
+		});
+		return;
+	}
+	if (typeof step.uses === "string") parseUsesStep(jobId, step, step.uses, operations, diagnostics);
+}
+/**
+* Parse a `uses:` step by dispatching to the appropriate action handler.
+*/
+function parseUsesStep(jobId, step, uses, operations, diagnostics) {
+	if (uses.includes("action-gh-release")) operations.push(parseReleaseAction(step));
+	else if (uses.includes("upload-pages-artifact")) operations.push(parseDeployPagesAction(step));
+	else if (uses.includes("actions/checkout")) {} else if (uses.includes("actions/upload-artifact")) operations.push(parseUploadArtifactAction(step));
+	else if (uses.includes("actions/download-artifact")) parseDownloadArtifactAction(jobId, step, operations, diagnostics);
+	else diagnostics.push({
+		severity: "info",
+		message: `unmapped action '${uses}' in job '${jobId}' — skipped`,
+		path: jobId
+	});
+}
+/**
+* Parse a release action (softprops/action-gh-release) into a release operation.
+*/
+function parseReleaseAction(step) {
+	const withMap = step.with ?? {};
+	return {
+		kind: "release",
+		tag: typeof withMap.tag_name === "string" ? withMap.tag_name : "unknown",
+		...typeof withMap.name === "string" ? { name: withMap.name } : {},
+		...typeof withMap.body === "string" ? { description: withMap.body } : {},
+		...typeof withMap.assets === "string" ? { assets: withMap.assets.split("\n").filter((s) => s.length > 0) } : {},
+		...typeof withMap.draft === "boolean" ? { draft: withMap.draft } : {},
+		...typeof withMap.prerelease === "boolean" ? { prerelease: withMap.prerelease } : {}
+	};
+}
+/**
+* Parse an upload-pages-artifact action into a deployPages operation.
+*/
+function parseDeployPagesAction(step) {
+	const withMap = step.with ?? {};
+	return {
+		kind: "deployPages",
+		path: typeof withMap.path === "string" ? withMap.path : "dist/"
+	};
+}
+/**
+* Parse an actions/upload-artifact action into an exportArtifact operation.
+*/
+function parseUploadArtifactAction(step) {
+	const withMap = step.with ?? {};
+	return {
+		kind: "exportArtifact",
+		name: typeof withMap.name === "string" ? withMap.name : "artifact",
+		path: typeof withMap.path === "string" ? withMap.path : "."
+	};
+}
+/**
+* Parse an actions/download-artifact action into an importArtifact operation.
+*/
+function parseDownloadArtifactAction(jobId, step, operations, diagnostics) {
+	const withMap = step.with ?? {};
+	const artifactName = typeof withMap.name === "string" ? withMap.name : "artifact";
+	const from = resolveArtifactProducer(artifactName);
+	operations.push({
+		kind: "importArtifact",
+		name: artifactName,
+		from,
+		output: artifactName
+	});
+	if (from === "ci/unknown") diagnostics.push({
+		severity: "warn",
+		message: `download-artifact in job '${jobId}' — producer could not be resolved from name '${artifactName}', may need manual correction`,
+		path: jobId
+	});
+}
+/**
+* Try to resolve the producing job from an artifact name.
+* Artifact names follow the pattern `<stepId>-<outputName>`, so the producer
+* is `ci/<stepId>`.
+*/
+function resolveArtifactProducer(artifactName) {
+	const dashIdx = artifactName.lastIndexOf("-");
+	if (dashIdx > 0) return `ci/${artifactName.slice(0, dashIdx)}`;
+	return "ci/unknown";
+}
+/**
+* Parse `runs-on` into a RunnerSpec.
+* Supports string, array, and object forms.
+*/
+function parseRunsOn(runsOn) {
+	if (typeof runsOn === "string") return { labels: [runsOn] };
+	if (Array.isArray(runsOn)) {
+		const labels = runsOn.filter((v) => typeof v === "string");
+		if (labels.length > 0) return { labels };
+	}
+	if (runsOn && typeof runsOn === "object") {
+		const obj = runsOn;
+		const group = typeof obj.group === "string" ? obj.group : void 0;
+		const labels = Array.isArray(obj.labels) ? obj.labels.filter((v) => typeof v === "string") : [];
+		if (labels.length > 0 || group !== void 0) return {
+			labels,
+			...group !== void 0 ? { group } : {}
+		};
+	}
+}
+/**
+* Record diagnostics for unmappable job-level constructs.
+*/
+function recordJobDiagnostics(jobId, job, diagnostics) {
+	if (job.strategy) diagnostics.push({
+		severity: "warn",
+		message: `job '${jobId}' has strategy/matrix — not imported`,
+		path: jobId
+	});
+	if (job.services) diagnostics.push({
+		severity: "info",
+		message: `job '${jobId}' has services — not imported`,
+		path: jobId
+	});
+	if (job.environment) diagnostics.push({
+		severity: "info",
+		message: `job '${jobId}' has environment — not imported`,
+		path: jobId
+	});
+}
+//#endregion
+//#region src/gitlab/importer.ts
+/**
+* Import a GitLab CI YAML string into a Definition Graph.
+* Lossy: unmappable constructs produce diagnostics.
+*/
+function importGitlab(source) {
+	return importGitlabWithDiagnostics(source).graph;
+}
+/**
+* Import a GitLab CI YAML string with diagnostics for unmappable constructs.
+*/
+function importGitlabWithDiagnostics(source) {
+	const diagnostics = [];
+	const doc = parseGitlabDoc(source);
+	const projectId = "imported";
+	const steps = [];
+	const entries = [];
+	const pipelineRules = [];
+	extractWorkflowRules(doc, pipelineRules);
+	const reservedKeys = /* @__PURE__ */ new Set([
+		"stages",
+		"variables",
+		"workflow",
+		"include",
+		"image",
+		"before_script",
+		"after_script",
+		"cache",
+		"services",
+		"default"
+	]);
+	for (const [key, value] of Object.entries(doc)) {
+		if (reservedKeys.has(key)) continue;
+		if (key.startsWith(".")) continue;
+		if (!value || typeof value !== "object") continue;
+		const step = convertJobToStep(key, value, diagnostics);
+		steps.push(step);
+	}
+	if (steps.length > 0 && entries.length === 0) entries.push({
+		id: "ci/default",
+		trigger: { kind: "push" },
+		roots: steps.map((s) => s.id)
+	});
+	return {
+		graph: { project: {
+			id: projectId,
+			pipelines: [{
+				id: "ci",
+				inputs: {},
+				entries,
+				steps,
+				outputs: [],
+				...pipelineRules.length > 0 ? { rules: pipelineRules } : {}
+			}]
+		} },
+		diagnostics
+	};
+}
+/**
+* Parse and validate the GitLab CI YAML source into a record.
+*/
+function parseGitlabDoc(source) {
+	let doc;
+	try {
+		doc = parse(source);
+	} catch (err) {
+		throw new GitlabTargetError(`failed to parse GitLab CI YAML: ${err instanceof Error ? err.message : String(err)}`, "IMPORT_FAILED");
+	}
+	if (!doc || typeof doc !== "object") throw new GitlabTargetError("GitLab CI YAML is not a valid object", "IMPORT_FAILED");
+	return doc;
+}
+/**
+* Extract workflow:rules into pipeline rules.
+*/
+function extractWorkflowRules(doc, pipelineRules) {
+	const workflow = doc.workflow;
+	if (!workflow?.rules) return;
+	for (const rule of workflow.rules) pipelineRules.push(convertWorkflowRule(rule));
+}
+/**
+* Extract string variables from a rule's `variables` field.
+*/
+function extractRuleVariables(rule) {
+	if (rule.variables && typeof rule.variables === "object") return Object.fromEntries(Object.entries(rule.variables).filter(([, v]) => typeof v === "string"));
+}
+function convertWorkflowRule(rule) {
+	const pr = {};
+	if (typeof rule.if === "string") pr.if = rule.if;
+	if (Array.isArray(rule.changes)) pr.changes = rule.changes;
+	if (Array.isArray(rule.exists)) pr.exists = rule.exists;
+	const variables = extractRuleVariables(rule);
+	if (variables) pr.variables = variables;
+	if (rule.when === "always" || rule.when === "never") pr.when = rule.when;
+	return pr;
+}
+/**
+* Convert a single GitLab job into a StepDefinition.
+*/
+function convertJobToStep(key, job, diagnostics) {
+	const stepId = `ci/${key}`;
+	const operations = [];
+	const dependencies = [];
+	convertScript(job, operations);
+	convertNeeds(job, dependencies);
+	convertTrigger(key, job, operations, diagnostics);
+	convertRelease(job, operations);
+	convertPages(job, operations);
+	convertArtifacts(job, operations);
+	recordUnmappableConstructs(key, job, diagnostics);
+	const runtime = typeof job.image === "string" ? {
+		mode: "container",
+		image: job.image
+	} : {};
+	const rules = convertJobRules(job);
+	const beforeScript = convertScriptArray(job, "before_script");
+	const afterScript = convertScriptArray(job, "after_script");
+	const delay = convertDelay(job);
+	return {
+		id: stepId,
+		runtime,
+		operations,
+		inputs: [],
+		outputs: [],
+		dependencies,
+		...rules.length > 0 ? { rules } : {},
+		...beforeScript !== void 0 ? { beforeScript } : {},
+		...afterScript !== void 0 ? { afterScript } : {},
+		...delay !== void 0 ? { delay } : {}
+	};
+}
+/**
+* Convert `script` into shell operations.
+*/
+function convertScript(job, operations) {
+	if (typeof job.script === "string") operations.push({
+		kind: "shell",
+		command: job.script
+	});
+	else if (Array.isArray(job.script)) {
+		for (const line of job.script) if (typeof line === "string") operations.push({
+			kind: "shell",
+			command: line
+		});
+	}
+}
+/**
+* Convert `needs` into dependencies.
+*/
+function convertNeeds(job, dependencies) {
+	if (Array.isArray(job.needs)) {
+		for (const need of job.needs) if (typeof need === "string") dependencies.push({
+			kind: "control",
+			producer: `ci/${need}`
+		});
+		else if (need && typeof need === "object" && typeof need.job === "string") {
+			const needJob = need.job;
+			dependencies.push({
+				kind: "control",
+				producer: `ci/${needJob}`
+			});
+		}
+	} else if (typeof job.needs === "string") dependencies.push({
+		kind: "control",
+		producer: `ci/${job.needs}`
+	});
+}
+/**
+* Convert `trigger` into downstream/child pipeline diagnostics.
+*/
+function convertTrigger(key, job, operations, diagnostics) {
+	if (!job.trigger || typeof job.trigger !== "object") return;
+	const trigger = job.trigger;
+	if (typeof trigger.project === "string") {
+		operations.push({
+			kind: "diagnostic",
+			message: `imported downstream trigger to project: ${trigger.project}`,
+			severity: "info"
+		});
+		diagnostics.push({
+			severity: "warn",
+			message: `job '${key}' has a downstream project trigger — imported as diagnostic. Manual reconstruction needed.`,
+			path: key
+		});
+	} else if (Array.isArray(trigger.include)) diagnostics.push({
+		severity: "warn",
+		message: `job '${key}' has a child pipeline trigger — imported as diagnostic. Manual reconstruction needed.`,
+		path: key
+	});
+}
+/**
+* Convert `release` into a release operation.
+*/
+function convertRelease(job, operations) {
+	if (!job.release || typeof job.release !== "object") return;
+	const release = job.release;
+	const assets = release.assets;
+	operations.push({
+		kind: "release",
+		tag: typeof release.tag_name === "string" ? release.tag_name : "unknown",
+		...typeof release.name === "string" ? { name: release.name } : {},
+		...typeof release.description === "string" ? { description: release.description } : {},
+		...assets?.links ? { assets: assets.links.map((l) => l.url ?? l.name ?? "unknown") } : {}
+	});
+}
+/**
+* Convert `pages` into a deployPages operation.
+*/
+function convertPages(job, operations) {
+	if (!job.pages || typeof job.pages !== "object") return;
+	const pages = job.pages;
+	operations.push({
+		kind: "deployPages",
+		path: typeof pages.publish === "string" ? pages.publish : "public/",
+		...typeof pages.path_prefix === "string" ? { prefix: pages.path_prefix } : {}
+	});
+}
+/**
+* Record diagnostics for constructs that cannot be mapped to the IR.
+*/
+function recordUnmappableConstructs(key, job, diagnostics) {
+	if (job.cache) diagnostics.push({
+		severity: "info",
+		message: `job '${key}' has cache — not imported`,
+		path: key
+	});
+	if (job.services) diagnostics.push({
+		severity: "info",
+		message: `job '${key}' has services — not imported`,
+		path: key
+	});
+	if (job.matrix) diagnostics.push({
+		severity: "warn",
+		message: `job '${key}' has matrix — not imported`,
+		path: key
+	});
+}
+/**
+* Valid `when` values for job-level rules.
+*/
+const JOB_RULE_WHEN_VALUES = /* @__PURE__ */ new Set([
+	"on_success",
+	"on_failure",
+	"always",
+	"never",
+	"manual"
+]);
+/**
+* Convert a single raw rule object into a StepDefinition rule entry.
+*/
+function convertJobRuleEntry(r) {
+	const ruleEntry = {};
+	if (typeof r.if === "string") ruleEntry.if = r.if;
+	if (Array.isArray(r.changes)) ruleEntry.changes = r.changes;
+	if (Array.isArray(r.exists)) ruleEntry.exists = r.exists;
+	if (typeof r.when === "string" && JOB_RULE_WHEN_VALUES.has(r.when)) ruleEntry.when = r.when;
+	const variables = extractRuleVariables(r);
+	if (variables) ruleEntry.variables = variables;
+	return ruleEntry;
+}
+/**
+* Convert job-level `rules` into StepDefinition rules.
+*/
+function convertJobRules(job) {
+	if (!Array.isArray(job.rules)) return [];
+	const rules = [];
+	for (const rule of job.rules) {
+		if (!rule || typeof rule !== "object") continue;
+		rules.push(convertJobRuleEntry(rule));
+	}
+	return rules;
+}
+/**
+* Convert a script array field (before_script/after_script) from a job.
+*/
+function convertScriptArray(job, field) {
+	const value = job[field];
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) {
+		const lines = value.filter((v) => typeof v === "string");
+		if (lines.length > 0) return lines;
+	}
+}
+/**
+* Convert `when: delayed` + `start_in` to a delay string.
+*/
+function convertDelay(job) {
+	if (job.when === "delayed" && typeof job.start_in === "string") return job.start_in;
+}
+/**
+* Convert artifact `paths` into exportArtifact operations.
+*/
+function convertArtifactPaths(artifacts, operations) {
+	const paths = artifacts.paths;
+	if (!Array.isArray(paths)) return;
+	for (const path of paths) if (typeof path === "string") operations.push({
+		kind: "exportArtifact",
+		name: path.split("/").pop() ?? path,
+		path
+	});
+}
+/**
+* Convert artifact `reports` into report operations.
+* Reports are noted but not fully mapped — they require spec types.
+* Unsupported report keys are silently skipped to avoid producing invalid
+* graph nodes that violate the CDK report-type contract.
+*/
+const SUPPORTED_REPORT_TYPES = /* @__PURE__ */ new Set([
+	"junit",
+	"coverage",
+	"dotenv",
+	"sast",
+	"dast",
+	"dependencyScanning",
+	"containerScanning",
+	"licenseScanning",
+	"performance",
+	"metrics",
+	"terraform",
+	"quality",
+	"sarif"
+]);
+function convertArtifactReports(artifacts, operations) {
+	if (!artifacts.reports || typeof artifacts.reports !== "object") return;
+	const reports = artifacts.reports;
+	for (const [type, value] of Object.entries(reports)) if (typeof value === "string" && SUPPORTED_REPORT_TYPES.has(type)) operations.push({
+		kind: "report",
+		spec: {
+			type,
+			path: value
+		}
+	});
+}
+/**
+* Convert `artifacts` into exportArtifact operations.
+*/
+function convertArtifacts(job, operations) {
+	if (!job.artifacts || typeof job.artifacts !== "object") return;
+	const artifacts = job.artifacts;
+	convertArtifactPaths(artifacts, operations);
+	convertArtifactReports(artifacts, operations);
+}
+//#endregion
+export { GithubTarget, GithubTargetError, GitlabTarget, GitlabTargetError, PluginError, analyzeCapabilities, compileGithub, compileGitlab, createPluginRegistry, defineSverkaPlugin, detectCapabilities, githubCapabilities, gitlabCapabilities, importGithub, importGithubWithDiagnostics, importGitlab, importGitlabWithDiagnostics, loadBundledRegistry, pinActionRef };
 
 //# sourceMappingURL=index.mjs.map