@kici-dev/compiler 0.0.0 → 0.1.1

package/dist/lockfile/hash-files.js

@@ -0,0 +1,50 @@
+import "../chunk-gOLHoazu.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+//#region src/lockfile/hash-files.ts
+/**
+* Resolve hashFiles patterns (paths and globs) relative to git root and build a deterministic
+* digest string: sorted resolved paths, each followed by "\n" and file content.
+* Used as input to the content hash so workflow cache invalidates when these files change.
+*
+* @param gitRoot - Absolute path to git repository root
+* @param patterns - Paths or glob patterns relative to repo root (e.g. ["config.json", "scripts/*.sh"])
+* @returns Object with digest string and list of resolved paths (relative to git root), or null if no patterns or resolution fails
+*/
+function resolveHashFiles(gitRoot, patterns) {
+	if (patterns.length === 0) return null;
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const pattern of patterns) {
+		const matches = fg.sync(pattern, {
+			cwd: gitRoot,
+			absolute: false,
+			onlyFiles: true,
+			dot: false,
+			followSymbolicLinks: false
+		});
+		for (const p of matches) {
+			const normalized = path.normalize(p).replace(/\\/g, "/");
+			if (seen.has(normalized)) continue;
+			seen.add(normalized);
+			resolved.push(normalized);
+		}
+	}
+	resolved.sort();
+	const parts = [];
+	for (const rel of resolved) try {
+		const content = readFileSync(path.join(gitRoot, rel), "utf-8");
+		parts.push(`${rel}\n${content}`);
+	} catch {
+		parts.push(`${rel}\n`);
+	}
+	return {
+		assetDigest: parts.join(""),
+		resolvedPaths: resolved
+	};
+}
+//#endregion
+export { resolveHashFiles };
+
+//# sourceMappingURL=hash-files.js.map

package/dist/lockfile/hasher.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Compile schema version -- bump when compilation approach changes
+ * (bundler change, bundling config, output format, etc.).
+ * This is NOT the lock file schema version.
+ *
+ * Bumped 3 → 4: the agent artifact switched from a Rolldown-bundled
+ * `.compiled.mjs` to a raw `.kici/` source tarball that the agent extracts
+ * and imports via the shared oxc-transform ESM loader hook.
+ *
+ * Bumped 4 → 5: the hash input is now line-ending-normalized (CRLF → LF) so a
+ * lockfile produced on Linux (LF) matches the agent's hash on Windows, where
+ * Git's `core.autocrlf=true` system default rewrites checked-out text files to
+ * CRLF. Old lockfiles must be regenerated via `kici compile`.
+ */
+export declare const COMPILE_SCHEMA_VERSION = 5;
+/**
+ * Compute content hash for a compiled workflow bundle, optionally including asset file contents.
+ * Hash = SHA-256(schemaVersion + ":" + bundleSource + "\0" + assetDigest) when assetDigest is provided,
+ * otherwise SHA-256(schemaVersion + ":" + bundleSource) for backward compatibility.
+ *
+ * The schema version is mixed into the hash input so that
+ * different compilation approaches produce different hashes
+ * even if the source hasn't changed.
+ *
+ * Line endings in `bundleSource` (and inside `assetDigest`) are normalized to
+ * LF before hashing — the agent applies the same normalization, so the hash
+ * agrees across platforms even when Git's `core.autocrlf=true` rewrites the
+ * working tree on Windows. Callers should not pre-normalize.
+ *
+ * @param bundleSource - The compiled JS bundle text (without source maps)
+ * @param schemaVersion - The compile schema version to mix into the hash
+ * @param assetDigest - Optional deterministic encoding of resolved hashFiles (path + content per file, sorted by path). Omit for bundle-only hash.
+ * @returns 64-character lowercase hex SHA-256 digest
+ */
+export declare function computeContentHash(bundleSource: string, schemaVersion: number, assetDigest?: string): string;
+//# sourceMappingURL=hasher.d.ts.map

package/dist/lockfile/hasher.js

