@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/local-executor/job-runner.js

@@ -0,0 +1,307 @@
+import "../chunk-gOLHoazu.js";
+import { formatter } from "../test-runner/output-formatter.js";
+import { createStepContext } from "../test-runner/step-context.js";
+import { createRuleContext, evaluateRules as evaluateRulesWithFormatting } from "../test-runner/rule-evaluator.js";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { applyIncludeExclude, expandMatrix, isDynamicJobFn, setJobOutputsMap, setStepOutputsMap, setStepRefMap } from "@kici-dev/sdk";
+//#region src/local-executor/job-runner.ts
+/**
+* Job resolution (matrix/dynamic) and single-job execution with step context.
+*
+* Handles:
+* - Static job resolution
+* - Matrix expansion into multiple ResolvedJob instances
+* - Dynamic job function evaluation
+* - Single-job step-by-step execution with rules, abort, and output chaining
+*/
+/**
+* Resolve SDK output setter functions from the workflow's module instance.
+* Ensures output maps are set on the same SDK module the workflow code uses.
+*/
+async function resolveSdkSetters(kiciDir) {
+	if (kiciDir) try {
+		const sdk = await import(pathToFileURL(path.join(kiciDir, "node_modules", "@kici-dev", "sdk", "dist", "index.js")).href);
+		return {
+			setStepOutputsMap: sdk.setStepOutputsMap,
+			setStepRefMap: sdk.setStepRefMap,
+			setJobOutputsMap: sdk.setJobOutputsMap
+		};
+	} catch {}
+	return {
+		setStepOutputsMap,
+		setStepRefMap,
+		setJobOutputsMap
+	};
+}
+/**
+* Format matrix values into a display string for the job name.
+* Single-dimension: "node-18"
+* Multi-dimensional: "linux, 18"
+*/
+function formatMatrixSuffix(matrixValues) {
+	if ("value" in matrixValues && matrixValues.value !== void 0) return matrixValues.value;
+	return Object.values(matrixValues).filter((v) => v !== void 0).join(", ");
+}
+/**
+* Resolve a needs entry to a string name.
+* Handles Job objects, strings, DynamicGroupRef, and object forms.
+*/
+function resolveNeedName(need) {
+	if (typeof need === "string") return need;
+	if ("name" in need) return need.name;
+	if ("group" in need) return `__group:${need.group}`;
+	return need.name;
+}
+/**
+* Resolve all jobs in a workflow, expanding matrix jobs and evaluating dynamic jobs.
+*
+* - Static jobs: create ResolvedJob with name, needs, job reference
+* - Matrix jobs: use expandMatrix() from SDK, create one ResolvedJob per combination
+* - Dynamic job functions: evaluate the function, recursively resolve results
+* - Fan-in: if a job needs a matrix-expanded job, it needs ALL instances
+*/
+async function resolveJobs(workflow, event) {
+	const resolved = [];
+	const expansionMap = /* @__PURE__ */ new Map();
+	for (const jobOrFn of workflow.jobs) if (isDynamicJobFn(jobOrFn)) {
+		const generatedJobs = await jobOrFn({
+			$: (await import("zx")).$,
+			ctx: {
+				workflow: { name: workflow.name },
+				event: {
+					type: event.type,
+					...event.payload
+				}
+			},
+			log: {
+				info: () => {},
+				warn: () => {},
+				error: () => {},
+				debug: () => {}
+			},
+			env: { ...process.env },
+			kici: { infrastructure: { list: () => Promise.resolve({
+				scalers: [],
+				agents: []
+			}) } }
+		});
+		for (const genJob of generatedJobs) {
+			const genResolved = await resolveStaticJob(genJob, expansionMap);
+			resolved.push(...genResolved);
+		}
+	} else {
+		const jobResolved = await resolveStaticJob(jobOrFn, expansionMap);
+		resolved.push(...jobResolved);
+	}
+	for (const r of resolved) r.resolvedNeeds = resolveNeedsWithExpansion(r.job, expansionMap);
+	return resolved;
+}
+/**
+* Resolve a single static job, potentially expanding its matrix.
+*/
+async function resolveStaticJob(job, expansionMap) {
+	if (!job.matrix) {
+		expansionMap.set(job.name, [job.name]);
+		return [{
+			job,
+			expandedName: job.name,
+			matrixValues: {},
+			resolvedNeeds: []
+		}];
+	}
+	let staticMatrix;
+	if (typeof job.matrix === "function") {
+		const matrixContext = {
+			$: (await import("zx")).$,
+			ctx: {
+				workflow: { name: "" },
+				job: {
+					name: job.name,
+					runsOn: job.runsOn
+				}
+			},
+			log: {
+				info: () => {},
+				warn: () => {},
+				error: () => {},
+				debug: () => {}
+			},
+			env: { ...process.env }
+		};
+		staticMatrix = await job.matrix(matrixContext);
+	} else staticMatrix = job.matrix;
+	let expanded = expandMatrix(staticMatrix);
+	if (job.include || job.exclude) expanded = applyIncludeExclude(expanded, job.include, job.exclude);
+	const expandedNames = [];
+	const results = [];
+	for (const matrixValues of expanded) {
+		const suffix = formatMatrixSuffix(matrixValues);
+		const expandedName = `${job.name} (${suffix})`;
+		expandedNames.push(expandedName);
+		results.push({
+			job,
+			expandedName,
+			matrixValues,
+			resolvedNeeds: []
+		});
+	}
+	expansionMap.set(job.name, expandedNames);
+	return results;
+}
+/**
+* Resolve needs with matrix expansion awareness.
+* If a job needs a matrix-expanded job, it needs ALL expanded instances (fan-in).
+*/
+function resolveNeedsWithExpansion(job, expansionMap) {
+	if (!job.needs || job.needs.length === 0) return [];
+	const resolvedNeeds = [];
+	for (const need of job.needs) {
+		const needName = resolveNeedName(need);
+		const expandedNames = expansionMap.get(needName);
+		if (expandedNames) resolvedNeeds.push(...expandedNames);
+		else resolvedNeeds.push(needName);
+	}
+	return resolvedNeeds;
+}
+/**
+* Execute a single resolved job: evaluate rules, run steps sequentially,
+* check abort signal between steps, collect outputs.
+*/
+async function executeResolvedJob(resolvedJob, context) {
+	const { expandedName, matrixValues } = resolvedJob;
+	const startTime = Date.now();
+	const hasMatrix = Object.keys(matrixValues).length > 0;
+	try {
+		return await executeResolvedJobInner(resolvedJob, context, startTime);
+	} catch (e) {
+		const durationMs = Date.now() - startTime;
+		const error = e instanceof Error ? e : new Error(String(e));
+		formatter.logJobFailure(expandedName, durationMs, error);
+		return {
+			name: expandedName,
+			status: "failure",
+			durationMs,
+			steps: [],
+			error,
+			matrixValues: hasMatrix ? matrixValues : void 0
+		};
+	}
+}
+async function executeResolvedJobInner(resolvedJob, context, startTime) {
+	const { job, expandedName, matrixValues } = resolvedJob;
+	formatter.logJobStart(expandedName);
+	const sdkSetters = await resolveSdkSetters(context.kiciDir);
+	let ruleResults;
+	if (job.rules && job.rules.length > 0) {
+		const ruleContext = createRuleContext(context.event, context.event.changedFiles);
+		const ruleEval = await evaluateRulesWithFormatting(job.rules, ruleContext, expandedName);
+		ruleResults = ruleEval.results;
+		if (!ruleEval.allPassed) return {
+			name: expandedName,
+			status: "skipped",
+			durationMs: Date.now() - startTime,
+			steps: [],
+			ruleResults,
+			matrixValues: Object.keys(matrixValues).length > 0 ? matrixValues : void 0
+		};
+	}
+	const outputsMap = /* @__PURE__ */ new Map();
+	const refMap = /* @__PURE__ */ new WeakMap();
+	sdkSetters.setStepOutputsMap(outputsMap);
+	sdkSetters.setStepRefMap(refMap);
+	setStepOutputsMap(outputsMap);
+	setStepRefMap(refMap);
+	sdkSetters.setJobOutputsMap(context.jobOutputsMap);
+	setJobOutputsMap(context.jobOutputsMap);
+	const hasMatrix = Object.keys(matrixValues).length > 0;
+	const repoRoot = path.dirname(context.kiciDir);
+	const stepCtx = createStepContext({ name: context.workflowName }, {
+		name: expandedName,
+		runsOn: typeof job.runsOn === "string" ? job.runsOn : Array.isArray(job.runsOn) ? job.runsOn.join(",") : (Array.isArray(job.runsOn.labels) ? job.runsOn.labels : [job.runsOn.labels]).join(",")
+	}, repoRoot, void 0, hasMatrix ? matrixValues : void 0, context.secrets, void 0, context.event.payload, context.event.provider);
+	const stepResults = [];
+	let stepCounter = 0;
+	for (const stepOrFn of job.steps) {
+		if (context.signal.aborted) return {
+			name: expandedName,
+			status: "cancelled",
+			durationMs: Date.now() - startTime,
+			steps: stepResults,
+			ruleResults,
+			matrixValues: hasMatrix ? matrixValues : void 0,
+			cancelled: true
+		};
+		let normalizedStep;
+		if (typeof stepOrFn === "function") {
+			stepCounter++;
+			const name = `step-${stepCounter}`;
+			refMap.set(stepOrFn, name);
+			normalizedStep = {
+				_tag: "Step",
+				name,
+				run: stepOrFn
+			};
+		} else {
+			normalizedStep = stepOrFn;
+			if (!normalizedStep.name) stepCounter++;
+		}
+		formatter.logStepStart(expandedName, normalizedStep.name);
+		const stepStart = Date.now();
+		try {
+			const outputs = await normalizedStep.run(stepCtx);
+			const stepDuration = Date.now() - stepStart;
+			formatter.logStepComplete(expandedName, normalizedStep.name, stepDuration);
+			const stepResult = {
+				name: normalizedStep.name,
+				status: "success",
+				durationMs: stepDuration,
+				outputs
+			};
+			if (outputs != null) outputsMap.set(normalizedStep.name, outputs);
+			stepResults.push(stepResult);
+		} catch (e) {
+			const stepDuration = Date.now() - stepStart;
+			const error = e instanceof Error ? e : new Error(String(e));
+			formatter.logStepError(expandedName, normalizedStep.name, error);
+			stepResults.push({
+				name: normalizedStep.name,
+				status: "failure",
+				durationMs: stepDuration,
+				error
+			});
+			const durationMs = Date.now() - startTime;
+			formatter.logJobFailure(expandedName, durationMs, error);
+			return {
+				name: expandedName,
+				status: "failure",
+				durationMs,
+				steps: stepResults,
+				ruleResults,
+				matrixValues: hasMatrix ? matrixValues : void 0,
+				error
+			};
+		}
+	}
+	const stepsWithOutputs = stepResults.filter((s) => s.outputs != null);
+	if (stepsWithOutputs.length === 1 && stepResults.length === 1) context.jobOutputsMap.set(expandedName, stepsWithOutputs[0].outputs);
+	else if (stepsWithOutputs.length > 0) {
+		const aggregated = {};
+		for (const stepResult of stepsWithOutputs) aggregated[stepResult.name] = stepResult.outputs;
+		context.jobOutputsMap.set(expandedName, aggregated);
+	}
+	const durationMs = Date.now() - startTime;
+	formatter.logJobComplete(expandedName, durationMs);
+	return {
+		name: expandedName,
+		status: "success",
+		durationMs,
+		steps: stepResults,
+		ruleResults,
+		matrixValues: hasMatrix ? matrixValues : void 0
+	};
+}
+//#endregion
+export { executeResolvedJob, resolveJobs };
+
+//# sourceMappingURL=job-runner.js.map

