@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/test-runner/output-formatter.d.ts

@@ -0,0 +1,47 @@
+type ColorFn = (text: string) => string;
+/**
+ * Output formatter that prefixes messages with colored job labels.
+ */
+declare class OutputFormatter {
+    private jobIndex;
+    private colorMap;
+    /**
+     * Get consistent color for a job name.
+     */
+    getJobColor(jobName: string): ColorFn;
+    /**
+     * Log a message with job prefix.
+     */
+    logJobLine(jobName: string, message: string): void;
+    /**
+     * Log step start.
+     */
+    logStepStart(jobName: string, stepName: string): void;
+    /**
+     * Log step completion.
+     */
+    logStepComplete(jobName: string, stepName: string, durationMs: number): void;
+    /**
+     * Log step error.
+     */
+    logStepError(jobName: string, stepName: string, error: Error): void;
+    /**
+     * Log job start.
+     */
+    logJobStart(jobName: string): void;
+    /**
+     * Log job complete.
+     */
+    logJobComplete(jobName: string, durationMs: number): void;
+    /**
+     * Log job failure.
+     */
+    logJobFailure(jobName: string, durationMs: number, error: Error): void;
+    /**
+     * Log rule evaluation.
+     */
+    logRuleResult(jobName: string, ruleLabel: string, passed: boolean): void;
+}
+export declare const formatter: OutputFormatter;
+export {};
+//# sourceMappingURL=output-formatter.d.ts.map

package/dist/test-runner/output-formatter.js

@@ -0,0 +1,92 @@
+import "../chunk-gOLHoazu.js";
+import pc from "picocolors";
+import { logger } from "@kici-dev/shared";
+//#region src/test-runner/output-formatter.ts
+const JOB_COLORS = [
+	pc.cyan,
+	pc.green,
+	pc.yellow,
+	pc.magenta,
+	pc.blue
+];
+/**
+* Output formatter that prefixes messages with colored job labels.
+*/
+var OutputFormatter = class {
+	jobIndex = 0;
+	colorMap = /* @__PURE__ */ new Map();
+	/**
+	* Get consistent color for a job name.
+	*/
+	getJobColor(jobName) {
+		if (!this.colorMap.has(jobName)) {
+			const color = JOB_COLORS[this.jobIndex % JOB_COLORS.length];
+			this.colorMap.set(jobName, color);
+			this.jobIndex++;
+		}
+		return this.colorMap.get(jobName);
+	}
+	/**
+	* Log a message with job prefix.
+	*/
+	logJobLine(jobName, message) {
+		const prefix = this.getJobColor(jobName)(`[${jobName}]`);
+		const lines = message.split("\n");
+		for (const line of lines) if (line.trim()) logger.info(`${prefix} ${line}`);
+	}
+	/**
+	* Log step start.
+	*/
+	logStepStart(jobName, stepName) {
+		const color = this.getJobColor(jobName);
+		logger.info(color(`[${jobName}]`) + pc.gray(` -> ${stepName}`));
+	}
+	/**
+	* Log step completion.
+	*/
+	logStepComplete(jobName, stepName, durationMs) {
+		const color = this.getJobColor(jobName);
+		logger.info(color(`[${jobName}]`) + pc.green(` ✓ ${stepName}`) + pc.gray(` (${durationMs}ms)`));
+	}
+	/**
+	* Log step error.
+	*/
+	logStepError(jobName, stepName, error) {
+		const color = this.getJobColor(jobName);
+		logger.error(color(`[${jobName}]`) + pc.red(` ✗ ${stepName}: ${error.message}`));
+	}
+	/**
+	* Log job start.
+	*/
+	logJobStart(jobName) {
+		const color = this.getJobColor(jobName);
+		logger.info(color(`[${jobName}]`) + pc.bold(" Starting..."));
+	}
+	/**
+	* Log job complete.
+	*/
+	logJobComplete(jobName, durationMs) {
+		const color = this.getJobColor(jobName);
+		logger.info(color(`[${jobName}]`) + pc.green(" ✓ Complete") + pc.gray(` (${durationMs}ms)`));
+	}
+	/**
+	* Log job failure.
+	*/
+	logJobFailure(jobName, durationMs, error) {
+		const color = this.getJobColor(jobName);
+		logger.error(color(`[${jobName}]`) + pc.red(` ✗ Failed: ${error.message}`) + pc.gray(` (${durationMs}ms)`));
+	}
+	/**
+	* Log rule evaluation.
+	*/
+	logRuleResult(jobName, ruleLabel, passed) {
+		const color = this.getJobColor(jobName);
+		const status = passed ? pc.green("✓ passed") : pc.red("✗ failed");
+		logger.info(color(`[${jobName}]`) + pc.gray(` rule "${ruleLabel}": `) + status);
+	}
+};
+const formatter = new OutputFormatter();
+//#endregion
+export { formatter };
+
+//# sourceMappingURL=output-formatter.js.map

