@pmate/cli 0.12.7 → 0.12.8

package/dist/commands/PrCommandHandler.js

@@ -1,673 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrCommandHandler = void 0;
-const node_child_process_1 = require("node:child_process");
-const cli_1 = require("../cli");
-const config_1 = require("../config");
-class PrCommandHandler {
-    constructor(cwd = process.cwd()) {
-        this.cwd = cwd;
-    }
-    async handle(args) {
-        if (args.action === "merge") {
-            await this.handleMerge(args.prRef);
-            return;
-        }
-        await this.ensureGitRepo();
-        // await this.ensureGitHubRepo()
-        await this.ensureGhCli();
-        await this.ensureGhAuth();
-        const context = await this.getRepoContext();
-        let existingPrUrl = await this.findExistingPrUrl(context.currentBranch);
-        if (!this.hasLocalChanges(context)) {
-            await this.handleNoLocalChanges(context, existingPrUrl);
-            return;
-        }
-        const recentLog = await this.runCapture("git", [
-            "log",
-            "--oneline",
-            "-n",
-            "20",
-        ]);
-        console.log("Generating PR metadata using PMate agents...");
-        const suggestion = await this.getAiSuggestion({
-            status: context.status,
-            diff: truncate(context.diff, 6000),
-            diffCached: truncate(context.diffCached, 6000),
-            recentLog: truncate(recentLog, 2000),
-            baseBranch: context.baseBranch,
-        });
-        this.assertNonEmpty("PR title", suggestion.prTitle);
-        this.assertNonEmpty("Commit message", suggestion.commitMessage);
-        const prTitle = normalizePrTitle(suggestion.prTitle);
-        if (prTitle !== suggestion.prTitle.trim()) {
-            cli_1.ui.info("Normalized PR title", prTitle);
-        }
-        const headBranch = await this.ensureWorkBranch(context, suggestion);
-        if (headBranch !== context.currentBranch) {
-            existingPrUrl = await this.findExistingPrUrl(headBranch);
-        }
-        await this.commitIfNeeded(suggestion.commitMessage);
-        await this.rebaseOntoBase(context.baseBranch);
-        await this.pushBranchIfNeeded(headBranch, context.baseBranch);
-        await this.ensurePr(existingPrUrl, context.baseBranch, headBranch, prTitle);
-    }
-    async handleCommit(push = false) {
-        await this.ensureGitRepo();
-        const context = await this.getRepoContext();
-        if (!this.hasLocalChanges(context)) {
-            throw new Error("No local changes to commit.");
-        }
-        const recentLog = await this.runCapture("git", [
-            "log",
-            "--oneline",
-            "-n",
-            "20",
-        ]);
-        console.log("Generating commit message using PMate agents...");
-        const suggestion = await this.getAiCommitSuggestion({
-            status: context.status,
-            diff: truncate(context.diff, 6000),
-            diffCached: truncate(context.diffCached, 6000),
-            recentLog: truncate(recentLog, 2000),
-            baseBranch: context.baseBranch,
-        });
-        this.assertNonEmpty("Commit title", suggestion.commitTitle);
-        this.assertNonEmpty("Commit log", suggestion.commitLog);
-        await this.commitIfNeeded(suggestion.commitTitle, suggestion.commitLog);
-        cli_1.ui.success("Committed changes", suggestion.commitTitle);
-        cli_1.ui.info("Commit log", suggestion.commitLog);
-        if (push) {
-            await this.pushCurrentBranch();
-        }
-    }
-    async handleMerge(prRef) {
-        await this.ensureGitRepo();
-        await this.ensureGhCli();
-        await this.ensureGhAuth();
-        const targetPr = (prRef === null || prRef === void 0 ? void 0 : prRef.trim()) || (await this.resolveCurrentPrRef());
-        if (!targetPr) {
-            throw new Error("No PR found for current branch. Pass a PR number/url, e.g. `pmate pr merge 123`.");
-        }
-        const pr = await this.getPrMergeCheck(targetPr);
-        if (pr.state !== "OPEN") {
-            throw new Error(`PR #${pr.number} is not open (state: ${pr.state}).`);
-        }
-        if (!this.isSquashMergeable(pr)) {
-            const reason = this.getNonMergeableReason(pr);
-            throw new Error(`PR #${pr.number} cannot be squash-merged: ${reason}`);
-        }
-        cli_1.ui.info(`Merging PR #${pr.number} with squash strategy`);
-        await this.runGh(["pr", "merge", String(pr.number), "--squash", "--delete-branch"]);
-        cli_1.ui.success(`Merged PR #${pr.number}`, pr.url);
-    }
-    async resolveCurrentPrRef() {
-        const branch = (await this.runCapture("git", ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-        if (!branch) {
-            return "";
-        }
-        const output = await this.runCaptureGh([
-            "pr",
-            "list",
-            "--head",
-            branch,
-            "--state",
-            "open",
-            "--json",
-            "number",
-            "--jq",
-            ".[0].number",
-        ]);
-        return output.trim();
-    }
-    async getPrMergeCheck(prRef) {
-        const output = await this.runCaptureGh([
-            "pr",
-            "view",
-            prRef,
-            "--json",
-            "number,url,isDraft,state,mergeStateStatus,reviewDecision,statusCheckRollup",
-        ]);
-        try {
-            return JSON.parse(output);
-        }
-        catch {
-            throw new Error("Failed to parse PR metadata from gh.");
-        }
-    }
-    isSquashMergeable(pr) {
-        if (pr.isDraft) {
-            return false;
-        }
-        const status = (pr.mergeStateStatus || "").toUpperCase();
-        if (status === "CLEAN" || status === "HAS_HOOKS") {
-            return true;
-        }
-        return false;
-    }
-    getNonMergeableReason(pr) {
-        if (pr.isDraft || pr.mergeStateStatus === "DRAFT") {
-            return "PR is in draft state.";
-        }
-        const state = (pr.mergeStateStatus || "").toUpperCase();
-        switch (state) {
-            case "BEHIND":
-                return "branch is behind base branch.";
-            case "DIRTY":
-                return "merge conflicts must be resolved.";
-            case "BLOCKED":
-                return this.formatBlockedReason(pr);
-            case "UNSTABLE":
-                return this.formatUnstableReason(pr);
-            case "UNKNOWN":
-                return "GitHub mergeability is still being computed. Retry shortly.";
-            default:
-                return `merge state is ${pr.mergeStateStatus || "unknown"}.`;
-        }
-    }
-    formatBlockedReason(pr) {
-        const parts = ["blocked by repository rules"];
-        if (pr.reviewDecision === "CHANGES_REQUESTED") {
-            parts.push("changes were requested in review");
-        }
-        else if (pr.reviewDecision === "REVIEW_REQUIRED") {
-            parts.push("review is still required");
-        }
-        const checkSummary = this.summarizeChecks(pr.statusCheckRollup);
-        if (checkSummary) {
-            parts.push(checkSummary);
-        }
-        return `${parts.join("; ")}.`;
-    }
-    formatUnstableReason(pr) {
-        const checkSummary = this.summarizeChecks(pr.statusCheckRollup);
-        if (checkSummary) {
-            return `required checks are not green; ${checkSummary}.`;
-        }
-        return "required checks are still pending or failing.";
-    }
-    summarizeChecks(checks) {
-        const items = checks !== null && checks !== void 0 ? checks : [];
-        const failing = [];
-        const pending = [];
-        for (const check of items) {
-            const name = check.name || check.context || "unknown-check";
-            const rawState = (check.conclusion || check.status || check.state || "")
-                .toString()
-                .toUpperCase();
-            if (!rawState || rawState === "PENDING" || rawState === "IN_PROGRESS" || rawState === "QUEUED") {
-                pending.push(name);
-                continue;
-            }
-            if (rawState === "FAILURE" ||
-                rawState === "FAILED" ||
-                rawState === "ERROR" ||
-                rawState === "TIMED_OUT" ||
-                rawState === "CANCELLED" ||
-                rawState === "ACTION_REQUIRED") {
-                failing.push(name);
-            }
-        }
-        const parts = [];
-        if (failing.length > 0) {
-            parts.push(`failing checks: ${failing.join(", ")}`);
-        }
-        if (pending.length > 0) {
-            parts.push(`pending checks: ${pending.join(", ")}`);
-        }
-        return parts.join("; ");
-    }
-    async getRepoContext() {
-        const status = await this.runCapture("git", ["status", "--porcelain"]);
-        const diff = await this.runCapture("git", ["diff"]);
-        const diffCached = await this.runCapture("git", ["diff", "--cached"]);
-        const baseBranch = await this.detectBaseBranch();
-        const currentBranch = (await this.runCapture("git", ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-        return { status, diff, diffCached, baseBranch, currentBranch };
-    }
-    hasLocalChanges(context) {
-        return (Boolean(context.status.trim()) ||
-            Boolean(context.diff.trim()) ||
-            Boolean(context.diffCached.trim()));
-    }
-    async handleNoLocalChanges(context, existingPrUrl) {
-        if (existingPrUrl) {
-            await this.pushBranchIfNeeded(context.currentBranch, context.baseBranch);
-            cli_1.ui.info(`PR already exists: ${existingPrUrl}`);
-            return;
-        }
-        if (context.currentBranch === context.baseBranch) {
-            throw new Error("No commits to include in a PR.");
-        }
-        const aheadLog = await this.getAheadLog(context.baseBranch);
-        if (!aheadLog.trim()) {
-            throw new Error("No commits to include in a PR.");
-        }
-        const prTitle = normalizePrTitle(this.getPrTitleFromLog(aheadLog));
-        const prBody = await this.buildPrBody(context.baseBranch);
-        await this.pushBranchIfNeeded(context.currentBranch, context.baseBranch);
-        await this.createPr(context.baseBranch, context.currentBranch, prTitle, prBody);
-    }
-    async ensureWorkBranch(context, suggestion) {
-        if (context.currentBranch !== context.baseBranch) {
-            return context.currentBranch;
-        }
-        const branchName = sanitizeBranchName(suggestion.branchName);
-        this.assertValidBranchName(branchName);
-        await this.ensureBranchAvailable(branchName);
-        cli_1.ui.info(`Creating branch ${branchName}`);
-        await this.run("git", ["checkout", "-b", branchName]);
-        return branchName;
-    }
-    async ensurePr(existingPrUrl, baseBranch, headBranch, prTitle) {
-        if (existingPrUrl) {
-            cli_1.ui.info(`PR already exists: ${existingPrUrl}`);
-            return;
-        }
-        const prBody = await this.buildPrBody(baseBranch);
-        await this.createPr(baseBranch, headBranch, prTitle, prBody);
-    }
-    async createPr(baseBranch, headBranch, prTitle, prBody) {
-        cli_1.ui.info("Creating GitHub PR");
-        await this.runGh([
-            "pr",
-            "create",
-            "--base",
-            baseBranch,
-            "--head",
-            headBranch,
-            "--title",
-            prTitle,
-            "--body",
-            prBody,
-        ]);
-    }
-    async getAheadLog(baseBranch) {
-        return this.runCapture("git", [
-            "log",
-            "--oneline",
-            `origin/${baseBranch}..HEAD`,
-        ]);
-    }
-    async rebaseOntoBase(baseBranch) {
-        cli_1.ui.info(`Rebasing onto origin/${baseBranch}`);
-        await this.run("git", ["fetch", "origin", baseBranch]);
-        await this.run("git", ["rebase", `origin/${baseBranch}`]);
-    }
-    async ensureGitRepo() {
-        const inside = await this.runCapture("git", [
-            "rev-parse",
-            "--is-inside-work-tree",
-        ]);
-        if (inside.trim() !== "true") {
-            throw new Error("This command must be run inside a git repository.");
-        }
-    }
-    async ensureGhAuth() {
-        // Auth check (works for GH_TOKEN too)
-        const code = await this.runGh(["auth", "status"], true);
-        if (code !== 0) {
-            throw new Error("GitHub CLI is not authenticated. Run: gh auth login.");
-        }
-    }
-    async ensureGhCli() {
-        await this.runGh(["--version"]);
-    }
-    async detectBaseBranch() {
-        const originHead = await this.runCapture("git", ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], true);
-        const originHeadBranch = originHead
-            ? originHead.trim().split("/").pop()
-            : "";
-        if (originHeadBranch) {
-            return originHeadBranch;
-        }
-        const candidates = ["main", "master", "develop"];
-        for (const candidate of candidates) {
-            const hasBranch = await this.run("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${candidate}`], true);
-            if (hasBranch === 0) {
-                return candidate;
-            }
-        }
-        return "main";
-    }
-    async getAiSuggestion(context) {
-        const { AgentLlmClient } = await Promise.resolve().then(() => __importStar(require("../llm/AgentLlmClient")));
-        const client = new AgentLlmClient();
-        const parsed = await client.prompt("pr-metadata", {
-            baseBranch: context.baseBranch,
-            status: context.status,
-            diff: context.diff,
-            diffCached: context.diffCached,
-            recentLog: context.recentLog,
-        });
-        if (!parsed) {
-            throw new Error("Agent response missing content.");
-        }
-        const suggestion = {
-            prTitle: normalizeAgentStringField(parsed.prTitle),
-            branchName: normalizeAgentStringField(parsed.branchName),
-            commitMessage: normalizeAgentStringField(parsed.commitMessage),
-        };
-        if (!suggestion.prTitle || !suggestion.branchName || !suggestion.commitMessage) {
-            throw new Error("Agent response missing required fields.");
-        }
-        return suggestion;
-    }
-    async getAiCommitSuggestion(context) {
-        const { AgentLlmClient } = await Promise.resolve().then(() => __importStar(require("../llm/AgentLlmClient")));
-        const client = new AgentLlmClient();
-        const parsed = await client.prompt("commit-metadata", {
-            baseBranch: context.baseBranch,
-            status: context.status,
-            diff: context.diff,
-            diffCached: context.diffCached,
-            recentLog: context.recentLog,
-        });
-        if (!parsed) {
-            throw new Error("Agent response missing content.");
-        }
-        const suggestion = {
-            commitTitle: normalizeAgentStringField(parsed.commitTitle),
-            commitLog: normalizeAgentStringField(parsed.commitLog),
-        };
-        if (!suggestion.commitTitle || !suggestion.commitLog) {
-            throw new Error("Agent response missing required fields.");
-        }
-        return suggestion;
-    }
-    async ensureBranchAvailable(branchName) {
-        const exists = await this.run("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], true);
-        if (exists === 0) {
-            throw new Error(`Branch ${branchName} already exists locally.`);
-        }
-    }
-    async commitIfNeeded(message, body) {
-        const status = await this.runCapture("git", ["status", "--porcelain"]);
-        if (!status.trim()) {
-            cli_1.ui.info("No new changes to commit.");
-            return;
-        }
-        cli_1.ui.info("Committing changes");
-        await this.run("git", ["add", "-A"]);
-        const bodyText = body === null || body === void 0 ? void 0 : body.trim();
-        const commitArgs = ["commit", "-m", message];
-        if (bodyText) {
-            commitArgs.push("-m", bodyText);
-        }
-        await this.run("git", commitArgs);
-    }
-    async buildPrBody(baseBranch) {
-        const log = await this.runCapture("git", [
-            "log",
-            "--oneline",
-            `origin/${baseBranch}..HEAD`,
-        ]);
-        if (!log.trim()) {
-            return "";
-        }
-        const lines = log
-            .trim()
-            .split(/\r?\n/)
-            .map((line) => `- ${line}`)
-            .join("\n");
-        return `Changes:\n${lines}`;
-    }
-    async pushBranchIfNeeded(branchName, baseBranch) {
-        if (branchName === baseBranch) {
-            return;
-        }
-        cli_1.ui.info(`Pushing branch ${branchName}`);
-        await this.run("git", ["push", "-u", "origin", branchName]);
-    }
-    async pushCurrentBranch() {
-        const branchName = (await this.runCapture("git", ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-        if (!branchName || branchName === "HEAD") {
-            throw new Error("Cannot push from detached HEAD.");
-        }
-        cli_1.ui.info(`Pushing branch ${branchName}`);
-        await this.run("git", ["push", "-u", "origin", branchName]);
-    }
-    async findExistingPrUrl(branchName) {
-        var _a, _b;
-        const output = await this.runCaptureGh([
-            "pr",
-            "list",
-            "--head",
-            branchName,
-            "--state",
-            "open",
-            "--json",
-            "url",
-        ]);
-        console.log(`Existing PR list output: ${output}`);
-        if (!output.trim()) {
-            return "";
-        }
-        try {
-            const data = JSON.parse(output);
-            return (_b = (_a = data[0]) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : "";
-        }
-        catch {
-            return "";
-        }
-    }
-    getPrTitleFromLog(log) {
-        var _a;
-        const firstLine = (_a = log.trim().split(/\r?\n/)[0]) !== null && _a !== void 0 ? _a : "";
-        const subject = firstLine.replace(/^[0-9a-f]+\s+/, "").trim();
-        return subject || "Auto-generated PR";
-    }
-    assertValidBranchName(branchName) {
-        if (!/^[a-z0-9._/-]+$/.test(branchName) || branchName.endsWith("/")) {
-            throw new Error(`Invalid branch name: ${branchName}`);
-        }
-    }
-    assertNonEmpty(label, value) {
-        if (!value.trim()) {
-            throw new Error(`${label} cannot be empty.`);
-        }
-    }
-    run(command, args, quietError = false, env, cwd) {
-        return new Promise((resolve, reject) => {
-            const child = (0, node_child_process_1.spawn)(command, args, {
-                stdio: quietError ? "ignore" : "inherit",
-                env: env !== null && env !== void 0 ? env : process.env,
-                cwd: cwd !== null && cwd !== void 0 ? cwd : this.cwd,
-            });
-            child.on("error", (error) => {
-                reject(error);
-            });
-            child.on("close", (code) => {
-                if (code === 0 || quietError) {
-                    resolve(code !== null && code !== void 0 ? code : 1);
-                    return;
-                }
-                reject(new Error(`${command} exited with code ${code}`));
-            });
-        });
-    }
-    runCapture(command, args, allowFailure = false, env, cwd) {
-        return new Promise((resolve, reject) => {
-            var _a, _b;
-            const child = (0, node_child_process_1.spawn)(command, args, {
-                stdio: ["ignore", "pipe", "pipe"],
-                env: env !== null && env !== void 0 ? env : process.env,
-                cwd: cwd !== null && cwd !== void 0 ? cwd : this.cwd,
-            });
-            let output = "";
-            let errorOutput = "";
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
-                output += chunk.toString();
-            });
-            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", (chunk) => {
-                errorOutput += chunk.toString();
-            });
-            child.on("error", (error) => {
-                reject(error);
-            });
-            child.on("close", (code) => {
-                if (code === 0 || allowFailure) {
-                    resolve(output);
-                    return;
-                }
-                const trimmed = errorOutput.trim();
-                reject(new Error(trimmed
-                    ? `${command} failed: ${trimmed}`
-                    : `${command} exited with code ${code}`));
-            });
-        });
-    }
-    getResponseText(response) {
-        var _a, _b;
-        const data = response;
-        const output = (_a = data.output) !== null && _a !== void 0 ? _a : [];
-        for (const item of output) {
-            const content = (_b = item.content) !== null && _b !== void 0 ? _b : [];
-            for (const part of content) {
-                if (part.type === "output_text" && typeof part.text === "string") {
-                    return part.text.trim();
-                }
-            }
-        }
-        return "";
-    }
-    async getGhEnv(cwd) {
-        var _a;
-        const env = { ...process.env };
-        delete env.GH_TOKEN;
-        const repoConfig = (0, config_1.loadRepoConfig)(cwd !== null && cwd !== void 0 ? cwd : this.cwd);
-        const githubUser = (_a = repoConfig === null || repoConfig === void 0 ? void 0 : repoConfig.githubUser) === null || _a === void 0 ? void 0 : _a.trim();
-        if (!githubUser) {
-            return env;
-        }
-        const token = (await this.runCapture("gh", ["auth", "token", "--user", githubUser], false, env, cwd)).trim();
-        if (!token) {
-            throw new Error(`Failed to resolve GitHub token for ${githubUser}.`);
-        }
-        env.GH_TOKEN = token;
-        return env;
-    }
-    async runGh(args, quietError = false, cwd) {
-        return this.run("gh", args, quietError, await this.getGhEnv(cwd), cwd);
-    }
-    async runCaptureGh(args, allowFailure = false, cwd) {
-        return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
-    }
-}
-exports.PrCommandHandler = PrCommandHandler;
-function truncate(value, limit) {
-    if (value.length <= limit) {
-        return value;
-    }
-    return `${value.slice(0, limit)}\n...[truncated]`;
-}
-function normalizeAgentStringField(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value
-            .filter((item) => typeof item === "string")
-            .join("\n");
-    }
-    if (value &&
-        typeof value === "object" &&
-        "content" in value &&
-        typeof value.content === "string") {
-        return value.content;
-    }
-    return "";
-}
-function parseJson(raw) {
-    const trimmed = raw.trim();
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        const match = trimmed.match(/\{[\s\S]*\}/);
-        if (!match) {
-            throw new Error("Failed to parse JSON from OpenAI response.");
-        }
-        return JSON.parse(match[0]);
-    }
-}
-function sanitizeBranchName(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9._/-]+/g, "-")
-        .replace(/--+/g, "-")
-        .replace(/^-+|-+$/g, "");
-}
-function normalizePrTitle(raw) {
-    var _a;
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        return trimmed;
-    }
-    const typed = trimmed.match(/^(feat|fix|chore)(?:\([^)]+\))?:\s*(.*)$/i);
-    if (typed) {
-        const type = typed[1].toLowerCase();
-        const rest = ((_a = typed[2]) !== null && _a !== void 0 ? _a : "").trim();
-        if (!rest) {
-            throw new Error("PR title cannot be empty after the type prefix.");
-        }
-        return `${type}: ${rest}`;
-    }
-    const rest = stripConventionalPrefix(trimmed);
-    const type = inferPrTitleType(rest);
-    return `${type}: ${rest}`;
-}
-function stripConventionalPrefix(value) {
-    var _a;
-    const match = value.match(/^([a-z][a-z0-9-]{1,15})(?:\([^)]+\))?:\s+(.*)$/i);
-    if (!match) {
-        return value.trim();
-    }
-    const rest = ((_a = match[2]) !== null && _a !== void 0 ? _a : "").trim();
-    return rest || value.trim();
-}
-function inferPrTitleType(title) {
-    const t = title.toLowerCase();
-    if (/\b(fix|bug|error|crash|regress|regression|hotfix)\b/.test(t)) {
-        return "fix";
-    }
-    if (/\b(chore|refactor|deps|dependency|dependencies|bump|upgrade|update|ci|build|tooling|lint|format)\b/.test(t)) {
-        return "chore";
-    }
-    return "feat";
-}
-//# sourceMappingURL=PrCommandHandler.js.map