@kici-dev/compiler 0.0.0 → 0.1.1

package/dist/execution/executor.js

@@ -0,0 +1,230 @@
+import "../chunk-gOLHoazu.js";
+import { compilerError } from "../errors/formatter.js";
+import "../errors/index.js";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/execution/executor.ts
+/**
+* Load a TypeScript workflow/config module by direct dynamic import.
+*
+* Relies on the shared `@kici-dev/shared/ts-loader-hook` ESM loader hook
+* registered by `packages/kici/bin/kici.js` (the same hook the agent registers
+* in its sandbox process). No Rolldown bundling: host-repo imports and
+* transitive deps with dynamic import() resolve via Node's normal ESM loader
+* against the workspace's node_modules — the same module graph any other
+* `npx tsx` invocation would see. This keeps ops-style workflows (which
+* import repo-local modules like scripts/lib/*) working the same as minimal
+* workflows that only touch @kici-dev/sdk.
+*/
+async function loadModule(entryPoint, errorContext) {
+	let hashBundleSource;
+	try {
+		hashBundleSource = await fs.readFile(entryPoint, "utf-8");
+	} catch {}
+	try {
+		return {
+			module: await import(pathToFileURL(entryPoint).href + `?t=${Date.now()}`),
+			hashBundleSource
+		};
+	} catch (err) {
+		const message = err.message ?? "Failed to load module";
+		throw compilerError("E003", `Failed to load ${errorContext.fileLabel} module: ${message}`, {
+			location: {
+				file: errorContext.filePath,
+				line: 1,
+				column: 1
+			},
+			suggestion: `Check for TypeScript or runtime errors in your ${errorContext.fileLabel}. Make sure you invoke the workflow via the kici CLI (the bin shim registers the oxc-transform loader hook that handles TS files).`
+		});
+	}
+}
+/**
+* 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
+*/
+async function executeConfig(configPath) {
+	const absolutePath = path.resolve(configPath);
+	try {
+		await fs.access(absolutePath);
+	} catch {
+		throw compilerError("E001", `Config file not found: ${absolutePath}`, { suggestion: "Ensure workflow files exist in .kici/workflows/" });
+	}
+	try {
+		await fs.readFile(absolutePath, "utf-8");
+	} catch {
+		throw compilerError("E001", `Failed to read config file: ${absolutePath}`, { suggestion: "Check file permissions" });
+	}
+	const { module, hashBundleSource } = await loadModule(absolutePath, {
+		fileLabel: "config file",
+		filePath: absolutePath
+	});
+	return {
+		workflows: extractWorkflows(module, absolutePath, hashBundleSource),
+		configPath: absolutePath
+	};
+}
+/**
+* Extract workflow definitions from a module's exports with source tracking.
+*
+* Supports:
+* - Default export: single workflow or array of workflows
+* - Named exports: any export that is a Workflow object
+*
+* @param module - The imported module
+* @param filePath - Absolute path to the source file
+* @returns Array of WorkflowWithSource objects
+*/
+function extractWorkflows(module, filePath, bundleSource) {
+	const workflows = [];
+	if (module.default) {
+		const defaultExport = module.default;
+		if (isWorkflow(defaultExport)) workflows.push({
+			workflow: defaultExport,
+			source: {
+				file: filePath,
+				exportName: "default"
+			},
+			bundleSource
+		});
+		else if (Array.isArray(defaultExport)) defaultExport.forEach((item, index) => {
+			if (isWorkflow(item)) workflows.push({
+				workflow: item,
+				source: {
+					file: filePath,
+					exportName: "default",
+					arrayIndex: index
+				},
+				bundleSource
+			});
+		});
+	}
+	for (const [key, value] of Object.entries(module)) {
+		if (key === "default") continue;
+		if (isWorkflow(value)) workflows.push({
+			workflow: value,
+			source: {
+				file: filePath,
+				exportName: key
+			},
+			bundleSource
+		});
+	}
+	if (workflows.length === 0) throw compilerError("E004", "Config does not export any workflows", {
+		location: {
+			file: filePath,
+			line: 1,
+			column: 1
+		},
+		suggestion: "Export a workflow using: export default workflow(\"name\", { ... }) or export const myWorkflow = workflow(...)"
+	});
+	return workflows;
+}
+/**
+* Type guard to check if a value is a Workflow object.
+* Uses _tag discriminant from SDK.
+*/
+function isWorkflow(value) {
+	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "Workflow";
+}
+/**
+* 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
+*/
+function resolveKiciDir(kiciDir) {
+	const raw = kiciDir ?? ".kici";
+	const resolved = path.resolve(raw);
+	if (existsSync(path.join(resolved, "workflows"))) return resolved;
+	if (raw === ".kici") {
+		const cwd = process.cwd();
+		if (path.basename(cwd) === ".kici" && existsSync(path.join(cwd, "workflows"))) return cwd;
+	}
+	return resolved;
+}
+/**
+* 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
+*/
+async function discoverWorkflows(kiciDir) {
+	const absoluteKiciDir = resolveKiciDir(kiciDir);
+	const workflowDir = path.join(absoluteKiciDir, "workflows");
+	try {
+		if (!(await fs.stat(workflowDir)).isDirectory()) throw compilerError("E001", `.kici/workflows/ is not a directory: ${workflowDir}`, { suggestion: "Run \"kici init\" to create the .kici/workflows/ directory" });
+	} catch (err) {
+		if (err.code === "ENOENT") throw compilerError("E001", `.kici/workflows/ directory not found: ${workflowDir}`, { suggestion: "Run \"kici init\" to create the .kici/workflows/ directory" });
+		throw err;
+	}
+	let files;
+	try {
+		files = (await fs.readdir(workflowDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => path.join(workflowDir, entry.name));
+	} catch {
+		throw compilerError("E001", `Failed to read .kici/workflows/ directory: ${workflowDir}`, { suggestion: "Check directory permissions" });
+	}
+	if (files.length === 0) throw compilerError("E001", "No workflow files found in .kici/workflows/", { suggestion: "Add *.ts workflow files to .kici/workflows/ or run \"kici init\"" });
+	const allWorkflows = [];
+	for (const file of files) {
+		const result = await executeWorkflowFile(file);
+		allWorkflows.push(...result.workflows);
+	}
+	if (allWorkflows.length === 0) throw compilerError("E004", "No workflows exported from .kici/workflows/ files", { suggestion: "Ensure your workflow files export workflows using: export const myWorkflow = workflow(...)" });
+	return {
+		workflows: allWorkflows,
+		workflowDir,
+		kiciDir: absoluteKiciDir
+	};
+}
+/**
+* Execute a single workflow file and extract workflow definitions.
+* Similar to executeConfig but for individual workflow files.
+*
+* @param filePath - Absolute path to workflow file
+* @returns Execution result with workflows from this file
+*/
+async function executeWorkflowFile(filePath) {
+	try {
+		await fs.access(filePath);
+	} catch {
+		throw compilerError("E001", `Failed to read workflow file: ${filePath}`, { suggestion: "Check file permissions" });
+	}
+	const { module, hashBundleSource } = await loadModule(filePath, {
+		fileLabel: "workflow file",
+		filePath
+	});
+	return {
+		workflows: extractWorkflows(module, filePath, hashBundleSource),
+		configPath: filePath
+	};
+}
+//#endregion
+export { discoverWorkflows, executeConfig, resolveKiciDir };
+
+//# sourceMappingURL=executor.js.map

package/dist/execution/index.d.ts

@@ -0,0 +1,4 @@
+export { executeConfig, discoverWorkflows, resolveKiciDir } from './executor.js';
+export type { ExecutionResult, DiscoveryResult } from './executor.js';
+export type { WorkflowSourceInfo, WorkflowWithSource } from '../types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/index.js

@@ -0,0 +1,3 @@
+import "../chunk-gOLHoazu.js";
+import { discoverWorkflows, executeConfig, resolveKiciDir } from "./executor.js";
+export { discoverWorkflows, executeConfig, resolveKiciDir };

package/dist/execution/sdk-alias.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SDK aliasing for development mode
+ *
+ * Enables automatic aliasing of @kici-dev/sdk imports to a local development repository when:
+ * 1. sdkPath is configured in .kici/package.json
+ * 2. Current project is NOT the kici development repo itself
+ *
+ * This allows developers to test SDK changes in real-time without publishing or manual linking.
+ */
+/**
+ * Get rolldown alias configuration for SDK development mode.
+ *
+ * Returns alias mapping if:
+ * - sdkPath is configured in .kici/package.json
+ * - Current project is NOT the kici repo itself
+ * - SDK build exists at configured path
+ *
+ * @returns Alias config for rolldown (empty object if aliasing disabled)
+ */
+export declare function getSdkAliasConfig(): Promise<Record<string, string>>;
+/**
+ * Get TypeScript path mappings for IDE support.
+ *
+ * Returns path mapping configuration to include in tsconfig.json:
+ * - Points @kici-dev/sdk to local source for autocomplete
+ * - Only if sdkPath is configured and valid
+ *
+ * @returns TypeScript paths config, or null if not applicable
+ */
+export declare function getTypeScriptPaths(): Promise<{
+    '@kici-dev/sdk': [string];
+} | null>;
+//# sourceMappingURL=sdk-alias.d.ts.map

package/dist/execution/sdk-alias.js

@@ -0,0 +1,102 @@
+import "../chunk-gOLHoazu.js";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { logger } from "@kici-dev/shared";
+//#region src/execution/sdk-alias.ts
+/**
+* SDK aliasing for development mode
+*
+* Enables automatic aliasing of @kici-dev/sdk imports to a local development repository when:
+* 1. sdkPath is configured in .kici/package.json
+* 2. Current project is NOT the kici development repo itself
+*
+* This allows developers to test SDK changes in real-time without publishing or manual linking.
+*/
+/**
+* Get rolldown alias configuration for SDK development mode.
+*
+* Returns alias mapping if:
+* - sdkPath is configured in .kici/package.json
+* - Current project is NOT the kici repo itself
+* - SDK build exists at configured path
+*
+* @returns Alias config for rolldown (empty object if aliasing disabled)
+*/
+async function getSdkAliasConfig() {
+	const basePath = await getSdkPathFromPackageJson();
+	if (!basePath) return {};
+	if (await isInKiciRepo()) {
+		if (process.env.KICI_DEBUG === "true") logger.warn("[kici] SDK aliasing disabled: running inside kici development repo");
+		return {};
+	}
+	const sdkPath = resolveAndValidateSdkPath(basePath);
+	if (!sdkPath) return {};
+	logger.warn(`[kici] Development mode: using local SDK from ${path.dirname(path.dirname(sdkPath))}`);
+	return { "@kici-dev/sdk": sdkPath };
+}
+/**
+* Read sdkPath from .kici/package.json configuration.
+*
+* @returns Absolute path to SDK repo, or null if not configured
+*/
+async function getSdkPathFromPackageJson() {
+	try {
+		const content = await readFile(path.resolve(process.cwd(), ".kici", "package.json"), "utf-8");
+		const sdkPath = JSON.parse(content).kici?.sdkPath;
+		if (!sdkPath) return null;
+		return path.resolve(sdkPath);
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if current project is the kici development repository.
+*
+* Checks if root package.json has kici.development flag set to true.
+*
+* @returns true if running inside kici repo
+*/
+async function isInKiciRepo() {
+	try {
+		const content = await readFile(path.resolve(process.cwd(), "package.json"), "utf-8");
+		return JSON.parse(content).kici?.development === true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve and validate the SDK dist path from a base kici repo path.
+*
+* @returns Absolute path to SDK dist/index.js, or null if not found
+*/
+function resolveAndValidateSdkPath(basePath) {
+	const sdkPath = path.resolve(basePath, "packages/sdk/dist/index.js");
+	if (!existsSync(sdkPath)) {
+		logger.warn("[kici] sdkPath configured but SDK not found at path");
+		logger.warn(`[kici] Expected: ${sdkPath}`);
+		logger.warn("[kici] Hint: run \"pnpm build\" in the kici repo");
+		return null;
+	}
+	if (process.env.KICI_DEBUG === "true") logger.warn(`[kici] SDK alias resolved to: ${sdkPath}`);
+	return sdkPath;
+}
+/**
+* Get TypeScript path mappings for IDE support.
+*
+* Returns path mapping configuration to include in tsconfig.json:
+* - Points @kici-dev/sdk to local source for autocomplete
+* - Only if sdkPath is configured and valid
+*
+* @returns TypeScript paths config, or null if not applicable
+*/
+async function getTypeScriptPaths() {
+	const basePath = await getSdkPathFromPackageJson();
+	if (!basePath) return null;
+	if (await isInKiciRepo()) return null;
+	return { "@kici-dev/sdk": [path.resolve(basePath, "packages/sdk/src/index.ts")] };
+}
+//#endregion
+export { getSdkAliasConfig, getTypeScriptPaths };
+
+//# sourceMappingURL=sdk-alias.js.map

package/dist/fixtures/compiler.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Fixture auto-compilation pipeline.
+ *
+ * Discovers and dynamic-imports Fixture exports from `.kici/tests/*.ts` files.
+ * TypeScript transformation is handled by the shared oxc-transform ESM loader
+ * hook registered by the kici CLI bin (`@kici-dev/shared/ts-loader-hook`),
+ * which is the same hook the agent registers. Fixture files are imported in
+ * place so Node resolves `@kici-dev/sdk` from the customer's
+ * `.kici/node_modules/` — no temp files, no Rolldown bundle step.
+ */
+import type { Fixture } from '@kici-dev/sdk';
+/** A compiled fixture with source tracking */
+export interface CompiledFixture {
+    /** Fixture ID */
+    id: string;
+    /** Absolute path to the source file */
+    sourceFile: string;
+    /** Resolved fixture definition */
+    fixture: Fixture;
+}
+/**
+ * Discover fixture files in the tests directory.
+ *
+ * Scans recursively for `*.ts` files.
+ * Returns empty array if directory doesn't exist (not an error).
+ */
+export declare function discoverFixtureFiles(testsDir: string): Promise<string[]>;
+/**
+ * Compile and extract fixtures from all `.kici/tests/*.ts` files.
+ *
+ * Process:
+ * 1. Discover fixture files.
+ * 2. Dynamic-import each `.ts` file (transformed on the fly by the shared
+ *    oxc-transform ESM loader hook registered by the kici CLI bin).
+ * 3. Extract Fixture exports.
+ * 4. Resolve async factory fixtures.
+ * 5. Validate no duplicate fixture IDs.
+ */
+export declare function compileFixtures(testsDir: string): Promise<CompiledFixture[]>;
+/**
+ * Filter compiled fixtures by pattern.
+ *
+ * - Exact match on fixture ID
+ * - Glob pattern matching via picomatch
+ */
+export declare function filterFixtures(fixtures: CompiledFixture[], pattern: string): CompiledFixture[];
+//# sourceMappingURL=compiler.d.ts.map

package/dist/fixtures/compiler.js

@@ -0,0 +1,177 @@
+import "../chunk-gOLHoazu.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import picomatch from "picomatch";
+//#region src/fixtures/compiler.ts
+/**
+* Fixture auto-compilation pipeline.
+*
+* Discovers and dynamic-imports Fixture exports from `.kici/tests/*.ts` files.
+* TypeScript transformation is handled by the shared oxc-transform ESM loader
+* hook registered by the kici CLI bin (`@kici-dev/shared/ts-loader-hook`),
+* which is the same hook the agent registers. Fixture files are imported in
+* place so Node resolves `@kici-dev/sdk` from the customer's
+* `.kici/node_modules/` — no temp files, no Rolldown bundle step.
+*/
+/**
+* Discover fixture files in the tests directory.
+*
+* Scans recursively for `*.ts` files.
+* Returns empty array if directory doesn't exist (not an error).
+*/
+async function discoverFixtureFiles(testsDir) {
+	const absoluteDir = path.resolve(testsDir);
+	try {
+		if (!(await fs.stat(absoluteDir)).isDirectory()) return [];
+	} catch {
+		return [];
+	}
+	return (await scanDirectory(absoluteDir)).sort();
+}
+async function scanDirectory(dir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	const results = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			const nested = await scanDirectory(fullPath);
+			results.push(...nested);
+		} else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) results.push(fullPath);
+	}
+	return results;
+}
+/**
+* Compile and extract fixtures from all `.kici/tests/*.ts` files.
+*
+* Process:
+* 1. Discover fixture files.
+* 2. Dynamic-import each `.ts` file (transformed on the fly by the shared
+*    oxc-transform ESM loader hook registered by the kici CLI bin).
+* 3. Extract Fixture exports.
+* 4. Resolve async factory fixtures.
+* 5. Validate no duplicate fixture IDs.
+*/
+async function compileFixtures(testsDir) {
+	const files = await discoverFixtureFiles(testsDir);
+	if (files.length === 0) return [];
+	const allFixtures = [];
+	for (const file of files) {
+		const fixtures = await loadFixtureFile(file);
+		allFixtures.push(...fixtures);
+	}
+	const seenIds = /* @__PURE__ */ new Map();
+	for (const cf of allFixtures) {
+		const existing = seenIds.get(cf.id);
+		if (existing) throw new Error(`Duplicate fixture ID "${cf.id}" found in:\n  - ${existing}\n  - ${cf.sourceFile}`);
+		seenIds.set(cf.id, cf.sourceFile);
+	}
+	return allFixtures;
+}
+async function loadFixtureFile(filePath) {
+	const createdLinks = await ensureRuntimeSymlinks(filePath);
+	let mod;
+	try {
+		mod = await import(pathToFileURL(filePath).href + `?t=${Date.now()}`);
+	} catch (err) {
+		throw new Error(`Failed to load fixture module ${filePath}: ${err.message}`);
+	} finally {
+		for (const link of createdLinks.reverse()) await fs.rm(link, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+	const fixtures = [];
+	for (const [key, value] of Object.entries(mod)) {
+		if (key === "default") continue;
+		if (isFixture(value)) {
+			const resolved = await resolveFixture(value);
+			fixtures.push({
+				id: resolved.id,
+				sourceFile: filePath,
+				fixture: resolved
+			});
+		}
+	}
+	return fixtures;
+}
+const RUNTIME_PACKAGES = [
+	"@kici-dev/sdk",
+	"zx",
+	"@kici-dev/shared"
+];
+async function ensureRuntimeSymlinks(filePath) {
+	const created = [];
+	let nodeModulesDir = await findNearestNodeModules(path.dirname(filePath));
+	if (!nodeModulesDir) {
+		nodeModulesDir = path.join(path.dirname(filePath), "node_modules");
+		await fs.mkdir(nodeModulesDir, { recursive: true });
+		created.push(nodeModulesDir);
+	}
+	for (const pkg of RUNTIME_PACKAGES) {
+		const linkPath = path.join(nodeModulesDir, pkg);
+		try {
+			await fs.access(linkPath);
+			continue;
+		} catch {}
+		try {
+			const pkgDir = await findPackageRoot(fileURLToPath(import.meta.resolve(pkg)));
+			const linkParent = path.dirname(linkPath);
+			if (linkParent !== nodeModulesDir) await fs.mkdir(linkParent, { recursive: true });
+			await fs.symlink(pkgDir, linkPath);
+			created.push(linkPath);
+		} catch {}
+	}
+	return created;
+}
+async function findNearestNodeModules(startDir) {
+	let dir = startDir;
+	while (dir !== path.dirname(dir)) {
+		const nm = path.join(dir, "node_modules");
+		try {
+			if ((await fs.stat(nm)).isDirectory()) return nm;
+		} catch {}
+		dir = path.dirname(dir);
+	}
+}
+async function findPackageRoot(filePath) {
+	let dir = path.dirname(filePath);
+	while (dir !== path.dirname(dir)) try {
+		await fs.access(path.join(dir, "package.json"));
+		return dir;
+	} catch {
+		dir = path.dirname(dir);
+	}
+	return path.dirname(filePath);
+}
+function isFixture(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	return typeof obj.id === "string" && obj.id.length > 0 && (typeof obj.options === "object" || typeof obj.options === "function") && obj.options !== null;
+}
+async function resolveFixture(fixture) {
+	if (typeof fixture.options === "function") {
+		const resolved = await fixture.options();
+		return Object.freeze({
+			id: fixture.id,
+			options: Object.freeze(resolved)
+		});
+	}
+	return fixture;
+}
+/**
+* Filter compiled fixtures by pattern.
+*
+* - Exact match on fixture ID
+* - Glob pattern matching via picomatch
+*/
+function filterFixtures(fixtures, pattern) {
+	const exact = fixtures.find((f) => f.id === pattern);
+	if (exact) return [exact];
+	const isMatch = picomatch(pattern);
+	return fixtures.filter((f) => isMatch(f.id)).sort((a, b) => a.id.localeCompare(b.id));
+}
+//#endregion
+export { compileFixtures, discoverFixtureFiles, filterFixtures };
+
+//# sourceMappingURL=compiler.js.map

package/dist/fixtures/defaults/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/fixtures/defaults/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/fixtures/defaults/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/fixtures/defaults/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"
+  }
+}