@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/commands/status.js

@@ -0,0 +1,210 @@
+import "../chunk-gOLHoazu.js";
+import { formatCapabilityGapError } from "../errors/capability-gap.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import { AuthenticationError, ConnectionError, NotFoundError, OrchestratorClient } from "../remote/client.js";
+import { StreamingFormatter } from "../remote/output/streaming.js";
+import { RunHistory } from "../remote/history.js";
+import { observeCompletion } from "./run.js";
+import pc from "picocolors";
+import { formatDuration, logger, toErrorMessage } from "@kici-dev/shared";
+//#region src/commands/status.ts
+/**
+* kici status command
+*
+* Shows the status and details of a test run, with optional log streaming.
+* Looks up local history first, then fetches from the orchestrator for
+* up-to-date status and logs.
+*/
+const CLI_VERSION = typeof KICI_VERSION !== "undefined" ? KICI_VERSION : "0.0.1";
+/**
+* Show status and details of a test run.
+*
+* Default mode: show run summary table from local history + orchestrator.
+* --logs: stream full logs from the orchestrator.
+* --job <name>: filter logs to a specific job.
+* --json: output raw JSON.
+*
+* @param runId - The run ID to inspect
+* @param options - Status display options
+* @returns true on success, false on error
+*/
+async function statusCommand(runId, options = {}) {
+	try {
+		const history = new RunHistory();
+		await history.load();
+		const localEntry = history.getEntry(runId);
+		if (!options.json) displayAuthInfo(await loadGlobalConfig());
+		const config = await loadGlobalConfig();
+		const endpoint = config.endpoint ?? config.platformEndpoint;
+		if (!config.token || !endpoint) {
+			if (localEntry) {
+				if (options.json) console.log(JSON.stringify(localEntry, null, 2));
+				else displayLocalEntry(localEntry);
+				return true;
+			}
+			logger.error(pc.red("Not authenticated and no local history for this run. Run `kici login` to authenticate."));
+			return false;
+		}
+		const client = new OrchestratorClient({
+			endpoint,
+			token: config.token
+		});
+		try {
+			const remoteStatus = await client.getRunStatus(runId);
+			if (options.json) {
+				console.log(JSON.stringify(remoteStatus, null, 2));
+				return true;
+			}
+			if (options.logs) return await displayLogs(client, config.token, runId, options.job);
+			displayRunSummary(remoteStatus, localEntry);
+			return true;
+		} catch (error) {
+			if (error instanceof NotFoundError) {
+				if (localEntry) {
+					if (options.json) console.log(JSON.stringify(localEntry, null, 2));
+					else {
+						logger.info(pc.yellow("Run not found on orchestrator. Showing local history:\n"));
+						displayLocalEntry(localEntry);
+					}
+					return true;
+				}
+				logger.error(pc.red(`Run not found: ${runId}`));
+				return false;
+			}
+			if (error instanceof AuthenticationError) {
+				logger.error(pc.red("Authentication failed. Run `kici login` to re-authenticate."));
+				return false;
+			}
+			if (error instanceof ConnectionError) {
+				if (localEntry) {
+					logger.info(pc.yellow("Cannot reach orchestrator. Showing local history (may be stale):\n"));
+					if (options.json) console.log(JSON.stringify(localEntry, null, 2));
+					else displayLocalEntry(localEntry);
+					return true;
+				}
+				logger.error(pc.red(`Connection failed: ${error.message}`));
+				return false;
+			}
+			throw error;
+		}
+	} catch (error) {
+		const message = toErrorMessage(error);
+		logger.error(pc.red(`Error: ${message}`));
+		return false;
+	}
+}
+/**
+* Display a run summary from remote status (+ local context).
+*/
+function displayRunSummary(remote, local) {
+	const statusColor = remote.status === "success" ? pc.green : remote.status === "failed" ? pc.red : remote.status === "cancelled" ? pc.yellow : pc.blue;
+	logger.info(pc.bold(`\nRun: ${remote.runId}`));
+	logger.info(`Status: ${statusColor(remote.status)}`);
+	if (local?.fixtureId) logger.info(`Fixture: ${pc.cyan(local.fixtureId)}`);
+	if (local?.endpoint) logger.info(`Endpoint: ${pc.gray(local.endpoint)}`);
+	if (local?.startedAt) logger.info(`Started: ${pc.gray(local.startedAt)}`);
+	if (local?.completedAt) logger.info(`Completed: ${pc.gray(local.completedAt)}`);
+	if (remote.summary) {
+		const totalDuration = remote.summary.totalDurationMs;
+		logger.info(`Duration: ${pc.gray(formatDuration(totalDuration))}`);
+		if (remote.summary.jobs.length > 0) {
+			logger.info(pc.bold("\nJobs:"));
+			const nameWidth = Math.max(10, ...remote.summary.jobs.map((j) => j.name.length)) + 2;
+			for (const job of remote.summary.jobs) {
+				const jobColor = job.status === "success" ? pc.green : job.status === "failed" ? pc.red : job.status === "cancelled" ? pc.yellow : pc.blue;
+				const duration = job.durationMs ? formatDuration(job.durationMs) : "-";
+				logger.info(`  ${jobColor(job.status.padEnd(12))} ${job.name.padEnd(nameWidth)} ${pc.gray(duration)}`);
+			}
+		}
+	}
+	logger.info("");
+}
+/**
+* Display a local-only history entry.
+*/
+function displayLocalEntry(entry) {
+	const statusColor = entry.status === "success" ? pc.green : entry.status === "failed" ? pc.red : entry.status === "cancelled" ? pc.yellow : pc.blue;
+	logger.info(pc.bold(`\nRun: ${entry.runId}`));
+	logger.info(`Status: ${statusColor(entry.status)}`);
+	logger.info(`Fixture: ${pc.cyan(entry.fixtureId)}`);
+	logger.info(`Endpoint: ${pc.gray(entry.endpoint)}`);
+	logger.info(`Started: ${pc.gray(entry.startedAt)}`);
+	if (entry.completedAt) logger.info(`Completed: ${pc.gray(entry.completedAt)}`);
+	if (entry.durationMs) logger.info(`Duration: ${pc.gray(formatDuration(entry.durationMs))}`);
+	if (entry.jobs && entry.jobs.length > 0) {
+		logger.info(pc.bold("\nJobs:"));
+		for (const job of entry.jobs) {
+			const jobColor = job.status === "success" ? pc.green : job.status === "failed" ? pc.red : job.status === "cancelled" ? pc.yellow : pc.blue;
+			const duration = job.durationMs ? formatDuration(job.durationMs) : "-";
+			logger.info(`  ${jobColor(job.status.padEnd(12))} ${job.name} ${pc.gray(duration)}`);
+		}
+	}
+	logger.info(pc.gray("\n(Local history only -- run may have updated on orchestrator)"));
+	logger.info("");
+}
+/**
+* Stream logs for a run from the orchestrator.
+*
+* For active runs, connects via WebSocket for live streaming.
+* For completed runs, fetches historical logs from storage.
+*/
+async function displayLogs(client, token, runId, jobFilter) {
+	let logsResponse;
+	try {
+		logsResponse = await client.getRunLogs(runId, jobFilter);
+	} catch (error) {
+		if (error instanceof NotFoundError) {
+			const caps = await client.getCapabilities();
+			logger.error(formatCapabilityGapError({
+				feature: "log-streaming",
+				cliVersion: CLI_VERSION,
+				orchestratorVersion: caps.orchestratorVersion
+			}));
+			return false;
+		}
+		throw error;
+	}
+	if (logsResponse.observeUrl) {
+		logger.info(pc.bold(`\nStreaming live logs for run: ${runId}\n`));
+		return (await observeCompletion("status", runId, logsResponse.observeUrl, token, client, {})).status === "success";
+	}
+	logger.info(pc.bold(`\nLogs for run: ${runId}\n`));
+	if (!logsResponse.logs || logsResponse.logs.length === 0) {
+		logger.info(pc.gray("No logs available for this run."));
+		return true;
+	}
+	const formatter = new StreamingFormatter();
+	for (const entry of logsResponse.logs) for (const line of entry.lines) {
+		const output = formatter.formatLogLine(entry.jobName, entry.stepName, line);
+		if (output) process.stdout.write(output);
+	}
+	logger.info("");
+	return true;
+}
+/**
+* Display authentication information section.
+*
+* Shows logged-in user, active org, and PAT expiry with warnings.
+*/
+function displayAuthInfo(config) {
+	logger.info(pc.bold("\nAuth:"));
+	if (config.pat) {
+		const email = config.userEmail || "unknown";
+		logger.info(`  Logged in as: ${pc.cyan(email)}`);
+		logger.info(`  Active org: ${config.activeOrgId || pc.gray("none")}`);
+		if (config.patExpiresAt) {
+			const expiryDate = new Date(config.patExpiresAt);
+			const now = /* @__PURE__ */ new Date();
+			const daysRemaining = Math.ceil((expiryDate.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+			if (daysRemaining <= 0) logger.info(pc.red(`  PAT expired. Run 'kici login' to re-authenticate.`));
+			else if (daysRemaining <= 7) logger.info(pc.yellow(`  PAT expires in ${daysRemaining} day(s). Run 'kici login' to refresh.`));
+			else logger.info(`  PAT expires: ${expiryDate.toLocaleDateString()} (${daysRemaining} days remaining)`);
+		}
+	} else if (config.token) logger.info(`  Using API key authentication.`);
+	else logger.info(pc.gray(`  Not authenticated. Run 'kici login' to get started.`));
+	logger.info("");
+}
+//#endregion
+export { statusCommand };
+
+//# sourceMappingURL=status.js.map

package/dist/commands/test.d.ts

@@ -0,0 +1,61 @@
+import { type PayloadOptions } from '../test-runner/payload-builder.js';
+/** Options for the kici test command (dry-run trigger preview) */
+export interface TestOptions extends PayloadOptions {
+    /** Filter to specific workflow */
+    workflow?: string;
+    /** Filter to specific job */
+    job?: string;
+    /** Enable debug output */
+    debug?: boolean;
+    /** Path to .kici directory (defaults to .kici) */
+    kiciDir?: string;
+    /** Flat secret overrides: KEY=VALUE */
+    secret?: string[];
+    /** Context secret overrides: contextName.KEY=VALUE */
+    context?: string[];
+}
+/** Options for the kici run remote command */
+export interface RemoteRunOptions extends TestOptions {
+    /** Run all available fixtures */
+    all?: boolean;
+    /** Run matching fixtures concurrently */
+    parallel?: boolean;
+    /** Fire and forget (print runIds, don't stream) */
+    wait?: boolean;
+    /** Suppress output except final result */
+    quiet?: boolean;
+    /** Output structured JSON result */
+    json?: boolean;
+    /** Output JUnit XML result */
+    junit?: string;
+    /** Override routing key for this run */
+    routingKey?: string;
+    /** Show recent run history */
+    history?: boolean;
+}
+/** Result of a single remote fixture run */
+export interface RemoteRunResult {
+    fixtureId: string;
+    runId: string;
+    status: 'accepted' | 'rejected' | 'success' | 'failed' | 'cancelled' | 'error';
+    reason?: string;
+    observeUrl?: string;
+    durationMs?: number;
+    jobs?: Array<{
+        name: string;
+        status: string;
+        durationMs?: number;
+    }>;
+}
+/**
+ * Main test command entry point.
+ *
+ * `kici test <event>` is now dry-run trigger preview only.
+ * If the argument looks like a fixture name (not a known event type), prints a migration message.
+ */
+export declare function testCommand(event: string | undefined, options: TestOptions): Promise<boolean>;
+/**
+ * Local-only dry-run mode: compile workflows, match triggers, display what would execute.
+ */
+export declare function testDryRun(event: string, options: TestOptions): Promise<boolean>;
+//# sourceMappingURL=test.d.ts.map

package/dist/commands/test.js

@@ -0,0 +1,220 @@
+import "../chunk-gOLHoazu.js";
+import { discoverWorkflows, resolveKiciDir } from "../execution/executor.js";
+import "../execution/index.js";
+import { transformTriggers } from "../lockfile/generator.js";
+import { parseEventArg } from "../test-runner/event-types.js";
+import { buildEventPayload } from "../test-runner/payload-builder.js";
+import { displayDryRun } from "../test-runner/dry-run.js";
+import { loadSecretsFile } from "../test-runner/secrets-file.js";
+import pc from "picocolors";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { logger, toErrorMessage } from "@kici-dev/shared";
+import { matchAllWorkflows, normalizeRunsOn } from "@kici-dev/engine";
+//#region src/commands/test.ts
+/**
+* Main test command entry point.
+*
+* `kici test <event>` is now dry-run trigger preview only.
+* If the argument looks like a fixture name (not a known event type), prints a migration message.
+*/
+async function testCommand(event, options) {
+	if (options.debug) {
+		process.env.KICI_DEBUG = "true";
+		logger.info(pc.gray("Debug mode enabled"));
+	}
+	try {
+		if (!event) {
+			logger.info(pc.bold("\nUsage: kici test <event>\n"));
+			logger.info(pc.gray("Preview which workflows and jobs would run for a given event.\n"));
+			logger.info(pc.gray("Examples:"));
+			logger.info(pc.gray("  kici test push"));
+			logger.info(pc.gray("  kici test pr:open"));
+			logger.info(pc.gray("  kici test schedule"));
+			logger.info(pc.gray("  kici test lifecycle:workflow_complete\n"));
+			logger.info(pc.gray("For remote fixture execution, use: kici run remote [fixture] [options]"));
+			logger.info(pc.gray("For local workflow execution, use: kici run local <event> [options]\n"));
+			return true;
+		}
+		if (!isKnownEventArg(event)) {
+			logger.info(pc.yellow(`\nFixture-based testing has moved to \`kici run remote\`.\nRun \`kici run remote ${event}\` instead.\n`));
+			return false;
+		}
+		return await testDryRun(event, options);
+	} catch (error) {
+		const message = toErrorMessage(error);
+		logger.error(pc.red(`\nError: ${message}\n`));
+		if (options.debug && error instanceof Error && error.stack) logger.error(pc.gray(error.stack));
+		return false;
+	}
+}
+/**
+* Check if the argument is a known event type.
+* Returns true if parseEventArg succeeds, false if it looks like a fixture name.
+*/
+function isKnownEventArg(arg) {
+	try {
+		parseEventArg(arg);
+		return true;
+	} catch {
+		return arg.includes(":");
+	}
+}
+/**
+* Local-only dry-run mode: compile workflows, match triggers, display what would execute.
+*/
+async function testDryRun(event, options) {
+	try {
+		const kiciDir = resolveKiciDir(options.kiciDir);
+		logger.info(pc.gray(`KiCI directory: ${kiciDir}`));
+		await loadTestSecrets(kiciDir, options.secret, options.context);
+		logger.info(pc.gray(`Event: ${event}`));
+		const simulatedEvent = await buildEventPayload(event, options);
+		logger.info(pc.gray(`Target branch: ${simulatedEvent.targetBranch}`));
+		if (simulatedEvent.sourceBranch) logger.info(pc.gray(`Source branch: ${simulatedEvent.sourceBranch}`));
+		if (simulatedEvent.changedFiles && simulatedEvent.changedFiles.length > 0) logger.info(pc.gray(`Changed files: ${simulatedEvent.changedFiles.join(", ")}`));
+		const { workflows } = await loadWorkflows(kiciDir);
+		const lockWorkflows = workflowsToLockFormat(workflows);
+		const decisions = matchAllWorkflows(lockWorkflows, simulatedEvent);
+		const matchedWorkflows = workflows.filter((_, i) => decisions[i].matched);
+		logger.info(pc.gray(`Workflows: ${workflows.length} total, ${matchedWorkflows.length} matched\n`));
+		let filteredWorkflows = matchedWorkflows;
+		if (options.workflow) {
+			filteredWorkflows = matchedWorkflows.filter((w) => w.name === options.workflow);
+			if (filteredWorkflows.length === 0) {
+				logger.info(pc.yellow(`No workflow found matching: ${options.workflow}`));
+				return false;
+			}
+		}
+		displayDryRun(lockWorkflows, decisions, {
+			workflow: options.workflow,
+			job: options.job
+		});
+		return true;
+	} catch (error) {
+		const message = toErrorMessage(error);
+		logger.error(pc.red(`\nError: ${message}\n`));
+		if (options.debug && error instanceof Error && error.stack) logger.error(pc.gray(error.stack));
+		return false;
+	}
+}
+/**
+* Load lock file if exists, otherwise discover workflows.
+*/
+async function loadWorkflows(kiciDir) {
+	const lockFilePath = path.join(kiciDir, "kici.lock.json");
+	try {
+		const lockContent = await readFile(lockFilePath, "utf-8");
+		const lockFile = JSON.parse(lockContent);
+		logger.info(pc.gray(`Using lock file: ${lockFilePath}`));
+		return {
+			lockFile,
+			workflows: (await discoverWorkflows(kiciDir)).workflows.map((w) => w.workflow)
+		};
+	} catch {
+		logger.info(pc.gray(`Discovering workflows from ${kiciDir}/workflows/`));
+		return { workflows: (await discoverWorkflows(kiciDir)).workflows.map((w) => w.workflow) };
+	}
+}
+/**
+* Convert SDK Workflow to lock-file-like structure for trigger matching.
+*/
+function workflowsToLockFormat(workflows) {
+	return workflows.map((w) => ({
+		name: w.name,
+		contentHash: "",
+		compileSchemaVersion: 0,
+		triggers: transformTriggers(w.on),
+		jobs: w.jobs.map((j, i) => {
+			if (typeof j === "function") return {
+				_type: "dynamic",
+				source: {
+					file: "",
+					index: i
+				}
+			};
+			return {
+				_type: "static",
+				name: j.name,
+				runsOn: typeof j.runsOn === "string" || Array.isArray(j.runsOn) ? j.runsOn : (() => {
+					const n = normalizeRunsOn(j.runsOn);
+					return n.labels.length === 1 ? n.labels[0] : n.labels;
+				})(),
+				needs: j.needs?.map((n) => {
+					if (typeof n === "string") return n;
+					if ("name" in n) return n.name;
+					if ("group" in n) return `__group:${n.group}`;
+					return n.name;
+				}) ?? [],
+				steps: j.steps.map((s) => {
+					if (typeof s === "function") return {
+						name: "",
+						hasOutputs: false
+					};
+					return {
+						name: s.name,
+						hasOutputs: !!s.outputs
+					};
+				}),
+				rules: j.rules?.map((r, ri) => ({
+					_type: "dynamic",
+					label: r.label,
+					source: {
+						file: "",
+						index: ri
+					}
+				})),
+				matrix: j.matrix ? typeof j.matrix === "function" ? {
+					_type: "dynamic",
+					source: {
+						file: "",
+						jobName: j.name
+					}
+				} : {
+					_type: "static",
+					values: j.matrix
+				} : void 0,
+				description: j.description
+			};
+		}),
+		rules: w.rules?.map((r, i) => ({
+			_type: "dynamic",
+			label: r.label,
+			source: {
+				file: "",
+				index: i
+			}
+		})),
+		description: w.description
+	}));
+}
+/**
+* Load test secrets from .kici/.secrets file and merge CLI overrides.
+*/
+async function loadTestSecrets(kiciDir, secretFlags, contextFlags) {
+	const secrets = await loadSecretsFile(kiciDir);
+	if (secretFlags) for (const flag of secretFlags) {
+		const eqIndex = flag.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = flag.slice(0, eqIndex).trim();
+		const value = flag.slice(eqIndex + 1).trim();
+		secrets.flat[key] = value;
+	}
+	if (contextFlags) for (const flag of contextFlags) {
+		const dotIndex = flag.indexOf(".");
+		if (dotIndex === -1) continue;
+		const contextName = flag.slice(0, dotIndex).trim();
+		const rest = flag.slice(dotIndex + 1);
+		const eqIndex = rest.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = rest.slice(0, eqIndex).trim();
+		const value = rest.slice(eqIndex + 1).trim();
+		if (!secrets.contexts[contextName]) secrets.contexts[contextName] = {};
+		secrets.contexts[contextName][key] = value;
+	}
+	return secrets;
+}
+//#endregion
+export { testCommand, testDryRun };
+
+//# sourceMappingURL=test.js.map

package/dist/commands/types.d.ts

@@ -0,0 +1,18 @@
+export interface TypesOptions {
+    /** Path to .kici directory (defaults to .kici) */
+    kiciDir?: string;
+    /** Orchestrator endpoint override (defaults to global config) */
+    endpoint?: string;
+}
+/**
+ * Generate TypeScript declarations for environment secrets.
+ *
+ * Fetches environment metadata from the orchestrator and generates
+ * .kici/types/secrets.d.ts with module augmentation for
+ * KnownSecretKeys and EnvironmentSecrets.
+ *
+ * @param options - Command options
+ * @returns true on success, false on error
+ */
+export declare function typesCommand(options: TypesOptions): Promise<boolean>;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/types.js

@@ -0,0 +1,74 @@
+import "../chunk-gOLHoazu.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import { generateSecretsDts } from "../generators/secrets-dts.js";
+import pc from "picocolors";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { toErrorMessage } from "@kici-dev/shared";
+//#region src/commands/types.ts
+/**
+* Generate TypeScript declarations for environment secrets.
+*
+* Fetches environment metadata from the orchestrator and generates
+* .kici/types/secrets.d.ts with module augmentation for
+* KnownSecretKeys and EnvironmentSecrets.
+*
+* @param options - Command options
+* @returns true on success, false on error
+*/
+async function typesCommand(options) {
+	try {
+		const config = await loadGlobalConfig();
+		if (!config.token) {
+			console.error(pc.red("Not authenticated. Run `kici login` first to connect to your orchestrator."));
+			return false;
+		}
+		const endpoint = options.endpoint ?? config.endpoint;
+		if (!endpoint) {
+			console.error(pc.red("No orchestrator endpoint configured. Run `kici login --endpoint <url>` first."));
+			return false;
+		}
+		if (!config.activeOrgId) {
+			console.error(pc.red("No active organization. Run `kici org list` then `kici org use <name>` first."));
+			return false;
+		}
+		const url = `${endpoint.replace(/\/+$/, "")}/api/v1/admin/environments?orgId=${encodeURIComponent(config.activeOrgId)}&includeSecrets=true`;
+		const res = await fetch(url, { headers: { Authorization: `Bearer ${config.token}` } });
+		if (res.status === 401) {
+			console.error(pc.red("Authentication failed. Check your API key with `kici login`."));
+			return false;
+		}
+		if (res.status === 403) {
+			console.error(pc.red("Permission denied. Your API key does not have environments.read access."));
+			return false;
+		}
+		if (!res.ok) {
+			const text = await res.text();
+			console.error(pc.red(`Failed to fetch environments: ${res.status} ${text}`));
+			return false;
+		}
+		const dtsContent = generateSecretsDts({
+			environments: ((await res.json()).environments ?? []).map((e) => ({
+				name: e.name,
+				keys: e.secret_keys ?? []
+			})),
+			endpoint: endpoint.replace(/\/+$/, ""),
+			generatedAt: /* @__PURE__ */ new Date()
+		});
+		const kiciDir = options.kiciDir ?? ".kici";
+		const typesDir = path.join(kiciDir, "types");
+		await fs.mkdir(typesDir, { recursive: true });
+		const outputPath = path.join(typesDir, "secrets.d.ts");
+		await fs.writeFile(outputPath, dtsContent, "utf-8");
+		console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
+		return true;
+	} catch (err) {
+		const message = toErrorMessage(err);
+		console.error(pc.red(`Failed to generate types: ${message}`));
+		return false;
+	}
+}
+//#endregion
+export { typesCommand };
+
+//# sourceMappingURL=types.js.map

package/dist/commands/watch.d.ts

@@ -0,0 +1,14 @@
+import { type CompileOptions } from './compile.js';
+/**
+ * Run compiler in watch mode.
+ *
+ * Features:
+ * - Clears terminal on each recompile (like tsc --watch)
+ * - Debounces rapid file changes (200ms)
+ * - Graceful shutdown on SIGINT/SIGTERM
+ * - Prevents concurrent compilation
+ *
+ * @param options - Compile options (kiciDir, verbose flag)
+ */
+export declare function watchCommand(options: Omit<CompileOptions, 'check'>): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/commands/watch.js

@@ -0,0 +1,97 @@
+import "../chunk-gOLHoazu.js";
+import { resolveKiciDir } from "../execution/executor.js";
+import "../execution/index.js";
+import { compileCommand } from "./compile.js";
+import pc from "picocolors";
+import path from "node:path";
+import { logger, toErrorMessage } from "@kici-dev/shared";
+import chokidar from "chokidar";
+//#region src/commands/watch.ts
+/** Debounce delay in milliseconds */
+const DEBOUNCE_MS = 200;
+/**
+* Run compiler in watch mode.
+*
+* Features:
+* - Clears terminal on each recompile (like tsc --watch)
+* - Debounces rapid file changes (200ms)
+* - Graceful shutdown on SIGINT/SIGTERM
+* - Prevents concurrent compilation
+*
+* @param options - Compile options (kiciDir, verbose flag)
+*/
+async function watchCommand(options) {
+	const kiciDir = resolveKiciDir(options.kiciDir);
+	const workflowDir = path.join(kiciDir, "workflows");
+	let debounceTimeout = null;
+	let isCompiling = false;
+	let pendingRecompile = false;
+	/**
+	* Run a compilation cycle.
+	* If called while already compiling, sets a flag to recompile after the
+	* current compilation finishes (prevents dropped file changes).
+	*/
+	const compile = async (initial = false) => {
+		if (isCompiling) {
+			pendingRecompile = true;
+			return;
+		}
+		isCompiling = true;
+		pendingRecompile = false;
+		if (!initial) console.clear();
+		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+		logger.debug(pc.dim(`[${timestamp}] Compiling...`));
+		try {
+			if (await compileCommand({
+				kiciDir: options.kiciDir,
+				check: false,
+				verbose: options.verbose
+			})) logger.debug(pc.dim(`\n[${timestamp}] Watching for file changes...`));
+			else logger.debug(pc.dim(`\n[${timestamp}] Fix errors and save to recompile...`));
+		} catch (error) {
+			logger.error(pc.red("Unexpected error:"), toErrorMessage(error));
+			logger.debug(pc.dim(`\n[${timestamp}] Watching for file changes...`));
+		} finally {
+			isCompiling = false;
+			if (pendingRecompile) {
+				pendingRecompile = false;
+				compile();
+			}
+		}
+	};
+	await compile(true);
+	const watcher = chokidar.watch(path.join(workflowDir, "*.ts"), {
+		persistent: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 100,
+			pollInterval: 50
+		},
+		ignoreInitial: true
+	});
+	const handleChange = () => {
+		if (debounceTimeout) clearTimeout(debounceTimeout);
+		debounceTimeout = setTimeout(() => {
+			compile();
+		}, DEBOUNCE_MS);
+	};
+	watcher.on("change", handleChange);
+	watcher.on("add", handleChange);
+	watcher.on("unlink", handleChange);
+	watcher.on("error", (error) => {
+		logger.error(pc.red("Watch error:"), toErrorMessage(error));
+	});
+	logger.debug(pc.dim(`\nWatching for file changes...`));
+	logger.debug(pc.dim(`Press Ctrl+C to stop.\n`));
+	const shutdown = async () => {
+		logger.debug(pc.dim("\nShutting down..."));
+		if (debounceTimeout) clearTimeout(debounceTimeout);
+		await watcher.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+//#endregion
+export { watchCommand };
+
+//# sourceMappingURL=watch.js.map