package/dist/local-executor/output-streamer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Output formatting for local execution: tree summary, JSON, JUnit XML.
+ *
+ * - displayLocalSummary: tree-format summary with per-step timing
+ * - formatLocalJsonResult: structured JSON output
+ * - formatLocalJunitResult: JUnit XML for CI integration
+ */
+import type { WorkflowExecutionResult } from './types.js';
+/**
+ * Display tree-format execution summary to the console.
+ *
+ * Shows per-workflow, per-job, per-step timing and status.
+ * Matrix values appear in the job name.
+ */
+export declare function displayLocalSummary(results: WorkflowExecutionResult[]): void;
+/**
+ * Format workflow execution results as structured JSON.
+ *
+ * @returns JSON string with 2-space indentation.
+ */
+export declare function formatLocalJsonResult(results: WorkflowExecutionResult[]): string;
+/**
+ * Format workflow execution results as JUnit XML.
+ *
+ * Each workflow maps to a <testsuite>, each job maps to a <testcase>.
+ * Failed jobs include failure message. Skipped/cancelled jobs use <skipped />.
+ *
+ * @returns Valid JUnit XML string.
+ */
+export declare function formatLocalJunitResult(results: WorkflowExecutionResult[]): string;
+//# sourceMappingURL=output-streamer.d.ts.map

