@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/commands/workflows.d.ts

@@ -0,0 +1,28 @@
+/**
+ * kici workflows list command
+ *
+ * Lists permanently registered workflows by querying the Platform API.
+ * Supports table output (default), JSON output, and stale filtering.
+ */
+/** Options for the workflows list command. */
+export interface WorkflowsListOptions {
+    /** Output as JSON */
+    json?: boolean;
+    /** Filter stale registrations (e.g., "30d", "7d", "24h") */
+    stale?: string;
+    /** Filter by trigger type */
+    triggerType?: string;
+    /** Filter by repository */
+    repo?: string;
+}
+/**
+ * List permanently registered workflows.
+ *
+ * Queries the Platform API for registrations, optionally filtering by trigger type,
+ * repository, or staleness. Displays results as a table or JSON.
+ *
+ * @param options - Command options
+ * @returns true on success, false on error
+ */
+export declare function workflowsListCommand(options?: WorkflowsListOptions): Promise<boolean>;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/commands/workflows.js

@@ -0,0 +1,154 @@
+import "../chunk-gOLHoazu.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import { AuthenticationError, ConnectionError, OrchestratorClient, ServerError } from "../remote/client.js";
+import { formatRelativeTime } from "../format.js";
+import pc from "picocolors";
+import { toErrorMessage } from "@kici-dev/shared";
+//#region src/commands/workflows.ts
+/**
+* kici workflows list command
+*
+* Lists permanently registered workflows by querying the Platform API.
+* Supports table output (default), JSON output, and stale filtering.
+*/
+/**
+* Parse a duration string like "30d", "7d", "24h", "2h" into milliseconds.
+* Returns null if the string is not a valid duration.
+*/
+function parseDuration(duration) {
+	const match = duration.match(/^(\d+)(d|h|m)$/);
+	if (!match) return null;
+	const value = parseInt(match[1], 10);
+	switch (match[2]) {
+		case "d": return value * 24 * 60 * 60 * 1e3;
+		case "h": return value * 60 * 60 * 1e3;
+		case "m": return value * 60 * 1e3;
+		default: return null;
+	}
+}
+/**
+* List permanently registered workflows.
+*
+* Queries the Platform API for registrations, optionally filtering by trigger type,
+* repository, or staleness. Displays results as a table or JSON.
+*
+* @param options - Command options
+* @returns true on success, false on error
+*/
+async function workflowsListCommand(options = {}) {
+	try {
+		const config = await loadGlobalConfig();
+		const token = config.pat ?? config.token;
+		if (!token) {
+			console.error(pc.red("Not authenticated. Run `kici login` to authenticate."));
+			return false;
+		}
+		const endpoint = config.platformEndpoint ?? config.endpoint;
+		if (!endpoint) {
+			console.error(pc.red("No endpoint configured. Run `kici login` to configure."));
+			return false;
+		}
+		const orgId = config.activeOrgId;
+		if (!orgId) {
+			console.error(pc.red("No organization selected. Run `kici org use <name>` to select one."));
+			return false;
+		}
+		const client = new OrchestratorClient({
+			endpoint,
+			token
+		});
+		const filters = {};
+		if (options.triggerType) filters.triggerType = options.triggerType;
+		if (options.repo) filters.repoIdentifier = options.repo;
+		let data;
+		try {
+			data = await client.getRegistrations(orgId, filters);
+		} catch (error) {
+			if (error instanceof AuthenticationError) {
+				console.error(pc.red("Authentication failed. Run `kici login` to re-authenticate."));
+				return false;
+			}
+			if (error instanceof ServerError && error.statusCode === 503) {
+				console.error(pc.red("No orchestrator connected. Ensure your orchestrator is running and connected."));
+				return false;
+			}
+			if (error instanceof ConnectionError) {
+				console.error(pc.red(`Connection failed: ${error.message}`));
+				return false;
+			}
+			throw error;
+		}
+		let registrations = data.registrations;
+		if (options.stale) {
+			const staleMs = parseDuration(options.stale);
+			if (staleMs === null) {
+				console.error(pc.red(`Invalid duration format: "${options.stale}". Use e.g., 30d, 7d, 24h`));
+				return false;
+			}
+			const now = Date.now();
+			registrations = registrations.filter((r) => {
+				if (r.lastTriggeredAt === null) return true;
+				return now - new Date(r.lastTriggeredAt).getTime() > staleMs;
+			});
+		}
+		if (options.json) {
+			console.log(JSON.stringify(registrations, null, 2));
+			return true;
+		}
+		if (registrations.length === 0) {
+			console.log(pc.yellow("No registered workflows found."));
+			return true;
+		}
+		const termWidth = process.stdout.columns || 100;
+		const headers = [
+			"WORKFLOW",
+			"REPO",
+			"TRIGGERS",
+			"LAST TRIGGERED"
+		];
+		const rows = registrations.map((r) => [
+			r.workflowName,
+			r.repoIdentifier,
+			r.triggerTypes.join(", "),
+			r.lastTriggeredAt ? formatRelativeTime(r.lastTriggeredAt) : "Never"
+		]);
+		const colWidths = headers.map((h, i) => {
+			const maxData = Math.max(...rows.map((r) => r[i].length));
+			return Math.max(h.length, maxData);
+		});
+		const totalGaps = (headers.length - 1) * 3;
+		const totalWidth = colWidths.reduce((a, b) => a + b, 0) + totalGaps;
+		if (totalWidth > termWidth) {
+			let excess = totalWidth - termWidth;
+			while (excess > 0) {
+				const maxIdx = colWidths.indexOf(Math.max(...colWidths));
+				const reduction = Math.min(excess, Math.max(0, colWidths[maxIdx] - headers[maxIdx].length));
+				if (reduction === 0) break;
+				colWidths[maxIdx] -= reduction;
+				excess -= reduction;
+			}
+		}
+		const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join("   ");
+		console.log(pc.bold(headerLine));
+		for (const row of rows) {
+			const cells = row.map((cell, i) => {
+				const maxW = colWidths[i];
+				const padded = (cell.length > maxW ? cell.slice(0, maxW - 1) + "…" : cell).padEnd(maxW);
+				if (cell === "Never") return pc.dim(padded);
+				return padded;
+			});
+			console.log(cells.join("   "));
+		}
+		console.log("");
+		console.log(pc.gray(`Registry v${data.registryVersion}, last updated ${formatRelativeTime(data.registryUpdatedAt)}`));
+		return true;
+	} catch (err) {
+		const message = toErrorMessage(err);
+		console.error(pc.red(`Failed to list workflows: ${message}`));
+		return false;
+	}
+}
+//#endregion
+export { workflowsListCommand };
+
+//# sourceMappingURL=workflows.js.map

