issue-flow 0.12.0 → 0.14.0

package/dist/{chunk-EZATO3DW.js → chunk-RVO7L4FX.js}

@@ -2,14 +2,353 @@
 import {
   loadPolicyConfig,
   mergeConfigLayers
-} from "./chunk-42PJFMAR.js";
+} from "./chunk-QJ5UZAH5.js";
+import {
+  printWarning
+} from "./chunk-TYRNTSPJ.js";
 import {
   getProjectRoot,
   run
-} from "./chunk-DIDUVL6O.js";
-import {
-  printWarning
-} from "./chunk-BYZDPR7N.js";
+} from "./chunk-BEZ5BA5U.js";
+
+// src/conventions/git/types.ts
+var CHANGE_TYPES = [
+  "feat",
+  "fix",
+  "docs",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "style",
+  "revert"
+];
+var DEFAULT_BRANCH_CONVENTION = "{type}/{N}-{slug}";
+var SLUG_MAX_LENGTH = 40;
+var BRANCH_MAX_LENGTH = 60;
+var DEFAULT_LABEL_TYPE_MAP = {
+  bug: "fix",
+  documentation: "docs",
+  docs: "docs",
+  refactor: "refactor",
+  "tech-debt": "refactor",
+  infra: "ci",
+  "ci-cd": "ci",
+  enhancement: "feat",
+  architecture: "feat",
+  investigation: "chore"
+};
+var FORBIDDEN_PROVIDER_NAMES = ["claude", "codex", "cursor", "antigravity"];
+function isChangeType(value) {
+  return CHANGE_TYPES.includes(value);
+}
+function isForbiddenProviderToken(value) {
+  return FORBIDDEN_PROVIDER_NAMES.includes(value.toLowerCase());
+}
+
+// src/conventions/git/slug.ts
+var COMBINING = /[\u0300-\u036f]/g;
+var NON_SLUG = /[^a-z0-9]+/g;
+function slugify(title, maxLength = SLUG_MAX_LENGTH) {
+  const withoutLock = title.replace(/\.lock$/i, "");
+  const normalized = withoutLock.normalize("NFD").replace(COMBINING, "").toLowerCase();
+  let slug = normalized.replace(NON_SLUG, "-").replace(/^-+|-+$/g, "");
+  slug = slug.replace(/\.{2,}/g, ".").replace(/^\.+|\.+$/g, "");
+  slug = slug.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug.length <= maxLength) return slug;
+  const cut = slug.slice(0, maxLength);
+  const lastHyphen = cut.lastIndexOf("-");
+  if (lastHyphen >= Math.floor(maxLength / 2)) {
+    return cut.slice(0, lastHyphen).replace(/-+$/g, "");
+  }
+  return cut.replace(/-+$/g, "");
+}
+
+// src/conventions/git/branch.ts
+var LEGACY_PREFIX = "issue";
+function branchType(type) {
+  return type === "style" || type === "revert" ? "chore" : type;
+}
+function applyConvention(convention, type, issueNumber, slug) {
+  const hasNumber = issueNumber !== void 0 && issueNumber !== null;
+  let result = convention.replaceAll("{type}", type).replaceAll("{N}", hasNumber ? String(issueNumber) : "").replaceAll("{slug}", slug);
+  result = result.replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-");
+  result = result.replace(/\/-/g, "/").replace(/-\//g, "/");
+  result = result.replace(/^\/+|\/+$/g, "").replace(/^-+|-+$/g, "");
+  if (!hasNumber) {
+    result = result.replace(`${type}/-`, `${type}/`).replace(/\/$/g, "");
+  }
+  if (slug === "") {
+    result = result.replace(/\/-$/, "").replace(/-$/, "");
+  }
+  return result.replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, "");
+}
+function truncateBranch(name, max) {
+  if (name.length <= max) return name;
+  const slash = name.indexOf("/");
+  const prefix = slash === -1 ? "" : name.slice(0, slash + 1);
+  const rest = slash === -1 ? name : name.slice(slash + 1);
+  const budget = max - prefix.length;
+  if (budget < 1) return name.slice(0, max);
+  const cut = rest.slice(0, budget);
+  const lastHyphen = cut.lastIndexOf("-");
+  const trimmed = lastHyphen >= Math.floor(budget / 2) ? cut.slice(0, lastHyphen) : cut;
+  return `${prefix}${trimmed.replace(/-+$/g, "")}`;
+}
+function collide(name, existingRefs, currentOid) {
+  if (existingRefs === void 0 || existingRefs.length === 0) return name;
+  const byName = new Map(existingRefs.map((ref) => [ref.name, ref.oid]));
+  const existing = byName.get(name);
+  if (existing === void 0) return name;
+  if (currentOid !== void 0 && existing === currentOid) return name;
+  for (let n = 2; n < 100; n += 1) {
+    const candidate = `${name}-${n}`;
+    const oid = byName.get(candidate);
+    if (oid === void 0 || currentOid !== void 0 && oid === currentOid) {
+      return candidate;
+    }
+  }
+  return `${name}-${Date.now()}`;
+}
+function branchName(input) {
+  const type = branchType(input.type);
+  const convention = input.convention ?? DEFAULT_BRANCH_CONVENTION;
+  const slug = slugify(input.title);
+  const raw = applyConvention(convention, type, input.issueNumber, slug);
+  const truncated = truncateBranch(raw, BRANCH_MAX_LENGTH);
+  return collide(truncated, input.existingRefs, input.currentOid);
+}
+function parseBranch(name) {
+  const raw = name.trim();
+  const match = raw.match(/^([^/]+)\/(?:(\d+)(?:-(.*))?|(.*))$/);
+  if (match === null) {
+    return { type: null, issueNumber: null, slug: raw, raw };
+  }
+  const prefix = match[1] ?? "";
+  const numbered = match[2];
+  const numberedSlug = match[3] ?? "";
+  const unnumberedSlug = match[4] ?? "";
+  const type = prefix === LEGACY_PREFIX ? "issue" : isChangeType(prefix) ? prefix : null;
+  if (numbered !== void 0) {
+    return { type, issueNumber: Number(numbered), slug: numberedSlug, raw };
+  }
+  return { type, issueNumber: null, slug: unnumberedSlug, raw };
+}
+function archiveFolderName(branch) {
+  const parsed = parseBranch(branch);
+  if (parsed.issueNumber !== null && parsed.slug !== "") {
+    return `${parsed.issueNumber}-${parsed.slug}`.replace(/[<>:"|?*\\]/g, "_");
+  }
+  if (parsed.issueNumber !== null) {
+    return String(parsed.issueNumber);
+  }
+  return branch.replace(/^[^/]+\//, "").replace(/[<>:"|?*\\]/g, "_");
+}
+
+// src/conventions/git/change-type.ts
+var ISSUE_TYPE_MAP = {
+  bug: "fix",
+  feature: "feat",
+  task: "chore",
+  epic: "chore",
+  idea: "chore",
+  research: "chore",
+  documentation: "docs"
+};
+var TITLE_PREFIX_MAP = {
+  bug: "fix",
+  fix: "fix",
+  feature: "feat",
+  enhancement: "feat",
+  architecture: "feat",
+  refactor: "refactor",
+  docs: "docs",
+  documentation: "docs",
+  chore: "chore",
+  perf: "perf",
+  test: "test",
+  ci: "ci"
+};
+function normalizeKey(value) {
+  return value.trim().toLowerCase();
+}
+function typeFromIssueType(issueType) {
+  const key = normalizeKey(issueType);
+  if (isChangeType(key)) return key;
+  return ISSUE_TYPE_MAP[key] ?? null;
+}
+function mergedTypeMap(overlay) {
+  const merged = { ...DEFAULT_LABEL_TYPE_MAP };
+  if (overlay === void 0 || overlay === null) return merged;
+  for (const [label, type] of Object.entries(overlay)) {
+    if (isChangeType(type)) {
+      merged[normalizeKey(label)] = type;
+    }
+  }
+  return merged;
+}
+function typeFromLabels(labels, typeMap) {
+  for (const label of labels) {
+    const key = normalizeKey(label);
+    const mapped = typeMap[key] ?? typeMap[key.replace(/^type:/, "")];
+    if (mapped !== void 0) return mapped;
+  }
+  return null;
+}
+function typeFromTitle(title) {
+  const match = title.match(/^\s*\[([^\]]+)\]/);
+  if (match?.[1] === void 0) return null;
+  const key = normalizeKey(match[1]);
+  if (isChangeType(key)) return key;
+  return TITLE_PREFIX_MAP[key] ?? null;
+}
+function resolveChangeType(input) {
+  if (input.declaredType !== void 0 && input.declaredType !== null) {
+    return { type: input.declaredType, source: "declared" };
+  }
+  const labels = input.labels ?? [];
+  const typeMap = mergedTypeMap(input.typeMap);
+  const fromLabels = typeFromLabels(labels, typeMap);
+  const fromIssueType = input.issueType !== void 0 && input.issueType !== null && input.issueType !== "" ? typeFromIssueType(input.issueType) : null;
+  if (fromIssueType !== null) {
+    const issueKey = normalizeKey(input.issueType ?? "");
+    if (issueKey === "task" && fromLabels !== null) {
+      return { type: fromLabels, source: "label" };
+    }
+    if (fromLabels !== null && fromLabels !== fromIssueType) {
+      return {
+        type: fromIssueType,
+        source: "issue-type",
+        conflict: { issueType: fromIssueType, label: fromLabels }
+      };
+    }
+    return { type: fromIssueType, source: "issue-type" };
+  }
+  if (fromLabels !== null) {
+    return { type: fromLabels, source: "label" };
+  }
+  if (input.titleConvention !== null && input.title !== void 0) {
+    const fromTitle = typeFromTitle(input.title);
+    if (fromTitle !== null) {
+      return { type: fromTitle, source: "title" };
+    }
+  } else if (input.title !== void 0) {
+    const fromTitle = typeFromTitle(input.title);
+    if (fromTitle !== null) {
+      return { type: fromTitle, source: "title" };
+    }
+  }
+  return { type: "feat", source: "fallback" };
+}
+
+// src/conventions/git/commit.ts
+var HEADER_MAX = 72;
+var BODY_WIDTH = 72;
+var STORY_ID = /^US-\d+$/i;
+function wrap(text, width) {
+  const paragraphs = text.replace(/\r\n/g, "\n").split("\n");
+  return paragraphs.map((paragraph) => {
+    if (paragraph.trim() === "") return "";
+    const words = paragraph.split(/\s+/);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+      const next = current === "" ? word : `${current} ${word}`;
+      if (next.length > width && current !== "") {
+        lines.push(current);
+        current = word;
+      } else {
+        current = next;
+      }
+    }
+    if (current !== "") lines.push(current);
+    return lines.join("\n");
+  }).join("\n");
+}
+function sanitizeScope(scope) {
+  if (scope === void 0 || scope === null) return void 0;
+  const trimmed = scope.trim();
+  if (trimmed === "" || isForbiddenProviderToken(trimmed)) return void 0;
+  return trimmed;
+}
+function sanitizeType(type) {
+  return isForbiddenProviderToken(type) ? "chore" : type;
+}
+function headerLine(type, scope, breaking, subject) {
+  const bang = breaking ? "!" : "";
+  const scoped = scope === void 0 ? `${type}${bang}` : `${type}(${scope})${bang}`;
+  const cleaned = subject.replace(/\.$/, "").trim();
+  const prefix = `${scoped}: `;
+  const budget = HEADER_MAX - prefix.length;
+  const clipped = budget < 1 ? "" : cleaned.length > budget ? cleaned.slice(0, budget).trimEnd() : cleaned;
+  return `${prefix}${clipped}`;
+}
+function commitMessage(input) {
+  const type = sanitizeType(input.type);
+  const scope = sanitizeScope(input.scope);
+  const breaking = input.breaking !== void 0 && input.breaking !== null && input.breaking !== "";
+  const lines = [headerLine(type, scope, breaking, input.subject)];
+  if (input.body !== void 0 && input.body !== "") {
+    lines.push("", wrap(input.body, BODY_WIDTH));
+  }
+  const footers = [];
+  if (input.issueNumber !== void 0 && input.issueNumber !== null) {
+    footers.push(`Refs #${input.issueNumber}`);
+  }
+  if (input.storyId !== void 0 && input.storyId !== null && STORY_ID.test(input.storyId)) {
+    footers.push(`Story: ${input.storyId}`);
+  }
+  if (breaking) {
+    footers.push(`BREAKING CHANGE: ${input.breaking}`);
+  }
+  if (input.signoff === true) {
+    footers.push("Signed-off-by:");
+  } else if (typeof input.signoff === "string" && input.signoff !== "") {
+    footers.push(`Signed-off-by: ${input.signoff}`);
+  }
+  if (footers.length > 0) {
+    lines.push("", ...footers);
+  }
+  return lines.join("\n");
+}
+
+// src/conventions/git/pull-request.ts
+var IMPACT = ["feat", "fix"];
+function sanitizeScope2(scope) {
+  if (scope === void 0 || scope === null) return void 0;
+  const trimmed = scope.trim();
+  if (trimmed === "" || isForbiddenProviderToken(trimmed)) return void 0;
+  return trimmed;
+}
+function highestImpact(types) {
+  for (const type of IMPACT) {
+    if (types.includes(type)) return type;
+  }
+  return types[0] ?? "feat";
+}
+function scopesAgree(scopes) {
+  const unique2 = [
+    ...new Set(scopes.map((scope) => sanitizeScope2(scope)).filter((scope) => scope !== void 0))
+  ];
+  return unique2.length === 1 ? unique2[0] : void 0;
+}
+function pullRequestTitle(input) {
+  const type = input.types !== void 0 && input.types.length > 0 ? highestImpact(input.types) : input.type;
+  const scope = input.scopes !== void 0 && input.scopes.length > 0 ? scopesAgree(input.scopes) : sanitizeScope2(input.scope);
+  const subject = input.subject.replace(/\.$/, "").trim();
+  if (isForbiddenProviderToken(type)) {
+    return scope === void 0 ? `chore: ${subject}` : `chore(${scope}): ${subject}`;
+  }
+  return scope === void 0 ? `${type}: ${subject}` : `${type}(${scope}): ${subject}`;
+}
+function issueReferenceLines(input) {
+  return input.references.map((ref) => {
+    const closes = ref.container === true ? ref.allChildrenComplete === true : ref.complete;
+    return `${closes ? "Closes" : "Refs"} #${ref.number}`;
+  }).join("\n");
+}
 
 // src/policy/resolve.ts
 import { isAbsolute, normalize, sep as sep2 } from "path";
@@ -58,6 +397,118 @@ function extractReferencedDocuments(content, fromPath) {
   return found;
 }
 
+// src/policy/parsers/git.ts
+var COMMITLINT_NAMES = [
+  ".commitlintrc",
+  ".commitlintrc.json",
+  ".commitlintrc.yaml",
+  ".commitlintrc.yml",
+  ".commitlintrc.js",
+  ".commitlintrc.cjs",
+  ".commitlintrc.mjs",
+  ".commitlintrc.ts",
+  "commitlint.config.js",
+  "commitlint.config.cjs",
+  "commitlint.config.mjs",
+  "commitlint.config.ts"
+];
+function unique(values) {
+  return [...new Set(values)];
+}
+function extractQuotedStrings(block) {
+  const matches = block.match(/['"]([a-z][a-z0-9-]*)['"]/g) ?? [];
+  return matches.map((token) => token.slice(1, -1));
+}
+function extractEnum(source, rule) {
+  const escaped = rule.replace("-", "\\-");
+  const match = source.match(new RegExp(`${escaped}[\\s\\S]{0,800}?\\[([\\s\\S]*?)\\]`, "i"));
+  if (match?.[1] === void 0) return [];
+  return extractQuotedStrings(match[1]).filter((value) => value !== "always" && value !== "never");
+}
+function parseCommitlintSource(source, path) {
+  const types = extractEnum(source, "type-enum").filter(isChangeType);
+  const scopes = extractEnum(source, "scope-enum");
+  const conventional = /conventional|commitlint/i.test(source) || types.length > 0;
+  return {
+    commitConvention: conventional ? "conventional" : null,
+    pullRequestTitleConvention: null,
+    allowedTypes: types.length > 0 ? unique(types) : null,
+    scopes: scopes.length > 0 ? unique(scopes) : null,
+    sources: [{ path, detail: conventional ? "commitlint" : "commitlint (unrecognised)" }]
+  };
+}
+function parsePackageCommitlint(pkg) {
+  if (pkg === null || typeof pkg !== "object" || Array.isArray(pkg)) return null;
+  const commitlint = pkg.commitlint;
+  if (commitlint === void 0 || commitlint === null) return null;
+  const source = JSON.stringify(commitlint);
+  return parseCommitlintSource(source, "package.json#commitlint");
+}
+function parseSemanticPrWorkflow(source, path) {
+  if (!/amannn\/action-semantic-pull-request/.test(source)) return null;
+  const typesBlock = source.match(/types:\s*[|>]?\s*\n((?:\s{2,}[a-z][a-z0-9-]*\s*\n)+)/i);
+  const scopesBlock = source.match(/scopes:\s*[|>]?\s*\n((?:\s{2,}[a-z][a-z0-9-]*\s*\n)+)/i);
+  const types = typesBlock?.[1]?.split("\n").map((line) => line.trim()).filter((line) => isChangeType(line)) ?? [];
+  const scopes = scopesBlock?.[1]?.split("\n").map((line) => line.trim()).filter((line) => /^[a-z][a-z0-9-]*$/.test(line)) ?? [];
+  return {
+    commitConvention: "conventional",
+    pullRequestTitleConvention: "conventional",
+    allowedTypes: types.length > 0 ? unique(types) : null,
+    scopes: scopes.length > 0 ? unique(scopes) : null,
+    sources: [{ path, detail: "amannn/action-semantic-pull-request" }]
+  };
+}
+function parseCommitlintText(source, path) {
+  return parseCommitlintSource(source, path);
+}
+function parsePackageJsonCommitlint(raw) {
+  try {
+    return parsePackageCommitlint(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function parseReleasePlease(_raw, path) {
+  return {
+    commitConvention: "conventional",
+    pullRequestTitleConvention: null,
+    allowedTypes: null,
+    scopes: null,
+    sources: [{ path, detail: "release-please (Conventional Commits)" }]
+  };
+}
+function parseSemanticRelease(path) {
+  return {
+    commitConvention: "conventional",
+    pullRequestTitleConvention: null,
+    allowedTypes: null,
+    scopes: null,
+    sources: [{ path, detail: "semantic-release" }]
+  };
+}
+function parseChangesetConfig(path) {
+  return {
+    commitConvention: null,
+    pullRequestTitleConvention: null,
+    allowedTypes: null,
+    scopes: null,
+    sources: [{ path, detail: "changesets release flow" }]
+  };
+}
+function parseHuskyCommitMsg(path) {
+  return {
+    commitConvention: null,
+    pullRequestTitleConvention: null,
+    allowedTypes: null,
+    scopes: null,
+    sources: [{ path, detail: "husky commit-msg hook" }]
+  };
+}
+function parseSemanticPullRequestWorkflow(source, path) {
+  return parseSemanticPrWorkflow(source, path);
+}
+var COMMITLINT_FILE_NAMES = COMMITLINT_NAMES;
+
 // src/policy/parsers/labels.ts
 function parseLabels(payload) {
   if (!Array.isArray(payload)) return [];
@@ -551,6 +1002,85 @@ async function discoverDocuments(root, scope) {
   }
   return { documents, sources };
 }
+function asPolicySources(discovered) {
+  return discovered.sources.map((entry) => ({
+    kind: "git-conventions",
+    origin: "filesystem",
+    path: entry.path,
+    status: "found",
+    detail: entry.detail
+  }));
+}
+async function discoverGitConventions(root) {
+  let merged = {
+    commitConvention: null,
+    pullRequestTitleConvention: null,
+    allowedTypes: null,
+    scopes: null,
+    sources: []
+  };
+  const take = (extra) => {
+    if (extra === null) return;
+    merged = {
+      commitConvention: merged.commitConvention ?? extra.commitConvention,
+      pullRequestTitleConvention: merged.pullRequestTitleConvention ?? extra.pullRequestTitleConvention,
+      allowedTypes: merged.allowedTypes ?? extra.allowedTypes,
+      scopes: merged.scopes ?? extra.scopes,
+      sources: [...merged.sources, ...extra.sources]
+    };
+  };
+  const pkg = await readCapped(join(root, "package.json"));
+  if (pkg !== null) {
+    take(parsePackageJsonCommitlint(pkg.content));
+  }
+  for (const name of COMMITLINT_FILE_NAMES) {
+    const found = await findFile(root, [name]);
+    if (found === null) continue;
+    const file = await readCapped(join(root, found));
+    if (file === null) continue;
+    take(parseCommitlintText(file.content, found));
+  }
+  for (const name of ["release-please-config.json", ".release-please-manifest.json"]) {
+    const found = await findFile(root, [name]);
+    if (found === null) continue;
+    const file = await readCapped(join(root, found));
+    if (file === null) continue;
+    take(parseReleasePlease(file.content, found));
+  }
+  for (const name of [
+    ".releaserc",
+    ".releaserc.json",
+    ".releaserc.yaml",
+    ".releaserc.yml",
+    "release.config.js"
+  ]) {
+    const found = await findFile(root, [name]);
+    if (found === null) continue;
+    take(parseSemanticRelease(found));
+  }
+  const changeset = await findFile(join(root, ".changeset"), ["config.json"]);
+  if (changeset !== null) {
+    take(parseChangesetConfig(`.changeset/${changeset}`));
+  }
+  const husky = await findFile(join(root, ".husky"), ["commit-msg"]);
+  if (husky !== null) {
+    take(parseHuskyCommitMsg(`.husky/${husky}`));
+  }
+  const workflowDir = join(root, ".github", "workflows");
+  for (const name of await listDirectory(workflowDir)) {
+    if (!/\.ya?ml$/i.test(name)) continue;
+    const file = await readCapped(join(workflowDir, name));
+    if (file === null) continue;
+    take(parseSemanticPullRequestWorkflow(file.content, `.github/workflows/${name}`));
+  }
+  return {
+    commitConvention: merged.commitConvention,
+    pullRequestTitleConvention: merged.pullRequestTitleConvention,
+    allowedTypes: merged.allowedTypes,
+    scopes: merged.scopes,
+    sources: asPolicySources(merged)
+  };
+}
 async function discoverBaseBranch(root, exec = defaultExec) {
   const options = { cwd: root, timeout: DISCOVERY_TIMEOUT_MS };
   try {
@@ -836,7 +1366,15 @@ function emptyPolicy(root, scope, enabled, sources) {
     enabled,
     issues: { templates: [], types: [], labels: [], titleConvention: null },
     pullRequests: { template: null, templates: [], baseBranch: null, titleConvention: null },
-    git: { branchConvention: null, commitConvention: null },
+    git: {
+      branchConvention: null,
+      commitConvention: null,
+      pullRequestTitleConvention: null,
+      issueReference: null,
+      typeMap: null,
+      allowedTypes: null,
+      scopes: null
+    },
     docs: [],
     codeowners: null,
     sources
@@ -854,7 +1392,7 @@ function disabledSource(kind) {
 var DECLARATION_KINDS = {
   issues: "issue-templates",
   pullRequests: "pull-request-template",
-  git: "base-branch"
+  git: "git-conventions"
 };
 async function resolvePolicy(root, scope, options) {
   const warn = options.warn ?? printWarning;
@@ -870,12 +1408,15 @@ async function resolvePolicy(root, scope, options) {
     ]);
   }
   const toggles = config.discovery;
-  const [templateDiscovery, prTemplates, documents, codeowners] = await Promise.all([
-    toggles.issueTemplates ? discoverIssueTemplates(root) : Promise.resolve({ templates: [], sources: [disabledSource("issue-templates")] }),
-    toggles.pullRequestTemplate ? discoverPullRequestTemplates(root) : Promise.resolve({ templates: [], sources: [disabledSource("pull-request-template")] }),
-    toggles.docs ? discoverDocuments(root, scope) : Promise.resolve({ documents: [], sources: [disabledSource("docs")] }),
-    toggles.codeowners ? discoverCodeowners(root) : Promise.resolve({ content: null, sources: [disabledSource("codeowners")] })
-  ]);
+  const [templateDiscovery, prTemplates, documents, codeowners, gitConventions] = await Promise.all(
+    [
+      toggles.issueTemplates ? discoverIssueTemplates(root) : Promise.resolve({ templates: [], sources: [disabledSource("issue-templates")] }),
+      toggles.pullRequestTemplate ? discoverPullRequestTemplates(root) : Promise.resolve({ templates: [], sources: [disabledSource("pull-request-template")] }),
+      toggles.docs ? discoverDocuments(root, scope) : Promise.resolve({ documents: [], sources: [disabledSource("docs")] }),
+      toggles.codeowners ? discoverCodeowners(root) : Promise.resolve({ content: null, sources: [disabledSource("codeowners")] }),
+      discoverGitConventions(root)
+    ]
+  );
   const wantsOrgTemplates = toggles.issueTemplates && templateDiscovery.templates.length === 0;
   const [baseBranch, slug] = await Promise.all([
     discoverBaseBranch(root, options.exec),
@@ -901,7 +1442,8 @@ async function resolvePolicy(root, scope, options) {
     ...prTemplates.sources,
     ...baseBranch.sources,
     ...documents.sources,
-    ...codeowners.sources
+    ...codeowners.sources,
+    ...gitConventions.sources
   ];
   const discoveredPullRequests = {};
   if (baseBranch.baseBranch !== null) {
@@ -916,8 +1458,30 @@ async function resolvePolicy(root, scope, options) {
     discovered: discoveredPullRequests,
     project: config.pullRequests
   });
+  const discoveredGit = {};
+  if (gitConventions.commitConvention !== null) {
+    discoveredGit.commitConvention = gitConventions.commitConvention;
+  }
+  if (gitConventions.pullRequestTitleConvention !== null) {
+    discoveredGit.pullRequestTitleConvention = gitConventions.pullRequestTitleConvention;
+  }
+  if (gitConventions.allowedTypes !== null) {
+    discoveredGit.allowedTypes = gitConventions.allowedTypes;
+  }
+  if (gitConventions.scopes !== null) {
+    discoveredGit.scopes = gitConventions.scopes;
+  }
   const git = mergeConfigLayers({
-    defaults: { branchConvention: null, commitConvention: null },
+    defaults: {
+      branchConvention: null,
+      commitConvention: null,
+      pullRequestTitleConvention: null,
+      issueReference: null,
+      typeMap: null,
+      allowedTypes: null,
+      scopes: null
+    },
+    discovered: discoveredGit,
     project: config.git
   });
   for (const group of ["issues", "pullRequests", "git"]) {
@@ -950,7 +1514,12 @@ async function resolvePolicy(root, scope, options) {
     },
     git: {
       branchConvention: git.branchConvention ?? null,
-      commitConvention: git.commitConvention ?? null
+      commitConvention: git.commitConvention ?? null,
+      pullRequestTitleConvention: git.pullRequestTitleConvention ?? null,
+      issueReference: git.issueReference ?? null,
+      typeMap: git.typeMap ?? null,
+      allowedTypes: git.allowedTypes ?? gitConventions.allowedTypes,
+      scopes: git.scopes ?? gitConventions.scopes
     },
     docs: documents.documents,
     codeowners: codeowners.content,
@@ -980,6 +1549,14 @@ async function loadRepositoryPolicy(options = {}) {
 }
 
 export {
+  DEFAULT_BRANCH_CONVENTION,
+  isChangeType,
+  branchName,
+  archiveFolderName,
+  resolveChangeType,
+  commitMessage,
+  pullRequestTitle,
+  issueReferenceLines,
   loadRepositoryPolicy
 };
-//# sourceMappingURL=chunk-EZATO3DW.js.map
+//# sourceMappingURL=chunk-RVO7L4FX.js.map