@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/templates/package-json.js

@@ -0,0 +1,34 @@
+import "../chunk-gOLHoazu.js";
+//#region src/templates/package-json.ts
+/**
+* Package.json template generator for kici init command
+*
+* Generates package.json for .kici/ directory in TypeScript mode.
+* SDK is a devDependency resolved from the npm registry
+* (or a private Verdaccio instance when .npmrc scopes the registry).
+* The compiler is invoked via npx (not installed as a dependency).
+*/
+/**
+* Generate package.json content for .kici/ directory
+*
+* @param devMode - When true, uses a prerelease-compatible version range
+*   (`>=0.0.1-0`) so npm resolves Verdaccio's prerelease builds (e.g. 0.0.1-2856).
+*   Semver `^0.0.1` does NOT match prereleases, causing 404s on Verdaccio.
+* @returns JSON string with proper formatting (2-space indent, trailing newline)
+*/
+function generatePackageJson(devMode = false) {
+	return JSON.stringify({
+		name: "@kici-dev/workflows",
+		private: true,
+		type: "module",
+		scripts: {
+			compile: "npx --yes kici@latest compile",
+			typecheck: "tsc --noEmit"
+		},
+		devDependencies: { "@kici-dev/sdk": devMode ? ">=0.0.1-0" : "^0.0.1" }
+	}, null, 2) + "\n";
+}
+//#endregion
+export { generatePackageJson };
+
+//# sourceMappingURL=package-json.js.map

package/dist/templates/tsconfig-json.d.ts

@@ -0,0 +1,9 @@
+/**
+ * tsconfig.json template for kici init command
+ *
+ * Exported as a JSON string that matches examples/tsconfig.json exactly.
+ * These settings enable proper TypeScript type checking for workflow files
+ * with NodeNext module resolution.
+ */
+export declare const tsconfigTemplate: string;
+//# sourceMappingURL=tsconfig-json.d.ts.map

package/dist/templates/tsconfig-json.js

@@ -0,0 +1,26 @@
+import "../chunk-gOLHoazu.js";
+//#region src/templates/tsconfig-json.ts
+/**
+* tsconfig.json template for kici init command
+*
+* Exported as a JSON string that matches examples/tsconfig.json exactly.
+* These settings enable proper TypeScript type checking for workflow files
+* with NodeNext module resolution.
+*/
+const tsconfigTemplate = JSON.stringify({
+	compilerOptions: {
+		target: "ES2024",
+		module: "NodeNext",
+		moduleResolution: "NodeNext",
+		strict: true,
+		noEmit: true,
+		esModuleInterop: true,
+		skipLibCheck: true,
+		forceConsistentCasingInFileNames: true
+	},
+	include: ["workflows/**/*", "types/**/*.d.ts"]
+}, null, 2) + "\n";
+//#endregion
+export { tsconfigTemplate };
+
+//# sourceMappingURL=tsconfig-json.js.map

package/dist/templates/workflows/hello-world.d.ts

@@ -0,0 +1,2 @@
+export declare const helloWorldWorkflow: import("@kici-dev/sdk").Workflow;
+//# sourceMappingURL=hello-world.d.ts.map

package/dist/templates/workflows/hello-world.js

@@ -0,0 +1,16 @@
+import "../../chunk-gOLHoazu.js";
+import { job, push, step, workflow } from "@kici-dev/sdk";
+//#region src/templates/workflows/hello-world.ts
+const helloWorldWorkflow = workflow("hello-world", {
+	on: push(),
+	jobs: [job("greet", {
+		runsOn: "ubuntu-latest",
+		steps: [step("say-hello", async ({ $ }) => {
+			await $`echo "Hello, World!"`;
+		})]
+	})]
+});
+//#endregion
+export { helloWorldWorkflow };
+
+//# sourceMappingURL=hello-world.js.map

package/dist/templates/workflows/hello-world.ts

@@ -0,0 +1,21 @@
+// Hello World -- minimal push workflow
+// Docs: https://kici.dev/docs/sdk-reference
+
+import { workflow, job, step, push } from '@kici-dev/sdk';
+
+export const helloWorldWorkflow = workflow('hello-world', {
+  // Trigger: push() matches any push event
+  // Options: branches, tags, paths, description (config-style; use !-prefix for exclusions)
+  on: push(),
+
+  jobs: [
+    job('greet', {
+      runsOn: 'ubuntu-latest',
+      steps: [
+        step('say-hello', async ({ $ }) => {
+          await $`echo "Hello, World!"`;
+        }),
+      ],
+    }),
+  ],
+});

package/dist/templates/workflows/pr-checks.d.ts

@@ -0,0 +1,2 @@
+export declare const prChecksWorkflow: import("@kici-dev/sdk").Workflow;
+//# sourceMappingURL=pr-checks.d.ts.map

package/dist/templates/workflows/pr-checks.js