package/dist/comment-created.json

@@ -0,0 +1,30 @@
+{
+  "action": "created",
+  "comment": {
+    "id": 1,
+    "body": "Looks good to me!",
+    "user": {
+      "login": "test-user"
+    },
+    "created_at": "2026-01-01T00:00:00Z"
+  },
+  "issue": {
+    "number": 42,
+    "title": "Test issue",
+    "state": "open",
+    "pull_request": {
+      "url": "https://api.github.com/repos/test-org/test-repo/pulls/42"
+    }
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "test-org/test-repo",
+    "owner": {
+      "login": "test-org"
+    },
+    "default_branch": "main"
+  },
+  "sender": {
+    "login": "test-user"
+  }
+}

package/dist/create-branch.json

@@ -0,0 +1,17 @@
+{
+  "ref": "feature/new",
+  "ref_type": "branch",
+  "master_branch": "main",
+  "description": null,
+  "repository": {
+    "name": "test-repo",
+    "full_name": "test-org/test-repo",
+    "owner": {
+      "login": "test-org"
+    },
+    "default_branch": "main"
+  },
+  "sender": {
+    "login": "test-user"
+  }
+}

package/dist/delete-branch.json

@@ -0,0 +1,15 @@
+{
+  "ref": "feature/old",
+  "ref_type": "branch",
+  "repository": {
+    "name": "test-repo",
+    "full_name": "test-org/test-repo",
+    "owner": {
+      "login": "test-org"
+    },
+    "default_branch": "main"
+  },
+  "sender": {
+    "login": "test-user"
+  }
+}

