@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/remote/observer.js

@@ -0,0 +1,174 @@
+import "../chunk-gOLHoazu.js";
+import WebSocket from "ws";
+//#region src/remote/observer.ts
+/**
+* WebSocket observer client for real-time run streaming.
+*
+* Connects to the orchestrator's observer WS endpoint, subscribes to a
+* specific run, and relays real-time events (logs, step changes, status
+* updates, completion) to registered callbacks.
+*
+* Features:
+* - Auto-reconnect with lastSeenSequence for backfill (up to 5 attempts)
+* - Promise-based waitForCompletion()
+* - Clean disconnect
+*/
+var ObserverClient = class {
+	ws = null;
+	lastSeenSequence = 0;
+	reconnectAttempts = 0;
+	intentionalDisconnect = false;
+	initialConnectCompleted = false;
+	reconnectTimer = null;
+	completionResolve = null;
+	completionReject = null;
+	completionResult = null;
+	config;
+	constructor(config) {
+		this.config = {
+			maxReconnectAttempts: 5,
+			reconnectDelayMs: 1e3,
+			...config
+		};
+	}
+	/**
+	* Connect to the observer endpoint and send the subscribe message.
+	* Resolves when the WS connection is open and subscribe is sent.
+	*/
+	connect() {
+		return new Promise((resolve, reject) => {
+			this.intentionalDisconnect = false;
+			this.doConnect(resolve, reject);
+		});
+	}
+	/**
+	* Returns a promise that resolves when the run completes.
+	* If the run already completed (from a prior observe.complete),
+	* resolves immediately.
+	*/
+	waitForCompletion() {
+		if (this.completionResult) return Promise.resolve(this.completionResult);
+		return new Promise((resolve, reject) => {
+			this.completionResolve = resolve;
+			this.completionReject = reject;
+		});
+	}
+	/**
+	* Gracefully disconnect from the observer endpoint.
+	*/
+	disconnect() {
+		this.intentionalDisconnect = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.ws) {
+			this.ws.close(1e3, "Observer disconnect");
+			this.ws = null;
+		}
+		if (this.completionReject) {
+			this.completionReject(/* @__PURE__ */ new Error("Observer disconnected"));
+			this.completionResolve = null;
+			this.completionReject = null;
+		}
+	}
+	/** Current lastSeenSequence (for testing). */
+	getLastSeenSequence() {
+		return this.lastSeenSequence;
+	}
+	doConnect(onConnected, onFailed) {
+		try {
+			this.ws = new WebSocket(this.config.observeUrl);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (onFailed) onFailed(error);
+			else this.config.onError(error);
+			return;
+		}
+		this.ws.on("open", () => {
+			const subscribeMsg = {
+				type: "observe.subscribe",
+				runId: this.config.runId,
+				token: this.config.token
+			};
+			if (this.lastSeenSequence > 0) subscribeMsg.lastSeenSequence = this.lastSeenSequence;
+			this.ws.send(JSON.stringify(subscribeMsg));
+			this.initialConnectCompleted = true;
+			this.reconnectAttempts = 0;
+			if (onConnected) onConnected();
+		});
+		this.ws.on("message", (data) => {
+			this.handleMessage(data);
+		});
+		this.ws.on("close", (_code) => {
+			this.ws = null;
+			if (!this.intentionalDisconnect) this.scheduleReconnect();
+		});
+		this.ws.on("error", (err) => {
+			if (onFailed) {
+				onFailed(err);
+				onFailed = void 0;
+				onConnected = void 0;
+			} else this.config.onError(err);
+		});
+	}
+	handleMessage(data) {
+		let msg;
+		try {
+			msg = JSON.parse(data.toString());
+		} catch {
+			return;
+		}
+		if (typeof msg.sequence === "number") this.lastSeenSequence = msg.sequence;
+		switch (msg.type) {
+			case "observe.log":
+				this.config.onLog(msg);
+				break;
+			case "observe.step":
+				this.config.onStep(msg);
+				break;
+			case "observe.status":
+				this.config.onStatus(msg);
+				break;
+			case "observe.complete": {
+				const completeMsg = msg;
+				this.completionResult = completeMsg;
+				this.config.onComplete(completeMsg);
+				if (this.completionResolve) {
+					this.completionResolve(completeMsg);
+					this.completionResolve = null;
+					this.completionReject = null;
+				}
+				break;
+			}
+			case "error": {
+				const error = new Error(msg.message || "Observer error");
+				this.config.onError(error);
+				break;
+			}
+		}
+	}
+	scheduleReconnect() {
+		if (!this.initialConnectCompleted) return;
+		if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+			const error = /* @__PURE__ */ new Error(`Observer connection lost after ${this.config.maxReconnectAttempts} reconnection attempts`);
+			this.config.onError(error);
+			if (this.completionReject) {
+				this.completionReject(error);
+				this.completionResolve = null;
+				this.completionReject = null;
+			}
+			return;
+		}
+		this.reconnectAttempts++;
+		process.stderr.write(`Reconnecting to observer (attempt ${this.reconnectAttempts}/${this.config.maxReconnectAttempts})...\n`);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			if (!this.intentionalDisconnect) this.doConnect();
+		}, this.config.reconnectDelayMs);
+	}
+};
+//#endregion
+export { ObserverClient };
+
+//# sourceMappingURL=observer.js.map

