@decaf-ts/utils 0.12.1 → 0.12.2

package/lib/esm/bin/release-chain.js

@@ -0,0 +1,16 @@
+/* istanbul ignore file */
+import { ReleaseChainCommand } from "./../cli/commands/index.js";
+new ReleaseChainCommand()
+    .execute()
+    .then(() => ReleaseChainCommand.log.info("Release chain executed successfully."))
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : `${error}`;
+    try {
+        ReleaseChainCommand.log.error(message);
+    }
+    catch {
+        console.error(message);
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=release-chain.js.map

package/lib/esm/bin/release-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-chain.js","sourceRoot":"","sources":["../../../src/bin/release-chain.ts"],"names":[],"mappings":"AAAA,0BAA0B;AAC1B,OAAO,EAAE,mBAAmB,EAAE,mCAAwB;AAEtD,IAAI,mBAAmB,EAAE;KACtB,OAAO,EAAE;KACT,IAAI,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;KAChF,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;IACxB,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC;IACpE,IAAI,CAAC;QACH,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/lib/esm/cli/commands/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./build-scripts";
 export * from "./tag-release";
+export * from "./release-chain";

package/lib/esm/cli/commands/index.js

@@ -1,3 +1,4 @@
 export * from "./build-scripts.js";
 export * from "./tag-release.js";
+export * from "./release-chain.js";
 //# sourceMappingURL=index.js.map

package/lib/esm/cli/commands/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA,mCAAgC;AAChC,iCAA8B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA,mCAAgC;AAChC,iCAA8B;AAC9B,mCAAgC"}

package/lib/esm/cli/commands/release-chain.d.ts

@@ -0,0 +1,62 @@
+import { Command } from "../command";
+import { CommandOptions } from "../types";
+import { DefaultCommandValues } from "../constants";
+import { LoggingConfig } from "@decaf-ts/logging";
+declare const releaseChainArgs: {
+    meta: {
+        type: string;
+        default: string;
+    };
+    branch: {
+        type: string;
+        default: string;
+    };
+    current: {
+        type: string;
+        default: string;
+    };
+    package: {
+        type: string;
+        default: string;
+    };
+    token: {
+        type: string;
+        default: string;
+    };
+    submoduleFile: {
+        type: string;
+        default: string;
+    };
+    submodulePath: {
+        type: string;
+        default: string;
+    };
+    workflow: {
+        type: string;
+        default: string;
+    };
+    repo: {
+        type: string;
+        default: string;
+    };
+    ref: {
+        type: string;
+        default: string;
+    };
+    targetBase: {
+        type: string;
+        default: string;
+    };
+};
+type ReleaseChainAnswerMap = {
+    [K in keyof typeof releaseChainArgs]: unknown;
+};
+export declare class ReleaseChainCommand extends Command<CommandOptions<typeof releaseChainArgs>, void> {
+    constructor();
+    protected run(options: LoggingConfig & typeof DefaultCommandValues & ReleaseChainAnswerMap): Promise<void>;
+}
+export declare class ReleaseChainDispatchCommand extends Command<CommandOptions<typeof releaseChainArgs>, void> {
+    constructor();
+    protected run(options: LoggingConfig & typeof DefaultCommandValues & ReleaseChainAnswerMap): Promise<void>;
+}
+export {};

package/lib/esm/cli/commands/release-chain.js

@@ -0,0 +1,125 @@
+import { Command } from "./../command.js";
+import { DefaultCommandOptions } from "./../constants.js";
+import { dispatchReleaseChainWorkflow, runReleaseChain, } from "./../../release-chain/index.js";
+import { getPackage } from "./../../utils/index.js";
+import { execSync } from "node:child_process";
+const releaseChainArgs = {
+    meta: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_META_REPO_URL || "",
+    },
+    branch: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_BRANCH ||
+            process.env.GITHUB_REF_NAME ||
+            "main",
+    },
+    current: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_CURRENT || process.env.GITHUB_REPOSITORY || "",
+    },
+    package: {
+        type: "string",
+        default: "",
+    },
+    token: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_TOKEN || "",
+    },
+    submoduleFile: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_FILE || "",
+    },
+    submodulePath: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_FILE_PATH || "",
+    },
+    workflow: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_WORKFLOW || "release-chain.yaml",
+    },
+    repo: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_REPO || "",
+    },
+    ref: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_REF || "",
+    },
+    targetBase: {
+        type: "string",
+        default: process.env.RELEASE_CHAIN_TARGET || "",
+    },
+};
+export class ReleaseChainCommand extends Command {
+    constructor() {
+        super("ReleaseChain", Object.assign({}, DefaultCommandOptions, releaseChainArgs));
+    }
+    async run(options) {
+        const answerMap = options;
+        const packageName = answerMap.package ||
+            getPackage(process.cwd())?.name;
+        if (!packageName) {
+            throw new Error("Unable to determine package name");
+        }
+        const metaRepo = answerMap.meta || detectRemoteUrl();
+        if (!metaRepo) {
+            throw new Error("A meta repository URL is required");
+        }
+        const branch = answerMap.branch || detectBranch();
+        await runReleaseChain({
+            metaRepoUrl: metaRepo,
+            branch,
+            currentRepo: answerMap.current,
+            packageName,
+            token: answerMap.token,
+            submoduleFile: answerMap.submoduleFile || undefined,
+            submodulePath: answerMap.submodulePath || undefined,
+            targetBaseBranch: answerMap.targetBase || undefined,
+        });
+    }
+}
+export class ReleaseChainDispatchCommand extends Command {
+    constructor() {
+        super("ReleaseChainDispatch", Object.assign({}, DefaultCommandOptions, releaseChainArgs));
+    }
+    async run(options) {
+        const answerMap = options;
+        const metaRepo = answerMap.meta || detectRemoteUrl();
+        if (!metaRepo) {
+            throw new Error("A meta repository URL is required");
+        }
+        const branch = answerMap.branch || detectBranch();
+        await dispatchReleaseChainWorkflow({
+            metaRepoUrl: metaRepo,
+            branch,
+            workflowFile: answerMap.workflow || "release-chain.yaml",
+            repoSlug: answerMap.repo,
+            currentRepo: answerMap.current,
+            token: answerMap.token,
+            ref: answerMap.ref || branch,
+            targetBaseBranch: answerMap.targetBase || undefined,
+        });
+    }
+}
+function detectRemoteUrl() {
+    try {
+        return execSync("git config --get remote.origin.url", {
+            encoding: "utf8",
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectBranch() {
+    try {
+        return execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf8",
+        }).trim();
+    }
+    catch {
+        return "main";
+    }
+}
+//# sourceMappingURL=release-chain.js.map

package/lib/esm/cli/commands/release-chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-chain.js","sourceRoot":"","sources":["../../../../src/cli/commands/release-chain.ts"],"names":[],"mappings":"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"}

package/lib/esm/index.d.ts

@@ -3,6 +3,7 @@ export * from "./input";
 export * from "./output";
 export * from "./utils";
 export * from "./writers";
+export * from "./release-chain";
 /**
  * @module utils
  * @description Utilities and building blocks for Decaf-TS CLI and scripting.
@@ -26,7 +27,7 @@ export * from "./writers";
  * @const VERSION
  * @memberOf module:utils
  */
-export declare const VERSION = "0.12.0";
+export declare const VERSION = "0.12.1";
 /**
  * @description Represents the current version of the module.
  * @summary Stores the version for the @decaf-ts/utils package. The build replaces

package/lib/esm/index.js

@@ -3,6 +3,7 @@ export * from "./input/index.js";
 export * from "./output/index.js";
 export * from "./utils/index.js";
 export * from "./writers/index.js";
+export * from "./release-chain/index.js";
 /**
  * @module utils
  * @description Utilities and building blocks for Decaf-TS CLI and scripting.
@@ -26,7 +27,7 @@ export * from "./writers/index.js";
  * @const VERSION
  * @memberOf module:utils
  */
-export const VERSION = "0.12.0";
+export const VERSION = "0.12.1";
 /**
  * @description Represents the current version of the module.
  * @summary Stores the version for the @decaf-ts/utils package. The build replaces

package/lib/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+BAAsB;AACtB,iCAAwB;AACxB,kCAAyB;AACzB,iCAAwB;AACxB,mCAA0B;AAE1B;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,+BAAsB;AACtB,iCAAwB;AACxB,kCAAyB;AACzB,iCAAwB;AACxB,mCAA0B;AAC1B,yCAAgC;AAEhC;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC"}

package/lib/esm/release-chain/index.d.ts

@@ -0,0 +1,43 @@
+export interface ReleaseChainOptions {
+    metaRepoUrl: string;
+    branch: string;
+    currentRepo?: string;
+    packageName: string;
+    workspace?: string;
+    token?: string;
+    submoduleFile?: string;
+    submodulePath?: string;
+    targetBaseBranch?: string;
+}
+export interface ReleaseChainDispatchOptions {
+    metaRepoUrl: string;
+    branch: string;
+    workflowFile?: string;
+    repoSlug?: string;
+    currentRepo?: string;
+    token?: string;
+    ref?: string;
+    targetBaseBranch?: string;
+}
+export declare class ReleaseChainRunner {
+    private readonly options;
+    private readonly workspace;
+    private readonly clonesRoot;
+    private readonly token?;
+    private readonly metaRepoSlug;
+    private readonly currentRepo?;
+    constructor(options: ReleaseChainOptions);
+    run(): Promise<void>;
+    private evaluateModule;
+    private cloneRepository;
+    private checkoutTargetBranch;
+    private loadSubmodules;
+    private runCommand;
+    private githubRequest;
+    private findExistingPr;
+    private acceptPullRequest;
+    private createPullRequest;
+    private getDefaultBranch;
+}
+export declare function runReleaseChain(options: ReleaseChainOptions): Promise<void>;
+export declare function dispatchReleaseChainWorkflow(options: ReleaseChainDispatchOptions): Promise<void>;

package/lib/esm/release-chain/index.js

@@ -0,0 +1,353 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "node:child_process";
+import { Logging } from "@decaf-ts/logging";
+const releaseLog = Logging.for("ReleaseChainRunner");
+export class ReleaseChainRunner {
+    constructor(options) {
+        this.options = options;
+        this.workspace = options.workspace ?? process.cwd();
+        this.clonesRoot = path.join(this.workspace, ".release-chain");
+        this.token =
+            options.token ||
+                process.env.RELEASE_CHAIN_TOKEN ||
+                process.env.GITHUB_TOKEN ||
+                process.env.GH_TOKEN;
+        this.metaRepoSlug =
+            normalizeRepoSlug(options.metaRepoUrl) ||
+                throwOnMissing("Unable to normalize META repo URL");
+        this.currentRepo =
+            normalizeRepoSlug(options.currentRepo) || detectCurrentRepoSlug();
+    }
+    async run() {
+        const modules = await this.loadSubmodules();
+        if (!modules.length) {
+            releaseLog.warn("No modules detected in provided .gitmodules file");
+            return;
+        }
+        const startIndex = this.currentRepo
+            ? modules.findIndex((module) => module.slug === this.currentRepo)
+            : -1;
+        const queue = startIndex >= 0 ? modules.slice(startIndex + 1) : modules;
+        releaseLog.info(`Evaluating ${queue.length} repositories for ${this.options.packageName}`);
+        for (const module of queue) {
+            await this.evaluateModule(module);
+        }
+    }
+    async evaluateModule(module) {
+        if (!module.slug) {
+            releaseLog.verbose(`Skipping ${module.name}: unsupported repository URL`);
+            return;
+        }
+        releaseLog.info(`\n[release-chain] ${module.slug}`);
+        const repoDir = path.join(this.clonesRoot, module.slug.replace(/\//g, "__"));
+        fs.rmSync(repoDir, { recursive: true, force: true });
+        fs.mkdirSync(repoDir, { recursive: true });
+        this.cloneRepository(module.url, repoDir);
+        await this.checkoutTargetBranch(repoDir);
+        const pkgPath = path.join(repoDir, "package.json");
+        if (!fs.existsSync(pkgPath)) {
+            releaseLog.debug(`No package.json detected for ${module.slug}`);
+            return;
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (!dependsOnPackage(pkg, this.options.packageName)) {
+            releaseLog.debug(`${module.slug} does not depend on ${this.options.packageName}`);
+            return;
+        }
+        ensureGitIdentity(repoDir);
+        this.runCommand("npm install --ignore-scripts", repoDir);
+        this.runCommand(`npm update ${this.options.packageName}`, repoDir);
+        this.runCommand("npm run build --if-present", repoDir);
+        this.runCommand("npm run test --if-present", repoDir);
+        if (!hasChanges(repoDir)) {
+            releaseLog.info(`No changes detected for ${module.slug}`);
+            return;
+        }
+        this.runCommand("git add -A", repoDir);
+        this.runCommand(`git commit -m "chore: release chain update for ${this.options.packageName}"`, repoDir);
+        this.runCommand(`git push origin ${this.options.branch} --force-with-lease`, repoDir);
+        const existingPr = await this.findExistingPr(module.slug);
+        if (existingPr) {
+            releaseLog.info(`Existing PR #${existingPr.number} detected for ${module.slug}, attempting merge`);
+            await this.acceptPullRequest(module.slug, existingPr.number, existingPr.head.sha);
+            return;
+        }
+        const baseBranch = this.options.targetBaseBranch ||
+            (await this.getDefaultBranch(module.slug));
+        await this.createPullRequest(module.slug, baseBranch);
+    }
+    cloneRepository(url, target) {
+        const authUrl = injectAuth(url, this.token);
+        this.runCommand(`git clone --no-tags --depth 1 ${authUrl} ${target}`);
+    }
+    async checkoutTargetBranch(cwd) {
+        try {
+            this.runCommand(`git fetch origin ${this.options.branch}:${this.options.branch}`, cwd);
+            this.runCommand(`git checkout ${this.options.branch}`, cwd);
+            this.runCommand(`git reset --hard origin/${this.options.branch}`, cwd);
+            return;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            releaseLog.verbose(`Branch ${this.options.branch} not found remotely; creating from default`);
+        }
+        const defaultBranch = detectDefaultBranch(cwd);
+        this.runCommand(`git checkout -b ${this.options.branch} origin/${defaultBranch}`, cwd);
+    }
+    async loadSubmodules() {
+        if (this.options.submodulePath &&
+            fs.existsSync(this.options.submodulePath)) {
+            const localContent = fs.readFileSync(this.options.submodulePath, "utf8");
+            return parseSubmodules(localContent);
+        }
+        const candidates = [
+            this.options.submoduleFile,
+            ".gitsubmodule",
+            ".gitmodules",
+        ].filter(Boolean);
+        for (const file of candidates) {
+            try {
+                const content = await fetchRawFile(this.metaRepoSlug, this.options.branch, file, this.token);
+                if (content) {
+                    return parseSubmodules(content);
+                }
+            }
+            catch (error) {
+                if (file === candidates[candidates.length - 1]) {
+                    throw error;
+                }
+            }
+        }
+        return [];
+    }
+    runCommand(command, cwd = this.workspace) {
+        releaseLog.debug(`[${cwd}] ${command}`);
+        execSync(command, {
+            cwd,
+            stdio: "inherit",
+            env: Object.assign({}, process.env, {
+                RELEASE_CHAIN_TOKEN: this.token,
+            }),
+        });
+    }
+    async githubRequest(path, init) {
+        const headers = {
+            "User-Agent": "decaf-release-chain",
+            Accept: "application/vnd.github+json",
+        };
+        if (this.token) {
+            headers.Authorization = `Bearer ${this.token}`;
+        }
+        const response = await fetch(`https://api.github.com${path}`, {
+            method: init?.method || "GET",
+            headers: Object.assign({}, headers, init?.headers),
+            body: init?.body,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`GitHub API ${response.status}: ${text}`);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return (await response.json());
+    }
+    async findExistingPr(slug) {
+        const [owner] = slug.split("/");
+        const list = await this.githubRequest(`/repos/${slug}/pulls?head=${owner}%3A${encodeURIComponent(this.options.branch)}&state=open&per_page=1`);
+        return list?.[0];
+    }
+    async acceptPullRequest(slug, number, sha) {
+        await this.githubRequest(`/repos/${slug}/pulls/${number}/merge`, {
+            method: "PUT",
+            body: JSON.stringify({
+                merge_method: "squash",
+                commit_title: `chore: accept release chain for ${this.options.packageName}`,
+                sha,
+            }),
+        });
+    }
+    async createPullRequest(slug, base) {
+        await this.githubRequest(`/repos/${slug}/pulls`, {
+            method: "POST",
+            body: JSON.stringify({
+                title: `${this.options.branch}-release-chain`,
+                head: this.options.branch,
+                base,
+                body: `Automated dependency update for ${this.options.packageName}.`,
+            }),
+        });
+    }
+    async getDefaultBranch(slug) {
+        const repo = await this.githubRequest(`/repos/${slug}`);
+        return repo?.default_branch || "main";
+    }
+}
+export async function runReleaseChain(options) {
+    const runner = new ReleaseChainRunner(options);
+    await runner.run();
+}
+export async function dispatchReleaseChainWorkflow(options) {
+    const token = options.token ||
+        process.env.RELEASE_CHAIN_TRIGGER_TOKEN ||
+        process.env.RELEASE_CHAIN_TOKEN ||
+        process.env.GITHUB_TOKEN ||
+        process.env.GH_TOKEN;
+    const repoSlug = options.repoSlug ||
+        detectCurrentRepoSlug() ||
+        throwOnMissing("Unable to determine repository slug for dispatch");
+    const workflow = options.workflowFile || "release-chain.yaml";
+    const ref = options.ref || options.branch;
+    const currentRepo = normalizeRepoSlug(options.currentRepo) || repoSlug;
+    releaseLog.info(`Dispatching ${workflow} on ${repoSlug} for ${options.branch} (current repo ${currentRepo})`);
+    const headers = {
+        "User-Agent": "decaf-release-chain-dispatch",
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json",
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const response = await fetch(`https://api.github.com/repos/${repoSlug}/actions/workflows/${workflow}/dispatches`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            ref,
+            inputs: {
+                meta_repo_url: options.metaRepoUrl,
+                branch: options.branch,
+                current_repo: currentRepo,
+                target_branch: options.targetBaseBranch || "",
+            },
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Workflow dispatch failed: ${response.status} ${text}`);
+    }
+}
+function parseSubmodules(content) {
+    return content
+        .split("[submodule")
+        .slice(1)
+        .map((block) => {
+        const nameMatch = block.match(/"(.+?)"\]/);
+        const pathMatch = block.match(/path\s*=\s*(.+)/);
+        const urlMatch = block.match(/url\s*=\s*(.+)/);
+        const url = urlMatch?.[1]?.trim() || "";
+        return {
+            name: nameMatch?.[1]?.trim() || "",
+            path: pathMatch?.[1]?.trim() || "",
+            url,
+            slug: normalizeRepoSlug(url),
+        };
+    })
+        .filter((entry) => entry.url);
+}
+function normalizeRepoSlug(value) {
+    if (!value)
+        return undefined;
+    if (value.includes("github.com")) {
+        const normalized = toHttpsUrl(value);
+        const parsed = new URL(normalized);
+        return parsed.pathname.replace(/^\//, "").replace(/\.git$/, "");
+    }
+    return value.replace(/^\//, "");
+}
+function toHttpsUrl(url) {
+    if (url.startsWith("git@github.com:")) {
+        return `https://github.com/${url.replace("git@github.com:", "")}`;
+    }
+    if (url.startsWith("ssh://git@github.com/")) {
+        return `https://github.com/${url.replace("ssh://git@github.com/", "")}`;
+    }
+    return url.replace(/\.git$/, "");
+}
+function injectAuth(url, token) {
+    const httpsUrl = toHttpsUrl(url);
+    if (!token) {
+        return httpsUrl;
+    }
+    const parsed = new URL(httpsUrl);
+    parsed.username = "x-access-token";
+    parsed.password = token;
+    return parsed.toString();
+}
+async function fetchRawFile(slug, branch, file, token) {
+    const url = `https://raw.githubusercontent.com/${slug}/${branch}/${file}`;
+    const headers = {
+        "User-Agent": "decaf-release-chain",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const response = await fetch(url, { headers });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to download ${file}: ${response.status} ${text}`);
+    }
+    return response.text();
+}
+function detectCurrentRepoSlug() {
+    if (process.env.GITHUB_REPOSITORY) {
+        return process.env.GITHUB_REPOSITORY;
+    }
+    try {
+        const remote = execSync("git config --get remote.origin.url", {
+            encoding: "utf8",
+        })
+            .trim()
+            .replace(/\s+/g, "");
+        return normalizeRepoSlug(remote);
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectDefaultBranch(cwd) {
+    try {
+        const ref = execSync("git symbolic-ref --short refs/remotes/origin/HEAD", {
+            cwd,
+            encoding: "utf8",
+        }).trim();
+        return ref.split("/").pop() || "main";
+    }
+    catch {
+        return "main";
+    }
+}
+function hasChanges(cwd) {
+    const status = execSync("git status --porcelain", {
+        cwd,
+        encoding: "utf8",
+    }).trim();
+    return Boolean(status);
+}
+function ensureGitIdentity(cwd) {
+    try {
+        execSync("git config user.name", { cwd, stdio: "pipe" });
+        execSync("git config user.email", { cwd, stdio: "pipe" });
+    }
+    catch {
+        execSync("git config user.name 'release-chain'", { cwd });
+        execSync("git config user.email 'release-chain@users.noreply.github.com'", {
+            cwd,
+        });
+    }
+}
+function dependsOnPackage(pkg, packageName) {
+    const sections = [
+        "dependencies",
+        "devDependencies",
+        "peerDependencies",
+        "optionalDependencies",
+    ];
+    return sections.some((section) => Boolean(pkg?.[section]?.[packageName]));
+}
+function throwOnMissing(message) {
+    throw new Error(message);
+}
+//# sourceMappingURL=index.js.map