package/dist/dispatch.json

@@ -0,0 +1,15 @@
+{
+  "action": "deploy",
+  "client_payload": {},
+  "repository": {
+    "name": "test-repo",
+    "full_name": "test-org/test-repo",
+    "owner": {
+      "login": "test-org"
+    },
+    "default_branch": "main"
+  },
+  "sender": {
+    "login": "test-user"
+  }
+}

package/dist/errors/capability-gap.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Actionable error format for CLI-side capability gaps.
+ *
+ * When the CLI calls an orchestrator feature the orchestrator doesn't support
+ * (e.g. `kici status --logs` against an older orchestrator that lacks the
+ * `/runs/:runId/logs` endpoint), it should tell the operator:
+ *   - which feature is missing,
+ *   - the CLI's own version,
+ *   - the orchestrator's advertised version (fetched from `/capabilities`,
+ *     `undefined` if that fetch failed),
+ *   - and how to resolve it.
+ *
+ * Every capability-gap error in the CLI flows through `formatCapabilityGapError`
+ * so the format stays consistent. Call sites either throw `CapabilityGapError`
+ * (caught at the command boundary and printed) or call the formatter directly.
+ */
+export interface CapabilityGapInfo {
+    /** Short feature name, e.g. `log-streaming`. Shown verbatim in the error. */
+    feature: string;
+    /** CLI package version (from `KICI_VERSION` build constant). */
+    cliVersion: string;
+    /**
+     * Orchestrator's advertised version from `GET /api/v1/capabilities`.
+     * `undefined` when the capabilities probe itself failed (old orchestrator,
+     * network error, etc.) — the formatter prints `unknown` and notes the cause.
+     */
+    orchestratorVersion?: string;
+    /**
+     * Optional override for the trailing guidance paragraph. Default guidance
+     * tells the operator to upgrade the orchestrator and how to confirm its
+     * current version.
+     */
+    guidance?: string;
+}
+/**
+ * Error thrown by CLI code when a capability gap is detected. Command-level
+ * catchers format the attached `info` via `formatCapabilityGapError`.
+ */
+export declare class CapabilityGapError extends Error {
+    readonly info: CapabilityGapInfo;
+    constructor(info: CapabilityGapInfo);
+}
+/**
+ * Produce the user-facing multi-line error string for a capability gap.
+ *
+ * The shape is stable (tests snapshot it). Colours come from picocolors and
+ * degrade gracefully in non-TTY output.
+ */
+export declare function formatCapabilityGapError(info: CapabilityGapInfo): string;
+//# sourceMappingURL=capability-gap.d.ts.map

package/dist/errors/capability-gap.js

@@ -0,0 +1,54 @@
+import "../chunk-gOLHoazu.js";
+import pc from "picocolors";
+//#region src/errors/capability-gap.ts
+/**
+* Actionable error format for CLI-side capability gaps.
+*
+* When the CLI calls an orchestrator feature the orchestrator doesn't support
+* (e.g. `kici status --logs` against an older orchestrator that lacks the
+* `/runs/:runId/logs` endpoint), it should tell the operator:
+*   - which feature is missing,
+*   - the CLI's own version,
+*   - the orchestrator's advertised version (fetched from `/capabilities`,
+*     `undefined` if that fetch failed),
+*   - and how to resolve it.
+*
+* Every capability-gap error in the CLI flows through `formatCapabilityGapError`
+* so the format stays consistent. Call sites either throw `CapabilityGapError`
+* (caught at the command boundary and printed) or call the formatter directly.
+*/
+const DEFAULT_GUIDANCE = "Upgrade the orchestrator to the latest KiCI release to enable this feature.\nRun `kici-admin version` on the orchestrator host to confirm the current version.";
+/**
+* Error thrown by CLI code when a capability gap is detected. Command-level
+* catchers format the attached `info` via `formatCapabilityGapError`.
+*/
+var CapabilityGapError = class extends Error {
+	info;
+	constructor(info) {
+		super(`Feature not supported: ${info.feature}`);
+		this.name = "CapabilityGapError";
+		this.info = info;
+	}
+};
+/**
+* Produce the user-facing multi-line error string for a capability gap.
+*
+* The shape is stable (tests snapshot it). Colours come from picocolors and
+* degrade gracefully in non-TTY output.
+*/
+function formatCapabilityGapError(info) {
+	const orchLine = info.orchestratorVersion ? info.orchestratorVersion : "unknown (capabilities endpoint unreachable)";
+	const guidance = info.guidance ?? DEFAULT_GUIDANCE;
+	return [
+		pc.red(pc.bold(`Feature not supported by the orchestrator: ${info.feature}`)),
+		"",
+		`  CLI version:          ${info.cliVersion}`,
+		`  Orchestrator version: ${orchLine}`,
+		"",
+		...guidance.split("\n").map((line) => `  ${pc.dim(line)}`)
+	].join("\n");
+}
+//#endregion
+export { CapabilityGapError, formatCapabilityGapError };
+
+//# sourceMappingURL=capability-gap.js.map