package/dist/remote/output/json.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JSON output formatter for machine-readable results.
+ *
+ * Used with `--json` flag to produce structured output for CI integration.
+ */
+import type { RunResult } from './summary.js';
+/**
+ * Format run results as structured JSON with 2-space indentation.
+ *
+ * @returns JSON string ready for stdout.
+ */
+export declare function formatJsonResult(results: RunResult[]): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/remote/output/json.js

@@ -0,0 +1,36 @@
+import "../../chunk-gOLHoazu.js";
+//#region src/remote/output/json.ts
+/**
+* Format run results as structured JSON with 2-space indentation.
+*
+* @returns JSON string ready for stdout.
+*/
+function formatJsonResult(results) {
+	const passed = results.filter((r) => r.status === "success").length;
+	const failed = results.filter((r) => r.status === "failed").length;
+	const cancelled = results.filter((r) => r.status === "cancelled").length;
+	const output = {
+		results: results.map((r) => ({
+			fixtureId: r.fixtureId,
+			runId: r.runId,
+			status: r.status,
+			totalDurationMs: r.totalDurationMs,
+			jobs: r.jobs.map((j) => ({
+				name: j.name,
+				status: j.status,
+				...j.durationMs !== void 0 && { durationMs: j.durationMs }
+			}))
+		})),
+		summary: {
+			passed,
+			failed,
+			cancelled,
+			total: results.length
+		}
+	};
+	return JSON.stringify(output, null, 2);
+}
+//#endregion
+export { formatJsonResult };
+
+//# sourceMappingURL=json.js.map

package/dist/remote/output/junit.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JUnit XML output formatter for CI integration.
+ *
+ * Used with `--junit` flag to produce standard JUnit XML output that
+ * can be consumed by CI systems (Jenkins, GitLab, etc.).
+ *
+ * Each fixture maps to a <testsuite>, each job maps to a <testcase>.
+ */
+import type { RunResult } from './summary.js';
+/**
+ * Format run results as JUnit XML following the standard schema.
+ *
+ * @param results The run results to format.
+ * @param failureMessages Optional map of jobKey -> last lines of output for failure details.
+ * @returns Valid JUnit XML string.
+ */
+export declare function formatJunitResult(results: RunResult[], failureMessages?: Map<string, string>): string;
+//# sourceMappingURL=junit.d.ts.map

package/dist/remote/output/junit.js