@@ -0,0 +1,46 @@
+import "../chunk-gOLHoazu.js";
+import { normalizeLineEndings, sha256 } from "@kici-dev/shared";
+//#region src/lockfile/hasher.ts
+/**
+* Compile schema version -- bump when compilation approach changes
+* (bundler change, bundling config, output format, etc.).
+* This is NOT the lock file schema version.
+*
+* Bumped 3 → 4: the agent artifact switched from a Rolldown-bundled
+* `.compiled.mjs` to a raw `.kici/` source tarball that the agent extracts
+* and imports via the shared oxc-transform ESM loader hook.
+*
+* Bumped 4 → 5: the hash input is now line-ending-normalized (CRLF → LF) so a
+* lockfile produced on Linux (LF) matches the agent's hash on Windows, where
+* Git's `core.autocrlf=true` system default rewrites checked-out text files to
+* CRLF. Old lockfiles must be regenerated via `kici compile`.
+*/
+const COMPILE_SCHEMA_VERSION = 5;
+/**
+* Compute content hash for a compiled workflow bundle, optionally including asset file contents.
+* Hash = SHA-256(schemaVersion + ":" + bundleSource + "\0" + assetDigest) when assetDigest is provided,
+* otherwise SHA-256(schemaVersion + ":" + bundleSource) for backward compatibility.
+*
+* The schema version is mixed into the hash input so that
+* different compilation approaches produce different hashes
+* even if the source hasn't changed.
+*
+* Line endings in `bundleSource` (and inside `assetDigest`) are normalized to
+* LF before hashing — the agent applies the same normalization, so the hash
+* agrees across platforms even when Git's `core.autocrlf=true` rewrites the
+* working tree on Windows. Callers should not pre-normalize.
+*
+* @param bundleSource - The compiled JS bundle text (without source maps)
+* @param schemaVersion - The compile schema version to mix into the hash
+* @param assetDigest - Optional deterministic encoding of resolved hashFiles (path + content per file, sorted by path). Omit for bundle-only hash.
+* @returns 64-character lowercase hex SHA-256 digest
+*/
+function computeContentHash(bundleSource, schemaVersion, assetDigest) {
+	let input = `${schemaVersion}:${normalizeLineEndings(bundleSource)}`;
+	if (assetDigest !== void 0 && assetDigest.length > 0) input += `\0${normalizeLineEndings(assetDigest)}`;
+	return sha256(input);
+}
+//#endregion
+export { COMPILE_SCHEMA_VERSION, computeContentHash };
+
+//# sourceMappingURL=hasher.js.map

package/dist/lockfile/index.d.ts

@@ -0,0 +1,3 @@
+export { generateLockFile, serializeLockFile, detectGitRoot, computeLockfileHash, } from './generator.js';
+export { computeContentHash, COMPILE_SCHEMA_VERSION } from './hasher.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lockfile/index.js

@@ -0,0 +1,4 @@
+import "../chunk-gOLHoazu.js";
+import { COMPILE_SCHEMA_VERSION, computeContentHash } from "./hasher.js";
+import { computeLockfileHash, detectGitRoot, generateLockFile, serializeLockFile } from "./generator.js";
+export { COMPILE_SCHEMA_VERSION, computeContentHash, computeLockfileHash, detectGitRoot, generateLockFile, serializeLockFile };

package/dist/lockfile/purity-analyzer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AST-based purity analysis for dynamic job functions.
+ * Determines whether a function can be safely evaluated inline by the orchestrator
+ * (via vm.runInNewContext) without requiring a full init job dispatch.
+ *
+ * A function is "pure" if it:
+ * - Is synchronous (not async)
+ * - Only references its parameters and safe globals
+ * - Does not perform I/O, mutation, or use external scope
+ * - Only uses const/let for local declarations (no var)
+ */
+/** Result of purity analysis */
+interface PurityResult {
+    pure: boolean;
+    reason?: string;
+}
+/**
+ * Analyze whether a function source string represents a pure function.
+ *
+ * @param fnSource - The function source code (e.g., "(event) => event.ref")
+ * @returns PurityResult indicating whether the function is pure
+ */
+export declare function analyzePurity(fnSource: string): PurityResult;
+export {};
+//# sourceMappingURL=purity-analyzer.d.ts.map