package/dist/errors/codes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compiler error codes.
+ * Format: EXXX where X is a digit.
+ *
+ * E0XX - Configuration errors (file not found, invalid TypeScript)
+ * E1XX - Validation errors (DAG cycles, missing deps, matrix limits)
+ * E2XX - Lock file errors (serialization issues)
+ */
+export declare const ErrorCodes: {
+    readonly E001: "Config file not found";
+    readonly E002: "Failed to compile TypeScript";
+    readonly E003: "Failed to load config module";
+    readonly E004: "Config does not export workflows";
+    readonly E101: "Job depends on non-existent job";
+    readonly E102: "Circular dependency detected";
+    readonly E103: "Job depends on itself";
+    readonly E104: "Static matrix exceeds 256 job limit";
+    readonly E105: "Invalid trigger configuration";
+    readonly E106: "Duplicate job name";
+    readonly E107: "Duplicate workflow name";
+    readonly E201: "Failed to write lock file";
+    readonly E202: "Failed to serialize workflow";
+};
+export type ErrorCode = keyof typeof ErrorCodes;
+//# sourceMappingURL=codes.d.ts.map

package/dist/errors/formatter.d.ts

@@ -0,0 +1,32 @@
+/** Error code string (e.g., 'E001', 'E102'). */
+type ErrorCode = string;
+/** Source location for error reporting */
+export interface SourceLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+/** Compiler error with all context */
+export interface CompilerError {
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly location?: SourceLocation;
+    readonly suggestion?: string;
+}
+/**
+ * Format error in GNU standard format: file:line:column: error [CODE]: message
+ *
+ * Example output:
+ * .kici/workflows/ci.ts:15:3 error [E102]: Circular dependency detected
+ *   Suggestion: Remove dependency 'build' -> 'test' -> 'build'
+ */
+export declare function formatError(error: CompilerError): string;
+/** Create a CompilerError and throw it */
+export declare function compilerError(code: ErrorCode, message: string, options?: {
+    location?: SourceLocation;
+    suggestion?: string;
+}): CompilerError;
+/** Check if an error is a CompilerError (codes are E + digits, e.g. E001, E102) */
+export declare function isCompilerError(error: unknown): error is CompilerError;
+export {};
+//# sourceMappingURL=formatter.d.ts.map

package/dist/errors/formatter.js

@@ -0,0 +1,35 @@
+import "../chunk-gOLHoazu.js";
+import pc from "picocolors";
+//#region src/errors/formatter.ts
+/**
+* Format error in GNU standard format: file:line:column: error [CODE]: message
+*
+* Example output:
+* .kici/workflows/ci.ts:15:3 error [E102]: Circular dependency detected
+*   Suggestion: Remove dependency 'build' -> 'test' -> 'build'
+*/
+function formatError(error) {
+	const parts = [];
+	if (error.location) parts.push(pc.cyan(`${error.location.file}:${error.location.line}:${error.location.column}`));
+	parts.push(pc.red("error") + pc.gray(` [${error.code}]`) + ": " + error.message);
+	let output = parts.join(" ");
+	if (error.suggestion) output += "\n  " + pc.dim(`Suggestion: ${error.suggestion}`);
+	return output;
+}
+/** Create a CompilerError and throw it */
+function compilerError(code, message, options) {
+	return {
+		code,
+		message,
+		location: options?.location,
+		suggestion: options?.suggestion
+	};
+}
+/** Check if an error is a CompilerError (codes are E + digits, e.g. E001, E102) */
+function isCompilerError(error) {
+	return typeof error === "object" && error !== null && "code" in error && "message" in error && typeof error.code === "string" && /^E\d+$/.test(error.code);
+}
+//#endregion
+export { compilerError, formatError, isCompilerError };
+
+//# sourceMappingURL=formatter.js.map