package/dist/test-runner/payload-builder.d.ts

@@ -0,0 +1,20 @@
+import type { SimulatedEvent } from '@kici-dev/engine';
+export interface PayloadOptions {
+    /** Path to custom fixture file */
+    payload?: string;
+    /** Override branch name */
+    branch?: string;
+    /** Override PR number */
+    pr?: number;
+    /** Override repository (owner/name) */
+    repo?: string;
+    /** Override commit SHA */
+    sha?: string;
+    /** Simulate changed file paths for onChangedFiles trigger matching */
+    files?: string[];
+}
+/**
+ * Build event payload from default fixture, custom file, and CLI overrides.
+ */
+export declare function buildEventPayload(eventArg: string, options: PayloadOptions): Promise<SimulatedEvent>;
+//# sourceMappingURL=payload-builder.d.ts.map

package/dist/test-runner/payload-builder.js

@@ -0,0 +1,216 @@
+import "../chunk-gOLHoazu.js";
+import { getDefaultFixture } from "../fixtures/defaults/index.js";
+import { detectRepoFromGit } from "./git-detector.js";
+import { parseEventArg } from "./event-types.js";
+import { readFile } from "node:fs/promises";
+//#region src/test-runner/payload-builder.ts
+/**
+* Deep merge objects (simple implementation for fixture overrides).
+*/
+function deepMerge(base, overrides) {
+	const result = { ...base };
+	for (const [key, value] of Object.entries(overrides)) if (value !== void 0 && value !== null) if (typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object") result[key] = deepMerge(result[key], value);
+	else result[key] = value;
+	return result;
+}
+/**
+* Build event payload from default fixture, custom file, and CLI overrides.
+*/
+async function buildEventPayload(eventArg, options) {
+	const eventType = parseEventArg(eventArg);
+	if (isInternalEventType(eventType)) return buildInternalEventPayload(eventType, options);
+	let payload;
+	if (options.payload) {
+		const content = await readFile(options.payload, "utf-8");
+		payload = JSON.parse(content);
+	} else payload = getDefaultFixture(eventArg);
+	const repoInfo = options.repo ? null : await detectRepoFromGit();
+	const overrides = {};
+	if (options.repo) {
+		const [owner, name] = options.repo.split("/");
+		overrides.repository = {
+			owner: { login: owner },
+			name,
+			full_name: options.repo
+		};
+	} else if (repoInfo) overrides.repository = {
+		owner: { login: repoInfo.owner },
+		name: repoInfo.name,
+		full_name: `${repoInfo.owner}/${repoInfo.name}`
+	};
+	if (options.sha) switch (eventType.type) {
+		case "push":
+		case "tag":
+			overrides.after = options.sha;
+			break;
+		case "status":
+			overrides.sha = options.sha;
+			break;
+		case "pull_request":
+		case "review":
+		case "review_comment":
+			overrides.pull_request = { head: { sha: options.sha } };
+			break;
+		case "workflow_run":
+			overrides.workflow_run = { head_sha: options.sha };
+			break;
+	}
+	if (options.branch) switch (eventType.type) {
+		case "push":
+			overrides.ref = `refs/heads/${options.branch}`;
+			break;
+		case "tag":
+			overrides.ref = `refs/tags/${options.branch}`;
+			break;
+		case "pull_request":
+		case "review":
+		case "review_comment":
+			overrides.pull_request = {
+				...overrides.pull_request ?? {},
+				base: { ref: options.branch }
+			};
+			break;
+		case "release":
+			overrides.release = { target_commitish: options.branch };
+			break;
+		case "create":
+		case "delete":
+			overrides.ref = options.branch;
+			break;
+		case "workflow_run":
+			overrides.workflow_run = {
+				...overrides.workflow_run ?? {},
+				head_branch: options.branch
+			};
+			break;
+	}
+	if (options.pr && (eventType.type === "pull_request" || eventType.type === "review" || eventType.type === "review_comment")) {
+		overrides.number = options.pr;
+		overrides.pull_request = {
+			...overrides.pull_request ?? {},
+			number: options.pr
+		};
+	}
+	const mergedPayload = deepMerge(payload, overrides);
+	let targetBranch = "main";
+	let sourceBranch;
+	const defaultBranch = mergedPayload.repository?.default_branch ?? "main";
+	switch (eventType.type) {
+		case "push":
+			targetBranch = (mergedPayload.ref ?? "refs/heads/main").replace("refs/heads/", "");
+			break;
+		case "tag":
+			targetBranch = (mergedPayload.ref ?? "refs/tags/v0.0.0").replace("refs/tags/", "");
+			break;
+		case "pull_request": {
+			const pr = mergedPayload.pull_request;
+			targetBranch = (pr?.base)?.ref ?? defaultBranch;
+			sourceBranch = (pr?.head)?.ref;
+			break;
+		}
+		case "comment":
+			targetBranch = (mergedPayload.issue?.pull_request)?.base_ref ?? defaultBranch;
+			break;
+		case "review":
+		case "review_comment": {
+			const pr = mergedPayload.pull_request;
+			targetBranch = (pr?.base)?.ref ?? defaultBranch;
+			sourceBranch = (pr?.head)?.ref;
+			break;
+		}
+		case "release":
+			targetBranch = mergedPayload.release?.target_commitish ?? defaultBranch;
+			break;
+		case "dispatch":
+			targetBranch = defaultBranch;
+			break;
+		case "create":
+		case "delete":
+			targetBranch = mergedPayload.ref ?? defaultBranch;
+			if ("refType" in eventType && eventType.refType) mergedPayload.ref_type = eventType.refType;
+			break;
+		case "status":
+			targetBranch = mergedPayload.branches?.[0]?.name ?? defaultBranch;
+			break;
+		case "workflow_run":
+			targetBranch = mergedPayload.workflow_run?.head_branch ?? defaultBranch;
+			break;
+		case "fork":
+		case "star":
+		case "watch":
+			targetBranch = defaultBranch;
+			break;
+	}
+	return {
+		type: eventType.type,
+		action: "action" in eventType ? eventType.action : void 0,
+		payload: mergedPayload,
+		targetBranch,
+		sourceBranch,
+		changedFiles: options.files ?? []
+	};
+}
+/**
+* Type guard for internal (non-GitHub) event types.
+*/
+function isInternalEventType(eventType) {
+	return [
+		"kici_event",
+		"workflow_complete",
+		"job_complete",
+		"generic_webhook",
+		"schedule",
+		"lifecycle"
+	].includes(eventType.type);
+}
+/**
+* Build SimulatedEvent for internal event types.
+* These events don't have GitHub webhook fixtures -- payload is constructed directly.
+*/
+async function buildInternalEventPayload(eventType, options) {
+	let payload;
+	if (options.payload) {
+		const content = await readFile(options.payload, "utf-8");
+		payload = JSON.parse(content);
+	} else switch (eventType.type) {
+		case "kici_event":
+			payload = { eventName: eventType.eventName };
+			break;
+		case "workflow_complete":
+			payload = {
+				workflowName: eventType.workflowName,
+				status: eventType.status
+			};
+			break;
+		case "job_complete":
+			payload = {
+				workflowName: eventType.workflowName,
+				jobName: eventType.jobName,
+				status: eventType.status
+			};
+			break;
+		case "generic_webhook":
+			payload = eventType.source ? { source: eventType.source } : {};
+			break;
+		case "schedule":
+			payload = {
+				cronExpression: eventType.cronExpression ?? "*",
+				timezone: eventType.timezone ?? "UTC"
+			};
+			break;
+		case "lifecycle":
+			payload = { lifecycleEvent: eventType.lifecycleEvent };
+			break;
+	}
+	return {
+		type: eventType.type,
+		action: void 0,
+		payload,
+		targetBranch: "main",
+		changedFiles: options.files ?? []
+	};
+}
+//#endregion
+export { buildEventPayload };
+
+//# sourceMappingURL=payload-builder.js.map

package/dist/test-runner/rule-evaluator.d.ts

@@ -0,0 +1,14 @@
+import type { Rule, RuleContext, EventPayload } from '@kici-dev/sdk';
+import type { RuleEvaluationResult } from '@kici-dev/sdk';
+/**
+ * Create RuleContext for rule evaluation.
+ */
+export declare function createRuleContext(event: EventPayload, changedFiles?: string[]): RuleContext;
+/**
+ * Evaluate rules with formatting output.
+ * Wraps the SDK's evaluateRules() with a callback that logs each rule result.
+ */
+declare function evaluateRulesWithFormatting(rules: Rule[], context: RuleContext, jobName: string): Promise<RuleEvaluationResult>;
+export { evaluateRulesWithFormatting as evaluateRules };
+export type { RuleEvaluationResult };
+//# sourceMappingURL=rule-evaluator.d.ts.map

package/dist/test-runner/rule-evaluator.js

@@ -0,0 +1,31 @@
+import "../chunk-gOLHoazu.js";
+import { formatter } from "./output-formatter.js";
+import { initZx } from "@kici-dev/shared";
+import { evaluateRules } from "@kici-dev/sdk";
+import { $ } from "zx";
+//#region src/test-runner/rule-evaluator.ts
+initZx();
+/**
+* Create RuleContext for rule evaluation.
+*/
+function createRuleContext(event, changedFiles = []) {
+	return {
+		event,
+		changedFiles,
+		env: { ...process.env },
+		$
+	};
+}
+/**
+* Evaluate rules with formatting output.
+* Wraps the SDK's evaluateRules() with a callback that logs each rule result.
+*/
+async function evaluateRulesWithFormatting(rules, context, jobName) {
+	return evaluateRules(rules, context, jobName, (result) => {
+		formatter.logRuleResult(jobName, result.label, result.passed);
+	});
+}
+//#endregion
+export { createRuleContext, evaluateRulesWithFormatting as evaluateRules };
+
+//# sourceMappingURL=rule-evaluator.js.map

package/dist/test-runner/secrets-file.d.ts

@@ -0,0 +1,24 @@
+export interface ParsedSecrets {
+    flat: Record<string, string>;
+    contexts: Record<string, Record<string, string>>;
+}
+/**
+ * Parse an INI-style secrets file content.
+ *
+ * Format:
+ *   # Comments start with #
+ *   KEY=VALUE             -> flat secrets (before any section)
+ *   [sectionName]         -> starts a context section
+ *   KEY=VALUE             -> context secrets (within a section)
+ *
+ * Keys are trimmed. Values are everything after the first `=`, trimmed.
+ * Section names may contain hyphens, underscores, etc.
+ */
+export declare function parseSecretsFile(content: string): ParsedSecrets;
+/**
+ * Load and parse a .kici/.secrets file.
+ *
+ * Returns empty secrets if the file does not exist.
+ */
+export declare function loadSecretsFile(kiciDir: string): Promise<ParsedSecrets>;
+//# sourceMappingURL=secrets-file.d.ts.map

package/dist/test-runner/secrets-file.js

@@ -0,0 +1,62 @@
+import "../chunk-gOLHoazu.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/test-runner/secrets-file.ts
+/**
+* Parse an INI-style secrets file content.
+*
+* Format:
+*   # Comments start with #
+*   KEY=VALUE             -> flat secrets (before any section)
+*   [sectionName]         -> starts a context section
+*   KEY=VALUE             -> context secrets (within a section)
+*
+* Keys are trimmed. Values are everything after the first `=`, trimmed.
+* Section names may contain hyphens, underscores, etc.
+*/
+function parseSecretsFile(content) {
+	const flat = {};
+	const contexts = {};
+	let currentSection = null;
+	for (const rawLine of content.split("\n")) {
+		const line = rawLine.trim();
+		if (line === "" || line.startsWith("#")) continue;
+		const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+		if (sectionMatch) {
+			currentSection = sectionMatch[1].trim();
+			if (!contexts[currentSection]) contexts[currentSection] = {};
+			continue;
+		}
+		const eqIndex = line.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = line.slice(0, eqIndex).trim();
+		const value = line.slice(eqIndex + 1).trim();
+		if (currentSection === null) flat[key] = value;
+		else contexts[currentSection][key] = value;
+	}
+	return {
+		flat,
+		contexts
+	};
+}
+/**
+* Load and parse a .kici/.secrets file.
+*
+* Returns empty secrets if the file does not exist.
+*/
+async function loadSecretsFile(kiciDir) {
+	const secretsPath = path.join(kiciDir, ".secrets");
+	try {
+		return parseSecretsFile(await readFile(secretsPath, "utf-8"));
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "ENOENT") return {
+			flat: {},
+			contexts: {}
+		};
+		throw err;
+	}
+}
+//#endregion
+export { loadSecretsFile, parseSecretsFile };
+
+//# sourceMappingURL=secrets-file.js.map