package/dist/lockfile/purity-analyzer.js

@@ -0,0 +1,204 @@
+import "../chunk-gOLHoazu.js";
+import ts from "typescript";
+//#region src/lockfile/purity-analyzer.ts
+/**
+* AST-based purity analysis for dynamic job functions.
+* Determines whether a function can be safely evaluated inline by the orchestrator
+* (via vm.runInNewContext) without requiring a full init job dispatch.
+*
+* A function is "pure" if it:
+* - Is synchronous (not async)
+* - Only references its parameters and safe globals
+* - Does not perform I/O, mutation, or use external scope
+* - Only uses const/let for local declarations (no var)
+*/
+/**
+* Safe globals that pure functions are allowed to reference.
+* These are deterministic, side-effect-free built-ins.
+*/
+const SAFE_GLOBALS = new Set([
+	"undefined",
+	"null",
+	"true",
+	"false",
+	"NaN",
+	"Infinity",
+	"String",
+	"Number",
+	"Boolean",
+	"Array",
+	"Object",
+	"JSON",
+	"Math",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"encodeURI",
+	"decodeURI"
+]);
+/**
+* Assignment operators that indicate mutation.
+*/
+const ASSIGNMENT_OPERATORS = new Set([
+	ts.SyntaxKind.EqualsToken,
+	ts.SyntaxKind.PlusEqualsToken,
+	ts.SyntaxKind.MinusEqualsToken,
+	ts.SyntaxKind.AsteriskEqualsToken,
+	ts.SyntaxKind.SlashEqualsToken,
+	ts.SyntaxKind.PercentEqualsToken,
+	ts.SyntaxKind.AmpersandEqualsToken,
+	ts.SyntaxKind.BarEqualsToken,
+	ts.SyntaxKind.CaretEqualsToken,
+	ts.SyntaxKind.LessThanLessThanEqualsToken,
+	ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+	ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+	ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+	ts.SyntaxKind.BarBarEqualsToken,
+	ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+	ts.SyntaxKind.QuestionQuestionEqualsToken
+]);
+/**
+* Analyze whether a function source string represents a pure function.
+*
+* @param fnSource - The function source code (e.g., "(event) => event.ref")
+* @returns PurityResult indicating whether the function is pure
+*/
+function analyzePurity(fnSource) {
+	const wrapped = "const __fn = " + fnSource;
+	const firstStatement = ts.createSourceFile("inline.js", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS).statements[0];
+	if (!ts.isVariableStatement(firstStatement)) return {
+		pure: false,
+		reason: "failed to parse function source"
+	};
+	const declaration = firstStatement.declarationList.declarations[0];
+	if (!declaration.initializer) return {
+		pure: false,
+		reason: "failed to parse function source"
+	};
+	const fnNode = declaration.initializer;
+	if (!ts.isArrowFunction(fnNode) && !ts.isFunctionExpression(fnNode)) return {
+		pure: false,
+		reason: "not a function expression"
+	};
+	if (ts.getModifiers(fnNode)?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) return {
+		pure: false,
+		reason: "async functions cannot be inlined"
+	};
+	if (ts.isFunctionExpression(fnNode) && fnNode.asteriskToken) return {
+		pure: false,
+		reason: "generator functions cannot be inlined"
+	};
+	const paramNames = /* @__PURE__ */ new Set();
+	for (const param of fnNode.parameters) collectBindingNames(param.name, paramNames);
+	const localNames = /* @__PURE__ */ new Set();
+	return checkNode(fnNode.body, paramNames, localNames) ?? { pure: true };
+}
+/**
+* Recursively collect binding names from parameter declarations,
+* including destructured patterns.
+*/
+function collectBindingNames(node, names) {
+	if (ts.isIdentifier(node)) names.add(node.text);
+	else if (ts.isObjectBindingPattern(node)) for (const element of node.elements) collectBindingNames(element.name, names);
+	else if (ts.isArrayBindingPattern(node)) {
+		for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectBindingNames(element.name, names);
+	}
+}
+/**
+* Check a node and its children for impurity.
+* Returns a PurityResult if impure, or undefined if pure so far.
+*/
+function checkNode(node, paramNames, localNames) {
+	switch (node.kind) {
+		case ts.SyntaxKind.AwaitExpression: return {
+			pure: false,
+			reason: "contains await expression"
+		};
+		case ts.SyntaxKind.ImportDeclaration: return {
+			pure: false,
+			reason: "contains import declaration"
+		};
+		case ts.SyntaxKind.YieldExpression: return {
+			pure: false,
+			reason: "contains yield expression"
+		};
+		case ts.SyntaxKind.ClassDeclaration:
+		case ts.SyntaxKind.ClassExpression: return {
+			pure: false,
+			reason: "contains class declaration"
+		};
+		case ts.SyntaxKind.ThisKeyword: return {
+			pure: false,
+			reason: "references 'this'"
+		};
+		case ts.SyntaxKind.DeleteExpression: return {
+			pure: false,
+			reason: "contains 'delete' expression"
+		};
+		case ts.SyntaxKind.ThrowStatement: return {
+			pure: false,
+			reason: "contains throw statement"
+		};
+		case ts.SyntaxKind.TryStatement: return {
+			pure: false,
+			reason: "contains try/catch"
+		};
+	}
+	if (ts.isNewExpression(node)) return {
+		pure: false,
+		reason: "contains 'new' expression"
+	};
+	if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) return {
+		pure: false,
+		reason: "contains dynamic import"
+	};
+	if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require") return {
+		pure: false,
+		reason: "contains require() call"
+	};
+	if (ts.isPostfixUnaryExpression(node)) {
+		if (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) return {
+			pure: false,
+			reason: "contains mutation operator"
+		};
+	}
+	if (ts.isPrefixUnaryExpression(node)) {
+		if (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) return {
+			pure: false,
+			reason: "contains mutation operator"
+		};
+	}
+	if (ts.isBinaryExpression(node) && ASSIGNMENT_OPERATORS.has(node.operatorToken.kind)) return {
+		pure: false,
+		reason: "contains assignment"
+	};
+	if (ts.isVariableDeclarationList(node)) if (node.flags & ts.NodeFlags.Const || node.flags & ts.NodeFlags.Let) for (const decl of node.declarations) collectBindingNames(decl.name, localNames);
+	else return {
+		pure: false,
+		reason: "'var' declarations are not allowed (use const or let)"
+	};
+	if (ts.isIdentifier(node)) {
+		const parent = node.parent;
+		if (ts.isPropertyAccessExpression(parent) && parent.name === node) {} else if (ts.isPropertyAssignment(parent) && parent.name === node) {} else if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
+			if (!paramNames.has(node.text) && !localNames.has(node.text) && !SAFE_GLOBALS.has(node.text)) return {
+				pure: false,
+				reason: `references unknown identifier '${node.text}'`
+			};
+		} else if (ts.isVariableDeclaration(parent) && parent.name === node) {} else if (ts.isBindingElement(parent) && parent.name === node) {} else if (ts.isParameter(parent) && parent.name === node) {} else if (!paramNames.has(node.text) && !localNames.has(node.text) && !SAFE_GLOBALS.has(node.text)) return {
+			pure: false,
+			reason: `references unknown identifier '${node.text}'`
+		};
+	}
+	const children = node.getChildren();
+	for (const child of children) {
+		const result = checkNode(child, paramNames, localNames);
+		if (result) return result;
+	}
+}
+//#endregion
+export { analyzePurity };
+
+//# sourceMappingURL=purity-analyzer.js.map