@@ -0,0 +1,50 @@
+import "../../chunk-gOLHoazu.js";
+//#region src/remote/output/junit.ts
+/**
+* Format run results as JUnit XML following the standard schema.
+*
+* @param results The run results to format.
+* @param failureMessages Optional map of jobKey -> last lines of output for failure details.
+* @returns Valid JUnit XML string.
+*/
+function formatJunitResult(results, failureMessages) {
+	const totalTests = results.reduce((sum, r) => sum + r.jobs.length, 0);
+	const totalFailures = results.reduce((sum, r) => sum + r.jobs.filter((j) => j.status === "failed").length, 0);
+	const totalTimeSeconds = results.reduce((sum, r) => sum + r.totalDurationMs / 1e3, 0);
+	const lines = [];
+	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+	lines.push(`<testsuites name="kici-test" tests="${totalTests}" failures="${totalFailures}" time="${totalTimeSeconds.toFixed(3)}">`);
+	for (const result of results) {
+		const suiteTests = result.jobs.length;
+		const suiteFailures = result.jobs.filter((j) => j.status === "failed").length;
+		const suiteTimeSeconds = result.totalDurationMs / 1e3;
+		lines.push(`  <testsuite name="${escapeXml(result.fixtureId)}" tests="${suiteTests}" failures="${suiteFailures}" time="${suiteTimeSeconds.toFixed(3)}">`);
+		for (const job of result.jobs) {
+			const jobTimeSeconds = job.durationMs !== void 0 ? job.durationMs / 1e3 : 0;
+			if (job.status === "failed") {
+				const failureKey = `${result.fixtureId}:${job.name}`;
+				const failureText = failureMessages?.get(failureKey) ?? "Step failed";
+				lines.push(`    <testcase name="${escapeXml(job.name)}" classname="${escapeXml(result.fixtureId)}" time="${jobTimeSeconds.toFixed(3)}">`);
+				lines.push(`      <failure message="Step failed">${escapeXml(failureText)}</failure>`);
+				lines.push("    </testcase>");
+			} else if (job.status === "skipped") {
+				lines.push(`    <testcase name="${escapeXml(job.name)}" classname="${escapeXml(result.fixtureId)}" time="${jobTimeSeconds.toFixed(3)}">`);
+				lines.push("      <skipped />");
+				lines.push("    </testcase>");
+			} else lines.push(`    <testcase name="${escapeXml(job.name)}" classname="${escapeXml(result.fixtureId)}" 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 { formatJunitResult };
+
+//# sourceMappingURL=junit.js.map

package/dist/remote/output/streaming.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Real-time log streaming output formatter for CLI observer.
+ *
+ * Manages colored output for multi-job runs:
+ * - Assigns distinct colors per job name (cycling through a palette)
+ * - Formats log lines with colored job-name prefix
+ * - Prints step transition headers
+ * - Tracks elapsed time with in-place status updates
+ */
+export declare class StreamingFormatter {
+    /** Color assignment per job name. */
+    private readonly jobColors;
+    private colorIndex;
+    /** Track the current step per job to detect transitions. */
+    private readonly currentStep;
+    /** Start timestamp for elapsed time tracking. */
+    private startTime;
+    /** Elapsed timer interval reference. */
+    private elapsedTimer;
+    /** If true, suppress all streaming output. */
+    isQuiet: boolean;
+    /**
+     * Get or assign a color function for a job name.
+     */
+    private getColor;
+    /**
+     * Format a log line with colored job-name prefix.
+     *
+     * If the step has changed since the last log for this job,
+     * a step header is emitted first.
+     *
+     * @returns The formatted line(s) to print, or empty string if quiet.
+     */
+    formatLogLine(jobName: string, stepName: string, line: string): string;
+    /**
+     * Format a step lifecycle change.
+     *
+     * @returns The formatted status line, or empty string if quiet.
+     */
+    formatStepChange(jobName: string, stepName: string, state: string, durationMs?: number): string;
+    /**
+     * Format a run status change.
+     *
+     * @returns The formatted status line, or empty string if quiet.
+     */
+    formatStatusChange(status: string, jobName?: string): string;
+    /**
+     * Start the elapsed timer that updates a status line in-place.
+     * Uses \\r to overwrite the current line.
+     */
+    startElapsedTimer(): void;
+    /**
+     * Stop the elapsed timer and clear the status line.
+     */
+    stopElapsedTimer(): void;
+}
+//# sourceMappingURL=streaming.d.ts.map

package/dist/remote/output/streaming.js

@@ -0,0 +1,124 @@
+import "../../chunk-gOLHoazu.js";
+import pc from "picocolors";
+import { formatDuration } from "@kici-dev/shared";
+//#region src/remote/output/streaming.ts
+/**
+* Real-time log streaming output formatter for CLI observer.
+*
+* Manages colored output for multi-job runs:
+* - Assigns distinct colors per job name (cycling through a palette)
+* - Formats log lines with colored job-name prefix
+* - Prints step transition headers
+* - Tracks elapsed time with in-place status updates
+*/
+/** Available color functions for job name assignment. */
+const COLOR_PALETTE = [
+	pc.blue,
+	pc.green,
+	pc.yellow,
+	pc.magenta,
+	pc.cyan
+];
+var StreamingFormatter = class {
+	/** Color assignment per job name. */
+	jobColors = /* @__PURE__ */ new Map();
+	colorIndex = 0;
+	/** Track the current step per job to detect transitions. */
+	currentStep = /* @__PURE__ */ new Map();
+	/** Start timestamp for elapsed time tracking. */
+	startTime = Date.now();
+	/** Elapsed timer interval reference. */
+	elapsedTimer = null;
+	/** If true, suppress all streaming output. */
+	isQuiet = false;
+	/**
+	* Get or assign a color function for a job name.
+	*/
+	getColor(jobName) {
+		let color = this.jobColors.get(jobName);
+		if (!color) {
+			color = COLOR_PALETTE[this.colorIndex % COLOR_PALETTE.length];
+			this.colorIndex++;
+			this.jobColors.set(jobName, color);
+		}
+		return color;
+	}
+	/**
+	* Format a log line with colored job-name prefix.
+	*
+	* If the step has changed since the last log for this job,
+	* a step header is emitted first.
+	*
+	* @returns The formatted line(s) to print, or empty string if quiet.
+	*/
+	formatLogLine(jobName, stepName, line) {
+		if (this.isQuiet) return "";
+		const prefix = this.getColor(jobName)(`[${jobName}]`);
+		let output = "";
+		if (this.currentStep.get(jobName) !== stepName) {
+			this.currentStep.set(jobName, stepName);
+			output += `${prefix} ${pc.dim(`── Step: ${stepName} ──`)}\n`;
+		}
+		output += `${prefix} ${line}\n`;
+		return output;
+	}
+	/**
+	* Format a step lifecycle change.
+	*
+	* @returns The formatted status line, or empty string if quiet.
+	*/
+	formatStepChange(jobName, stepName, state, durationMs) {
+		if (this.isQuiet) return "";
+		const prefix = this.getColor(jobName)(`[${jobName}]`);
+		const duration = durationMs !== void 0 ? ` (${formatDuration(durationMs)})` : "";
+		switch (state) {
+			case "running": return `${prefix} ▶ Step '${stepName}' started\n`;
+			case "success": return `${prefix} ${pc.green(`✓ Step '${stepName}' completed${duration}`)}\n`;
+			case "failed": return `${prefix} ${pc.red(`✗ Step '${stepName}' failed${duration}`)}\n`;
+			case "skipped": return `${prefix} ${pc.dim(`- Step '${stepName}' skipped`)}\n`;
+			default: return `${prefix} Step '${stepName}': ${state}${duration}\n`;
+		}
+	}
+	/**
+	* Format a run status change.
+	*
+	* @returns The formatted status line, or empty string if quiet.
+	*/
+	formatStatusChange(status, jobName) {
+		if (this.isQuiet) return "";
+		switch (status) {
+			case "queued": return `${pc.dim("Queued...")}\n`;
+			case "running": return jobName ? `${pc.cyan(`Running: ${jobName}`)}\n` : `${pc.cyan("Running...")}\n`;
+			case "success": return `${pc.green("Run completed successfully")}\n`;
+			case "failed": return `${pc.red("Run failed")}\n`;
+			case "cancelled": return `${pc.yellow("Run cancelled")}\n`;
+			default: return `Status: ${status}\n`;
+		}
+	}
+	/**
+	* Start the elapsed timer that updates a status line in-place.
+	* Uses \\r to overwrite the current line.
+	*/
+	startElapsedTimer() {
+		if (this.isQuiet) return;
+		this.startTime = Date.now();
+		this.elapsedTimer = setInterval(() => {
+			const elapsed = Date.now() - this.startTime;
+			process.stderr.write(`\r${pc.dim(`Elapsed: ${formatDuration(elapsed)}`)}`);
+		}, 1e3);
+	}
+	/**
+	* Stop the elapsed timer and clear the status line.
+	*/
+	stopElapsedTimer() {
+		if (this.elapsedTimer) {
+			clearInterval(this.elapsedTimer);
+			this.elapsedTimer = null;
+			process.stderr.write("\r\x1B[K");
+		}
+	}
+};
+//#endregion
+export { StreamingFormatter };
+
+//# sourceMappingURL=streaming.js.map

package/dist/remote/output/summary.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Completion summary output formatters.
+ *
+ * Renders summary tables, error highlights, and multi-fixture aggregates
+ * for display after run completion.
+ */
+/** Result of a single run (fixture execution). */
+export interface RunResult {
+    fixtureId: string;
+    runId: string;
+    status: 'success' | 'failed' | 'cancelled';
+    totalDurationMs: number;
+    jobs: Array<{
+        name: string;
+        status: string;
+        durationMs?: number;
+    }>;
+}
+/**
+ * Format a summary table for a single run result.
+ *
+ * Renders a box-drawn table with job name, status, and duration.
+ * Status is colored: green for pass, red for fail, gray for skip.
+ */
+export declare function formatSummary(result: RunResult): string;
+/**
+ * Format an error highlight section showing the last lines of a failed step.
+ *
+ * @param failedJobName The name of the failed job.
+ * @param lastLines The last N lines of the failed step's output.
+ */
+export declare function formatErrorHighlight(failedJobName: string, lastLines: string[]): string;
+/**
+ * Format a multi-fixture summary aggregate.
+ *
+ * Shows counts: "Fixtures: N passed, M failed, T total"
+ */
+export declare function formatMultiFixtureSummary(results: RunResult[]): string;
+//# sourceMappingURL=summary.d.ts.map

package/dist/remote/output/summary.js

@@ -0,0 +1,99 @@
+import "../../chunk-gOLHoazu.js";
+import pc from "picocolors";
+import { formatDuration } from "@kici-dev/shared";
+//#region src/remote/output/summary.ts
+/**
+* Completion summary output formatters.
+*
+* Renders summary tables, error highlights, and multi-fixture aggregates
+* for display after run completion.
+*/
+/**
+* Format a summary table for a single run result.
+*
+* Renders a box-drawn table with job name, status, and duration.
+* Status is colored: green for pass, red for fail, gray for skip.
+*/
+function formatSummary(result) {
+	const rows = result.jobs.map((job) => ({
+		name: job.name,
+		status: formatJobStatus(job.status),
+		statusRaw: job.status,
+		duration: job.durationMs !== void 0 ? formatDuration(job.durationMs) : "-"
+	}));
+	const nameWidth = Math.max(3, ...rows.map((r) => r.name.length));
+	const statusRawWidth = Math.max(6, ...rows.map((r) => statusTextLength(r.statusRaw)));
+	const durationWidth = Math.max(8, ...rows.map((r) => r.duration.length));
+	const lines = [];
+	lines.push(`\u250c${"─".repeat(nameWidth + 2)}\u252c${"─".repeat(statusRawWidth + 2)}\u252c${"─".repeat(durationWidth + 2)}\u2510`);
+	lines.push(`\u2502 ${"Job".padEnd(nameWidth)} \u2502 ${"Status".padEnd(statusRawWidth)} \u2502 ${"Duration".padEnd(durationWidth)} \u2502`);
+	lines.push(`\u251c${"─".repeat(nameWidth + 2)}\u253c${"─".repeat(statusRawWidth + 2)}\u253c${"─".repeat(durationWidth + 2)}\u2524`);
+	for (const row of rows) {
+		const statusPadding = statusRawWidth - statusTextLength(row.statusRaw);
+		lines.push(`\u2502 ${row.name.padEnd(nameWidth)} \u2502 ${row.status}${" ".repeat(statusPadding)} \u2502 ${row.duration.padEnd(durationWidth)} \u2502`);
+	}
+	lines.push(`\u2514${"─".repeat(nameWidth + 2)}\u2534${"─".repeat(statusRawWidth + 2)}\u2534${"─".repeat(durationWidth + 2)}\u2518`);
+	lines.push("");
+	const resultText = result.status === "success" ? pc.green("PASSED") : pc.red("FAILED");
+	lines.push(`Result: ${resultText} (${formatDuration(result.totalDurationMs)})`);
+	return lines.join("\n");
+}
+/**
+* Format an error highlight section showing the last lines of a failed step.
+*
+* @param failedJobName The name of the failed job.
+* @param lastLines The last N lines of the failed step's output.
+*/
+function formatErrorHighlight(failedJobName, lastLines) {
+	const truncated = lastLines.slice(-50);
+	const headerWidth = 40;
+	const header = `── Error: ${failedJobName} `;
+	const headerLine = pc.red(header + "─".repeat(Math.max(0, headerWidth - header.length)));
+	const footerLine = pc.red("─".repeat(headerWidth));
+	const lines = [];
+	lines.push(headerLine);
+	for (const line of truncated) lines.push(line);
+	lines.push(footerLine);
+	return lines.join("\n");
+}
+/**
+* Format a multi-fixture summary aggregate.
+*
+* Shows counts: "Fixtures: N passed, M failed, T total"
+*/
+function formatMultiFixtureSummary(results) {
+	const passed = results.filter((r) => r.status === "success").length;
+	const failed = results.filter((r) => r.status === "failed").length;
+	const cancelled = results.filter((r) => r.status === "cancelled").length;
+	const total = results.length;
+	const parts = [];
+	if (passed > 0) parts.push(pc.green(`${passed} passed`));
+	if (failed > 0) parts.push(pc.red(`${failed} failed`));
+	if (cancelled > 0) parts.push(pc.yellow(`${cancelled} cancelled`));
+	parts.push(`${total} total`);
+	return `Fixtures: ${parts.join(", ")}`;
+}
+/** Format a job status with icon and color. */
+function formatJobStatus(status) {
+	switch (status) {
+		case "success": return pc.green("✓ pass");
+		case "failed": return pc.red("✗ fail");
+		case "skipped": return pc.dim("- skip");
+		case "cancelled": return pc.yellow("! cancel");
+		default: return status;
+	}
+}
+/** Get the visual text length for a status (for padding). */
+function statusTextLength(status) {
+	switch (status) {
+		case "success": return 6;
+		case "failed": return 6;
+		case "skipped": return 6;
+		case "cancelled": return 8;
+		default: return status.length;
+	}
+}
+//#endregion
+export { formatErrorHighlight, formatMultiFixtureSummary, formatSummary };
+
+//# sourceMappingURL=summary.js.map