package/dist/errors/index.d.ts

@@ -0,0 +1,5 @@
+export { formatError, compilerError, isCompilerError } from './formatter.js';
+export type { SourceLocation, CompilerError } from './formatter.js';
+export { CapabilityGapError, formatCapabilityGapError } from './capability-gap.js';
+export type { CapabilityGapInfo } from './capability-gap.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -0,0 +1,4 @@
+import "../chunk-gOLHoazu.js";
+import { compilerError, formatError, isCompilerError } from "./formatter.js";
+import { CapabilityGapError, formatCapabilityGapError } from "./capability-gap.js";
+export { CapabilityGapError, compilerError, formatCapabilityGapError, formatError, isCompilerError };

package/dist/execution/executor.d.ts

@@ -0,0 +1,61 @@
+import type { WorkflowWithSource } from '../types.js';
+/** Result of executing a config file */
+export interface ExecutionResult {
+    /** Workflows exported from the config with source tracking */
+    workflows: WorkflowWithSource[];
+    /** Absolute path to the original config file */
+    configPath: string;
+}
+/** Result of discovering workflows from .kici/workflows/ directory */
+export interface DiscoveryResult {
+    /** All workflows discovered from .kici/workflows/ with source tracking */
+    workflows: WorkflowWithSource[];
+    /** Absolute path to .kici/workflows/ directory */
+    workflowDir: string;
+    /** Absolute path to .kici/ directory */
+    kiciDir: string;
+}
+/**
+ * Execute a TypeScript config file and extract workflow definitions.
+ *
+ * Process:
+ * 1. Read TypeScript source from disk
+ * 2. Transform to ESM JavaScript via rolldown (in-memory)
+ * 3. Write temp file for Node.js dynamic import (required by ESM spec)
+ * 4. Dynamic import the compiled module
+ * 5. Extract and return workflow definitions
+ * 6. Clean up temp file
+ *
+ * @param configPath - Path to workflow file (relative or absolute)
+ * @returns Workflows exported from the config
+ * @throws CompilerError on file not found, TypeScript errors, or missing exports
+ */
+export declare function executeConfig(configPath: string): Promise<ExecutionResult>;
+/**
+ * Resolve the .kici directory path, handling the case where the user
+ * is already inside the .kici directory (or a subdirectory of it).
+ *
+ * Resolution order:
+ * 1. If the resolved path has a workflows/ subdirectory, use it directly
+ * 2. If CWD itself is named .kici and has workflows/, use CWD
+ * 3. Fall through to the original resolved path (downstream code will error)
+ *
+ * @param kiciDir - Path to .kici directory (defaults to '.kici')
+ * @returns Absolute path to the .kici directory
+ */
+export declare function resolveKiciDir(kiciDir?: string): string;
+/**
+ * Discover and execute all workflow files from .kici/workflows/ directory.
+ *
+ * Process:
+ * 1. Locate .kici/workflows/ directory (defaults to .kici relative to cwd)
+ * 2. Find all *.ts files in the directory
+ * 3. Execute each file to extract workflow definitions
+ * 4. Collect and return all workflows
+ *
+ * @param kiciDir - Path to .kici directory (defaults to '.kici' relative to cwd)
+ * @returns Discovery result with all workflows and directory paths
+ * @throws CompilerError if .kici/workflows/ doesn't exist or no workflows found
+ */
+export declare function discoverWorkflows(kiciDir?: string): Promise<DiscoveryResult>;
+//# sourceMappingURL=executor.d.ts.map