package/dist/package-F7UXSDHW.json

@@ -0,0 +1,74 @@
+{
+	"name": "winston",
+	"description": "A logger for just about everything.",
+	"version": "3.19.0",
+	"author": "Charlie Robbins <charlie.robbins@gmail.com>",
+	"maintainers": [
+		"David Hyde <dabh@alumni.stanford.edu>"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/winstonjs/winston.git"
+	},
+	"keywords": [
+		"winston",
+		"logger",
+		"logging",
+		"logs",
+		"sysadmin",
+		"bunyan",
+		"pino",
+		"loglevel",
+		"tools",
+		"json",
+		"stream"
+	],
+	"dependencies": {
+		"@dabh/diagnostics": "^2.0.8",
+		"@colors/colors": "^1.6.0",
+		"async": "^3.2.3",
+		"is-stream": "^2.0.0",
+		"logform": "^2.7.0",
+		"one-time": "^1.0.0",
+		"readable-stream": "^3.4.0",
+		"safe-stable-stringify": "^2.3.1",
+		"stack-trace": "0.0.x",
+		"triple-beam": "^1.3.0",
+		"winston-transport": "^4.9.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.23.9",
+		"@babel/core": "^7.24.0",
+		"@babel/preset-env": "^7.24.0",
+		"@dabh/eslint-config-populist": "^4.4.0",
+		"@types/node": "^20.11.24",
+		"abstract-winston-transport": "^0.5.1",
+		"assume": "^2.2.0",
+		"cross-spawn-async": "^2.2.5",
+		"eslint": "^8.57.0",
+		"hock": "^1.4.1",
+		"jest": "^29.7.0",
+		"rimraf": "5.0.10",
+		"split2": "^4.1.0",
+		"std-mocks": "^2.0.0",
+		"through2": "^4.0.2",
+		"winston-compat": "^0.1.5"
+	},
+	"main": "./lib/winston.js",
+	"browser": "./dist/winston",
+	"types": "./index.d.ts",
+	"scripts": {
+		"lint": "eslint lib/*.js lib/winston/*.js lib/winston/**/*.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist",
+		"test": "jest",
+		"test:unit": "jest -c test/jest.config.unit.js",
+		"test:integration": "jest -c test/jest.config.integration.js",
+		"test:typescript": "npx --package typescript tsc --project test",
+		"build": "babel lib -d dist",
+		"prebuild": "rimraf dist",
+		"prepublishOnly": "npm run build"
+	},
+	"engines": {
+		"node": ">= 12.0.0"
+	},
+	"license": "MIT"
+}