package/dist/test-runner/step-context.d.ts

@@ -0,0 +1,15 @@
+import type { StepContext, WorkflowInfo, JobInfo, MatrixValues } from '@kici-dev/sdk';
+/**
+ * Create a step context for local test execution.
+ *
+ * `repoRoot` pins `ctx.$` to the workflow's repository root so steps running
+ * via local-dispatch behave the same as on the agent path (see
+ * `packages/agent/src/execution/sandbox/workflow-runner.ts`). Without this,
+ * `ctx.$` would inherit `process.cwd()` — i.e. wherever the user invoked
+ * `kici` — which silently breaks any step that uses relative paths.
+ */
+export declare function createStepContext(workflowInfo: WorkflowInfo, jobInfo: JobInfo, repoRoot: string, inputs?: Record<string, unknown>, matrix?: MatrixValues, testSecrets?: {
+    flat: Record<string, string>;
+    contexts: Record<string, Record<string, string>>;
+}, environment?: string, rawPayload?: Record<string, unknown>, provider?: string): StepContext;
+//# sourceMappingURL=step-context.d.ts.map

package/dist/test-runner/step-context.js

@@ -0,0 +1,140 @@
+import "../chunk-gOLHoazu.js";
+import { formatter } from "./output-formatter.js";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { initZx } from "@kici-dev/shared";
+import { createStepSecrets, resolveJobOutputs, resolveStepOutputs } from "@kici-dev/sdk";
+import { tmpdir } from "node:os";
+import { $ } from "zx";
+//#region src/test-runner/step-context.ts
+initZx();
+/**
+* Create a logger that prefixes output with job name.
+*/
+function createTestLogger(jobName) {
+	return {
+		info: (message, ...args) => {
+			const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+			formatter.logJobLine(jobName, formatted);
+		},
+		warn: (message, ...args) => {
+			const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+			formatter.logJobLine(jobName, `⚠ ${formatted}`);
+		},
+		error: (message, ...args) => {
+			const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+			formatter.logJobLine(jobName, `✗ ${formatted}`);
+		},
+		debug: (message, ...args) => {
+			if (process.env.KICI_DEBUG === "true") {
+				const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+				formatter.logJobLine(jobName, `[debug] ${formatted}`);
+			}
+		}
+	};
+}
+/**
+* Create a step context for local test execution.
+*
+* `repoRoot` pins `ctx.$` to the workflow's repository root so steps running
+* via local-dispatch behave the same as on the agent path (see
+* `packages/agent/src/execution/sandbox/workflow-runner.ts`). Without this,
+* `ctx.$` would inherit `process.cwd()` — i.e. wherever the user invoked
+* `kici` — which silently breaks any step that uses relative paths.
+*/
+function createStepContext(workflowInfo, jobInfo, repoRoot, inputs = {}, matrix, testSecrets, environment, rawPayload, provider) {
+	const flat = testSecrets?.flat ?? {};
+	const namespacedSecrets = testSecrets?.contexts ?? {};
+	const mergedFlat = { ...flat };
+	for (const contextSecrets of Object.values(namespacedSecrets)) Object.assign(mergedFlat, contextSecrets);
+	const env = { ...process.env };
+	const scoped$ = $({ cwd: repoRoot });
+	let tmpdirPath = null;
+	const exposedEnvVars = /* @__PURE__ */ new Set();
+	let mountCounter = 0;
+	let exitHandlerRegistered = false;
+	const onProcessExit = () => {
+		for (const envVar of exposedEnvVars) {
+			delete env[envVar];
+			delete process.env[envVar];
+		}
+		exposedEnvVars.clear();
+		if (tmpdirPath !== null) {
+			try {
+				rmSync(tmpdirPath, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+			tmpdirPath = null;
+		}
+	};
+	const secretsHandle = createStepSecrets(mergedFlat, env, void 0, {
+		host: {
+			async writeMountedFile(args) {
+				if (tmpdirPath === null) tmpdirPath = mkdtempSync(join(tmpdir(), "kici-secret-files-"));
+				if (!exitHandlerRegistered) {
+					process.once("exit", onProcessExit);
+					exitHandlerRegistered = true;
+				}
+				mountCounter += 1;
+				const filename = args.name ?? `secret-${mountCounter}`;
+				const filePath = join(tmpdirPath, filename);
+				writeFileSync(filePath, args.content);
+				chmodSync(filePath, args.mode);
+				return filePath;
+			},
+			trackExposedEnv(envVar) {
+				exposedEnvVars.add(envVar);
+			}
+		},
+		cleanup: async () => {
+			if (exitHandlerRegistered) {
+				process.off("exit", onProcessExit);
+				exitHandlerRegistered = false;
+			}
+			onProcessExit();
+		}
+	});
+	return {
+		$: scoped$,
+		log: createTestLogger(jobInfo.name),
+		env,
+		setEnv: (key, value) => {
+			env[key] = value;
+			process.env[key] = value;
+		},
+		addPath: (dir) => {
+			const updated = `${dir}:${env.PATH ?? process.env.PATH ?? ""}`;
+			env.PATH = updated;
+			process.env.PATH = updated;
+		},
+		inputs,
+		workflow: workflowInfo,
+		job: jobInfo,
+		matrix,
+		isTestRun: false,
+		environment,
+		...rawPayload && { rawPayload },
+		...provider && { provider },
+		secrets: secretsHandle.secrets,
+		emit: async () => {
+			return { deliveryId: "local-test-noop" };
+		},
+		outputsOf: (ref) => {
+			return resolveStepOutputs(ref);
+		},
+		jobOutputs: (ref) => {
+			return resolveJobOutputs(ref);
+		},
+		setSecretOutput: () => {},
+		kici: { infrastructure: { list: () => Promise.resolve({
+			scalers: [],
+			agents: []
+		}) } }
+	};
+}
+//#endregion
+export { createStepContext };
+
+//# sourceMappingURL=step-context.js.map

package/dist/test-runner/summary.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowResult } from './job-executor.js';
+import type { WorkflowDecision } from '@kici-dev/engine';
+/**
+ * Display final execution summary.
+ */
+export declare function displaySummary(results: WorkflowResult[], decisions: WorkflowDecision[]): void;
+//# sourceMappingURL=summary.d.ts.map