package/dist/local-executor/output-streamer.js

@@ -0,0 +1,166 @@
+import "../chunk-gOLHoazu.js";
+import pc from "picocolors";
+import { logger } from "@kici-dev/shared";
+//#region src/local-executor/output-streamer.ts
+/**
+* Output formatting for local execution: tree summary, JSON, JUnit XML.
+*
+* - displayLocalSummary: tree-format summary with per-step timing
+* - formatLocalJsonResult: structured JSON output
+* - formatLocalJunitResult: JUnit XML for CI integration
+*/
+/**
+* Display tree-format execution summary to the console.
+*
+* Shows per-workflow, per-job, per-step timing and status.
+* Matrix values appear in the job name.
+*/
+function displayLocalSummary(results) {
+	const hasFailure = results.some((r) => r.status === "failure");
+	const allSkipped = results.every((r) => r.status === "skipped");
+	logger.info("");
+	logger.info(pc.bold("=== EXECUTION SUMMARY ==="));
+	logger.info("");
+	const overallStatus = hasFailure ? pc.red("FAILED") : allSkipped ? pc.yellow("SKIPPED") : pc.green("SUCCESS");
+	logger.info(`Status: ${overallStatus}`);
+	logger.info("");
+	for (const workflow of results) {
+		logger.info(`Workflow: ${pc.bold(workflow.name)} (${workflow.durationMs}ms)`);
+		for (const job of workflow.jobs) {
+			const jobLabel = formatJobLabel(job);
+			const jobIcon = statusIcon(job.status);
+			logger.info(`  ${jobIcon} ${jobLabel} (${job.durationMs}ms)`);
+			if (job.ruleResults && job.ruleResults.length > 0) for (const rule of job.ruleResults) {
+				const rIcon = rule.passed ? pc.green("[ok]") : pc.red("[fail]");
+				logger.info(pc.gray(`    ${rIcon} rule: ${rule.label}`));
+			}
+			for (const step of job.steps) {
+				const sIcon = step.status === "success" ? pc.green("[ok]") : pc.red("[fail]");
+				logger.info(`    ${sIcon} ${step.name} (${step.durationMs}ms)`);
+				if (step.error) logger.info(pc.red(`      Error: ${step.error.message}`));
+			}
+			if (job.status === "cancelled") logger.info(pc.yellow("    (cancelled)"));
+			else if (job.status === "skipped") logger.info(pc.yellow("    (skipped: dependency failed)"));
+		}
+		logger.info("");
+	}
+	const totalDuration = results.reduce((sum, r) => sum + r.durationMs, 0);
+	logger.info(pc.gray(`Total duration: ${totalDuration}ms`));
+}
+/**
+* Format job label including matrix values if present.
+* e.g., "test (node18, ubuntu)" or just "lint"
+*/
+function formatJobLabel(job) {
+	if (job.matrixValues && Object.keys(job.matrixValues).length > 0) {
+		const vals = Object.values(job.matrixValues).join(", ");
+		if (job.name.includes("(")) return job.name;
+		return `${job.name} (${vals})`;
+	}
+	return job.name;
+}
+/**
+* Get colored status icon for a job status.
+*/
+function statusIcon(status) {
+	switch (status) {
+		case "success": return pc.green("[ok]");
+		case "failure": return pc.red("[fail]");
+		case "skipped": return pc.yellow("[skip]");
+		case "cancelled": return pc.yellow("[cancel]");
+		default: return pc.gray("[?]");
+	}
+}
+/**
+* Format workflow execution results as structured JSON.
+*
+* @returns JSON string with 2-space indentation.
+*/
+function formatLocalJsonResult(results) {
+	const passed = results.filter((r) => r.status === "success").length;
+	const failed = results.filter((r) => r.status === "failure").length;
+	const skipped = results.filter((r) => r.status === "skipped").length;
+	const totalDurationMs = results.reduce((sum, r) => sum + r.durationMs, 0);
+	const output = {
+		workflows: results.map((wf) => ({
+			name: wf.name,
+			status: wf.status,
+			durationMs: wf.durationMs,
+			jobs: wf.jobs.map((job) => ({
+				name: job.name,
+				status: job.status,
+				durationMs: job.durationMs,
+				...job.matrixValues && Object.keys(job.matrixValues).length > 0 && { matrixValues: job.matrixValues },
+				steps: job.steps.map((step) => ({
+					name: step.name,
+					status: step.status,
+					durationMs: step.durationMs,
+					...step.error && { error: step.error.message }
+				})),
+				...job.ruleResults && job.ruleResults.length > 0 && { ruleResults: job.ruleResults.map((r) => ({
+					label: r.label,
+					passed: r.passed,
+					durationMs: r.durationMs
+				})) },
+				...job.error && { error: job.error.message }
+			}))
+		})),
+		summary: {
+			totalWorkflows: results.length,
+			passed,
+			failed,
+			skipped,
+			totalDurationMs
+		}
+	};
+	return JSON.stringify(output, null, 2);
+}
+/**
+* Format workflow execution results as JUnit XML.
+*
+* Each workflow maps to a <testsuite>, each job maps to a <testcase>.
+* Failed jobs include failure message. Skipped/cancelled jobs use <skipped />.
+*
+* @returns Valid JUnit XML string.
+*/
+function formatLocalJunitResult(results) {
+	const totalTests = results.reduce((sum, r) => sum + r.jobs.length, 0);
+	const totalFailures = results.reduce((sum, r) => sum + r.jobs.filter((j) => j.status === "failure").length, 0);
+	const totalTimeSeconds = results.reduce((sum, r) => sum + r.durationMs / 1e3, 0);
+	const lines = [];
+	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+	lines.push(`<testsuites name="kici-local" tests="${totalTests}" failures="${totalFailures}" time="${totalTimeSeconds.toFixed(3)}">`);
+	for (const workflow of results) {
+		const suiteTests = workflow.jobs.length;
+		const suiteFailures = workflow.jobs.filter((j) => j.status === "failure").length;
+		const suiteTimeSeconds = workflow.durationMs / 1e3;
+		lines.push(`  <testsuite name="${escapeXml(workflow.name)}" tests="${suiteTests}" failures="${suiteFailures}" time="${suiteTimeSeconds.toFixed(3)}">`);
+		for (const job of workflow.jobs) {
+			const jobTimeSeconds = job.durationMs / 1e3;
+			const jobName = formatJobLabel(job);
+			if (job.status === "failure") {
+				const errorMsg = job.error?.message ?? "Job failed";
+				lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}">`);
+				lines.push(`      <failure message="${escapeXml(errorMsg)}">${escapeXml(errorMsg)}</failure>`);
+				lines.push("    </testcase>");
+			} else if (job.status === "skipped" || job.status === "cancelled") {
+				lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}">`);
+				lines.push("      <skipped />");
+				lines.push("    </testcase>");
+			} else lines.push(`    <testcase name="${escapeXml(jobName)}" classname="${escapeXml(workflow.name)}" time="${jobTimeSeconds.toFixed(3)}" />`);
+		}
+		lines.push("  </testsuite>");
+	}
+	lines.push("</testsuites>");
+	return lines.join("\n");
+}
+/**
+* Escape special XML characters in a string.
+*/
+function escapeXml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+export { displayLocalSummary, formatLocalJsonResult, formatLocalJunitResult };
+
+//# sourceMappingURL=output-streamer.js.map