@@ -0,0 +1,40 @@
+import "../../chunk-gOLHoazu.js";
+import { job, pr, rule, skip, step, workflow } from "@kici-dev/sdk";
+//#region src/templates/workflows/pr-checks.ts
+const prChecksWorkflow = workflow("pr-checks", {
+	on: pr({
+		target: "main",
+		paths: ["src/**"]
+	}),
+	rules: [skip("skip-draft-prs", async (ctx) => {
+		return ctx.event.pull_request?.draft === true;
+	}), rule("require-src-changes", async (ctx) => {
+		return ctx.changedFiles.some((file) => file.startsWith("src/"));
+	})],
+	jobs: [job("lint", {
+		runsOn: "ubuntu-latest",
+		steps: [step("checkout", async ({ $ }) => {
+			await $`echo "Checking out code..."`;
+		}), step("run-linter", async ({ $ }) => {
+			await $`echo "Running linter..."`;
+		})]
+	}), job("test", {
+		runsOn: "ubuntu-latest",
+		needs: ["lint"],
+		steps: [
+			step("checkout", async ({ $ }) => {
+				await $`echo "Checking out code..."`;
+			}),
+			step("install-deps", async ({ $ }) => {
+				await $`echo "Installing dependencies..."`;
+			}),
+			step("run-tests", async ({ $ }) => {
+				await $`echo "Running tests..."`;
+			})
+		]
+	})]
+});
+//#endregion
+export { prChecksWorkflow };
+
+//# sourceMappingURL=pr-checks.js.map

package/dist/templates/workflows/pr-checks.ts

@@ -0,0 +1,57 @@
+// PR Checks -- workflow with rules, dependencies, and multiple jobs
+// Docs: https://kici.dev/docs/sdk-reference
+// Patterns: https://kici.dev/docs/workflow-patterns
+
+import { workflow, job, step, pr, rule, skip } from '@kici-dev/sdk';
+
+export const prChecksWorkflow = workflow('pr-checks', {
+  // Trigger: pr() matches pull request events
+  // Options: target, paths, events (config-style)
+  on: pr({ target: 'main', paths: ['src/**'] }),
+
+  // Rules: evaluated before workflow runs
+  // skip() = skip if true, rule() = run only if true
+  rules: [
+    skip('skip-draft-prs', async (ctx) => {
+      return (ctx.event as any).pull_request?.draft === true;
+    }),
+
+    rule('require-src-changes', async (ctx) => {
+      return ctx.changedFiles.some((file) => file.startsWith('src/'));
+    }),
+  ],
+
+  // Jobs: run in parallel unless connected via `needs`
+  jobs: [
+    job('lint', {
+      runsOn: 'ubuntu-latest',
+      steps: [
+        step('checkout', async ({ $ }) => {
+          await $`echo "Checking out code..."`;
+        }),
+        step('run-linter', async ({ $ }) => {
+          // Replace with your linter: eslint, biome, cargo clippy, etc.
+          await $`echo "Running linter..."`;
+        }),
+      ],
+    }),
+
+    job('test', {
+      runsOn: 'ubuntu-latest',
+      needs: ['lint'], // Waits for lint to pass
+      steps: [
+        step('checkout', async ({ $ }) => {
+          await $`echo "Checking out code..."`;
+        }),
+        step('install-deps', async ({ $ }) => {
+          // Replace with: npm ci, etc.
+          await $`echo "Installing dependencies..."`;
+        }),
+        step('run-tests', async ({ $ }) => {
+          // Replace with: npm test, vitest run, cargo test, etc.
+          await $`echo "Running tests..."`;
+        }),
+      ],
+    }),
+  ],
+});

package/dist/test-runner/dry-run.d.ts

@@ -0,0 +1,12 @@
+import type { LockWorkflow } from '../types.js';
+import type { WorkflowDecision } from '@kici-dev/engine';
+interface DryRunOptions {
+    workflow?: string;
+    job?: string;
+}
+/**
+ * Display dry-run output showing what would execute.
+ */
+export declare function displayDryRun(workflows: readonly LockWorkflow[], decisions: WorkflowDecision[], options: DryRunOptions): void;
+export {};
+//# sourceMappingURL=dry-run.d.ts.map

package/dist/test-runner/dry-run.js