package/dist/postinstall.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for @kici-dev/compiler
+ *
+ * Prompts users to run `kici init` after installing the package.
+ * Skips in CI environments, non-TTY, dev mode, and if .kici/ already exists.
+ */
+export {};
+//# sourceMappingURL=postinstall.d.ts.map

package/dist/postinstall.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import "./chunk-gOLHoazu.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { confirm } from "@inquirer/prompts";
+//#region src/postinstall.ts
+/**
+* Post-install script for @kici-dev/compiler
+*
+* Prompts users to run `kici init` after installing the package.
+* Skips in CI environments, non-TTY, dev mode, and if .kici/ already exists.
+*/
+/**
+* Detect if running in development mode
+*
+* Development mode is used when developing KiCI itself.
+* Checks:
+* 1. KICI_DEV environment variable
+* 2. Root package.json kici.development flag
+*
+* @returns true if in development mode
+*/
+async function detectDevelopmentMode() {
+	if (process.env.KICI_DEV === "true") return true;
+	try {
+		const rootDir = process.env.INIT_CWD || process.cwd();
+		const content = await readFile(path.join(rootDir, "package.json"), "utf-8");
+		return JSON.parse(content).kici?.development === true;
+	} catch {
+		return false;
+	}
+}
+async function main() {
+	if (await detectDevelopmentMode()) return;
+	if (process.env.CI === "true" || !process.stdout.isTTY) return;
+	const fs = await import("node:fs/promises");
+	try {
+		await fs.access(".kici");
+		return;
+	} catch {}
+	console.log("\n");
+	if (await confirm({
+		message: "Would you like to initialize .kici/ directory now?",
+		default: true
+	})) {
+		console.log("\nRunning kici init...\n");
+		spawn("npx", ["kici", "init"], {
+			stdio: "inherit",
+			shell: true
+		}).on("error", (err) => {
+			console.error("Failed to run kici init:", err.message);
+		});
+	} else console.log("\nYou can run \"npx kici init\" later to set up workflows.\n");
+}
+main().catch(() => {});
+//#endregion
+export {};
+
+//# sourceMappingURL=postinstall.js.map