package/dist/local-executor/payload-generator.d.ts

@@ -0,0 +1,16 @@
+import type { SimulatedEvent } from '@kici-dev/engine';
+import type { RunLocalOptions } from './types.js';
+/**
+ * Generate a SimulatedEvent from git state and CLI overrides.
+ *
+ * For push events: detects branch, SHA, and changed files from git.
+ * For PR events: uses current branch as source, 'main' (or --branch) as target.
+ * If --payload flag is provided, delegates to existing buildEventPayload.
+ * Falls back gracefully when not in a git repository.
+ *
+ * @param event - Event argument string (e.g. 'push', 'pr:open')
+ * @param options - CLI options with override fields
+ * @returns Generated SimulatedEvent
+ */
+export declare function generateEventPayload(event: string, options: RunLocalOptions): Promise<SimulatedEvent>;
+//# sourceMappingURL=payload-generator.d.ts.map

package/dist/local-executor/payload-generator.js

@@ -0,0 +1,138 @@
+import "../chunk-gOLHoazu.js";
+import { parseEventArg } from "../test-runner/event-types.js";
+import { buildEventPayload } from "../test-runner/payload-builder.js";
+import { execSync } from "node:child_process";
+//#region src/local-executor/payload-generator.ts
+const ZERO_SHA = "0000000000000000000000000000000000000000";
+/**
+* Run a git command and return trimmed output, or null on failure.
+*/
+function git(cmd) {
+	try {
+		return execSync(cmd, {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Detect current git branch name.
+*/
+function detectBranch() {
+	return git("git rev-parse --abbrev-ref HEAD");
+}
+/**
+* Detect current git HEAD SHA.
+*/
+function detectSha() {
+	return git("git rev-parse HEAD");
+}
+/**
+* Detect changed files from git diff (unstaged + staged, deduplicated).
+*/
+function detectChangedFiles() {
+	const unstaged = git("git diff --name-only HEAD");
+	const staged = git("git diff --name-only --cached");
+	const files = /* @__PURE__ */ new Set();
+	if (unstaged) for (const f of unstaged.split("\n").filter(Boolean)) files.add(f);
+	if (staged) for (const f of staged.split("\n").filter(Boolean)) files.add(f);
+	return [...files];
+}
+/**
+* Generate a SimulatedEvent from git state and CLI overrides.
+*
+* For push events: detects branch, SHA, and changed files from git.
+* For PR events: uses current branch as source, 'main' (or --branch) as target.
+* If --payload flag is provided, delegates to existing buildEventPayload.
+* Falls back gracefully when not in a git repository.
+*
+* @param event - Event argument string (e.g. 'push', 'pr:open')
+* @param options - CLI options with override fields
+* @returns Generated SimulatedEvent
+*/
+async function generateEventPayload(event, options) {
+	if (options.payload) return buildEventPayload(event, {
+		payload: options.payload,
+		branch: options.branch,
+		sha: options.sha,
+		files: options.files
+	});
+	const eventType = parseEventArg(event);
+	const detectedBranch = detectBranch() ?? "main";
+	const detectedSha = detectSha() ?? ZERO_SHA;
+	const changedFiles = options.files && options.files.length > 0 ? options.files : detectChangedFiles();
+	const branch = options.branch ?? detectedBranch;
+	const sha = options.sha ?? detectedSha;
+	switch (eventType.type) {
+		case "push": return {
+			type: "push",
+			payload: {
+				ref: `refs/heads/${branch}`,
+				after: sha,
+				before: ZERO_SHA,
+				head_commit: {
+					id: sha,
+					message: "local execution"
+				},
+				repository: { default_branch: "main" }
+			},
+			targetBranch: branch,
+			changedFiles
+		};
+		case "pull_request": {
+			const action = "action" in eventType ? eventType.action : "opened";
+			const targetBranch = options.branch ?? "main";
+			const sourceBranch = detectedBranch;
+			return {
+				type: "pull_request",
+				action,
+				payload: {
+					action,
+					number: 1,
+					pull_request: {
+						number: 1,
+						head: {
+							ref: sourceBranch,
+							sha
+						},
+						base: { ref: targetBranch }
+					},
+					repository: { default_branch: "main" }
+				},
+				targetBranch,
+				sourceBranch,
+				changedFiles
+			};
+		}
+		case "tag": return {
+			type: "tag",
+			payload: {
+				ref: `refs/tags/${branch}`,
+				after: sha,
+				repository: { default_branch: "main" }
+			},
+			targetBranch: branch,
+			changedFiles
+		};
+		default: {
+			const action = "action" in eventType ? eventType.action : void 0;
+			return {
+				type: eventType.type,
+				action,
+				payload: { repository: { default_branch: "main" } },
+				targetBranch: branch,
+				changedFiles
+			};
+		}
+	}
+}
+//#endregion
+export { generateEventPayload };
+
+//# sourceMappingURL=payload-generator.js.map

package/dist/local-executor/picker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Interactive workflow picker for `kici run local --pick`.
+ *
+ * Lists every workflow with a summary of its triggers, lets the user pick one
+ * (and a specific trigger when there are multiple), and returns the derived
+ * event arg plus workflow name. The caller feeds these back into the standard
+ * executeLocal pipeline so the run remains consistent with normal trigger
+ * matching.
+ */
+import type { Workflow } from '@kici-dev/sdk';
+export declare class PickerCancelledError extends Error {
+    constructor(message: string);
+}
+export interface PickerOptions {
+    /**
+     * Optional event-arg filter. When set, restrict the workflow list to those
+     * with at least one trigger whose derived event arg shares the same family
+     * (e.g. `filterEvent: 'pr'` keeps any workflow with a `pr:*` trigger).
+     */
+    filterEvent?: string;
+}
+export interface PickerResult {
+    event: string;
+    workflow: string;
+}
+/**
+ * Run the interactive picker.
+ *
+ * @throws PickerCancelledError when stdin is not a TTY, when no eligible
+ *   workflows exist, or when the user aborts one of the prompts.
+ */
+export declare function runPicker(workflows: Workflow[], opts?: PickerOptions): Promise<PickerResult>;
+//# sourceMappingURL=picker.d.ts.map