@@ -0,0 +1,66 @@
+import "../chunk-gOLHoazu.js";
+import pc from "picocolors";
+import { logger } from "@kici-dev/shared";
+//#region src/test-runner/dry-run.ts
+/**
+* Display dry-run output showing what would execute.
+*/
+function displayDryRun(workflows, decisions, options) {
+	logger.info(pc.bold("\n🔍 DRY RUN - No commands will be executed\n"));
+	const matchedWorkflows = decisions.filter((d) => d.matched);
+	if (matchedWorkflows.length === 0) {
+		logger.info(pc.yellow("No workflows matched the event.\n"));
+		displayDecisionSummary(decisions);
+		return;
+	}
+	for (const decision of matchedWorkflows) {
+		if (options.workflow && decision.workflowName !== options.workflow) continue;
+		const workflow = workflows.find((w) => w.name === decision.workflowName);
+		logger.info(pc.cyan(`Workflow: ${workflow.name}`));
+		if (workflow.description) logger.info(pc.gray(`  ${workflow.description}`));
+		logger.info(pc.yellow(`  Triggers:`));
+		for (const trigger of workflow.triggers) logger.info(`    - ${trigger._type}`);
+		if (decision.matchedTrigger !== void 0) logger.info(pc.green(`  ✓ Matched trigger ${decision.matchedTrigger + 1}`));
+		const staticJobs = workflow.jobs.filter((j) => j._type === "static");
+		logger.info(pc.yellow(`  Jobs (${staticJobs.length}):`));
+		for (const job of staticJobs) {
+			if (options.job && job.name !== options.job) continue;
+			logger.info(`    ${pc.bold(job.name)}`);
+			logger.info(pc.gray(`      runs-on: ${job.runsOn}`));
+			if (job.needs.length > 0) logger.info(pc.gray(`      needs: ${job.needs.join(", ")}`));
+			if (job.rules && job.rules.length > 0) logger.info(pc.gray(`      rules: ${job.rules.map((r) => r.label).join(", ")}`));
+			if (job.matrix) if (job.matrix._type === "static" && job.matrix.values) logger.info(pc.gray(`      matrix: ${JSON.stringify(job.matrix.values)}`));
+			else logger.info(pc.gray(`      matrix: [dynamic]`));
+			logger.info(pc.gray(`      steps (${job.steps.length}):`));
+			for (const step of job.steps) logger.info(pc.gray(`        - ${step.name}`));
+		}
+		const dynamicJobs = workflow.jobs.filter((j) => j._type === "dynamic");
+		if (dynamicJobs.length > 0) {
+			logger.info(pc.yellow(`  Dynamic job generators (${dynamicJobs.length}):`));
+			for (const _job of dynamicJobs) logger.info(pc.gray(`    - [dynamic job generator]`));
+		}
+		logger.info("");
+	}
+	displayDecisionSummary(decisions);
+	logger.info(pc.green("✓ Dry run complete\n"));
+}
+/**
+* Display decision trace summary.
+*/
+function displayDecisionSummary(decisions) {
+	logger.info(pc.bold("\nDecision Summary:\n"));
+	for (const decision of decisions) {
+		const status = decision.matched ? pc.green("✓ matched") : pc.gray("✗ skipped");
+		logger.info(`  ${decision.workflowName}: ${status}`);
+		logger.info(pc.gray(`    ${decision.summary}`));
+		if (decision.checks.length > 0 && !decision.matched) {
+			const failedCheck = decision.checks.find((c) => !c.passed);
+			if (failedCheck) logger.info(pc.gray(`    Failed: ${failedCheck.check} - ${failedCheck.pattern} vs ${failedCheck.value}`));
+		}
+	}
+	logger.info("");
+}
+//#endregion
+export { displayDryRun };
+
+//# sourceMappingURL=dry-run.js.map

package/dist/test-runner/event-types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Event type mapping system for webhook events.
+ * Supports all 22 trigger types defined in the SDK:
+ * 15 GitHub event types + 7 internal/generic types.
+ */
+import type { LockTrigger } from '../types.js';
+export type EventType = {
+    type: 'pull_request';
+    action: string;
+} | {
+    type: 'push';
+} | {
+    type: 'tag';
+} | {
+    type: 'comment';
+    action: string;
+} | {
+    type: 'review';
+    action: string;
+} | {
+    type: 'review_comment';
+    action: string;
+} | {
+    type: 'release';
+    action: string;
+} | {
+    type: 'dispatch';
+} | {
+    type: 'create';
+    refType?: string;
+} | {
+    type: 'delete';
+    refType?: string;
+} | {
+    type: 'status';
+} | {
+    type: 'workflow_run';
+    action: string;
+} | {
+    type: 'fork';
+} | {
+    type: 'star';
+    action: string;
+} | {
+    type: 'watch';
+    action: string;
+} | {
+    type: 'kici_event';
+    eventName: string;
+} | {
+    type: 'workflow_complete';
+    workflowName: string;
+    status: string;
+} | {
+    type: 'job_complete';
+    workflowName: string;
+    jobName: string;
+    status: string;
+} | {
+    type: 'generic_webhook';
+    source?: string;
+} | {
+    type: 'schedule';
+    cronExpression?: string;
+    timezone?: string;
+} | {
+    type: 'lifecycle';
+    lifecycleEvent: string;
+};
+/**
+ * Parse CLI event argument to EventType.
+ * Supports all trigger types and common action shortcuts.
+ */
+export declare function parseEventArg(arg: string): EventType;
+/**
+ * Derive an event-arg string from a `LockTrigger` that `parseEventArg` can accept.
+ * Inverse of `parseEventArg` for picker-driven flows: pick a trigger, feed the
+ * derived event arg back through the standard pipeline.
+ */
+export declare function triggerToEventArg(trigger: LockTrigger): string;
+/**
+ * One-line label for a `LockTrigger`, suitable for interactive picker rows.
+ * Keeps output compact and human-readable.
+ */
+export declare function triggerSummary(trigger: LockTrigger): string;
+//# sourceMappingURL=event-types.d.ts.map