package/dist/pr-closed.json

@@ -0,0 +1,28 @@
+{
+  "action": "closed",
+  "number": 1,
+  "pull_request": {
+    "number": 1,
+    "title": "Test PR",
+    "state": "closed",
+    "merged": false,
+    "head": {
+      "ref": "feature-branch",
+      "sha": "abc123"
+    },
+    "base": {
+      "ref": "main",
+      "sha": "def456"
+    }
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "owner/test-repo",
+    "owner": {
+      "login": "owner"
+    }
+  },
+  "sender": {
+    "login": "user"
+  }
+}

package/dist/pr-opened.json

@@ -0,0 +1,27 @@
+{
+  "action": "opened",
+  "number": 1,
+  "pull_request": {
+    "number": 1,
+    "title": "Test PR",
+    "state": "open",
+    "head": {
+      "ref": "feature-branch",
+      "sha": "abc123"
+    },
+    "base": {
+      "ref": "main",
+      "sha": "def456"
+    }
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "owner/test-repo",
+    "owner": {
+      "login": "owner"
+    }
+  },
+  "sender": {
+    "login": "user"
+  }
+}

package/dist/pr-reopened.json

@@ -0,0 +1,27 @@
+{
+  "action": "reopened",
+  "number": 1,
+  "pull_request": {
+    "number": 1,
+    "title": "Test PR",
+    "state": "open",
+    "head": {
+      "ref": "feature-branch",
+      "sha": "abc123"
+    },
+    "base": {
+      "ref": "main",
+      "sha": "def456"
+    }
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "owner/test-repo",
+    "owner": {
+      "login": "owner"
+    }
+  },
+  "sender": {
+    "login": "user"
+  }
+}

package/dist/pr-synchronize.json

@@ -0,0 +1,27 @@
+{
+  "action": "synchronize",
+  "number": 1,
+  "pull_request": {
+    "number": 1,
+    "title": "Test PR",
+    "state": "open",
+    "head": {
+      "ref": "feature-branch",
+      "sha": "abc123"
+    },
+    "base": {
+      "ref": "main",
+      "sha": "def456"
+    }
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "owner/test-repo",
+    "owner": {
+      "login": "owner"
+    }
+  },
+  "sender": {
+    "login": "user"
+  }
+}

package/dist/push.json

@@ -0,0 +1,16 @@
+{
+  "ref": "refs/heads/main",
+  "before": "000000",
+  "after": "abc123",
+  "repository": {
+    "name": "test-repo",
+    "full_name": "owner/test-repo",
+    "owner": {
+      "login": "owner"
+    }
+  },
+  "pusher": {
+    "name": "user"
+  },
+  "commits": []
+}

package/dist/release-published.json

@@ -0,0 +1,23 @@
+{
+  "action": "published",
+  "release": {
+    "id": 1,
+    "tag_name": "v1.0.0",
+    "target_commitish": "main",
+    "name": "v1.0.0",
+    "draft": false,
+    "prerelease": false,
+    "body": "Release notes"
+  },
+  "repository": {
+    "name": "test-repo",
+    "full_name": "test-org/test-repo",
+    "owner": {
+      "login": "test-org"
+    },
+    "default_branch": "main"
+  },
+  "sender": {
+    "login": "test-user"
+  }
+}