issue-flow 0.8.0 → 0.10.0

package/dist/policy-NP4ZAVF6.js

@@ -0,0 +1,1013 @@
+#!/usr/bin/env node
+import {
+  getProjectRoot,
+  loadPolicyConfig,
+  mergeConfigLayers,
+  run
+} from "./chunk-VYFKOUUR.js";
+import {
+  printError,
+  printInfo,
+  printWarning
+} from "./chunk-V5OHFSW4.js";
+
+// src/policy/discovery.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join, relative, sep } from "path";
+
+// src/policy/parsers/docs.ts
+import { posix } from "path";
+function classifyDocument(fileName) {
+  switch (fileName.toLowerCase()) {
+    case "agents.md":
+      return "agents";
+    case "claude.md":
+      return "claude";
+    case "contributing.md":
+      return "contributing";
+    case "code_of_conduct.md":
+    case "code-of-conduct.md":
+      return "code-of-conduct";
+    default:
+      return null;
+  }
+}
+var MAX_REFERENCED_DOCUMENTS = 20;
+var MARKDOWN_LINK = /\[[^\]\n]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+function extractReferencedDocuments(content, fromPath) {
+  const fromDir = posix.dirname(fromPath.replace(/\\/g, "/"));
+  const found = [];
+  for (const match of content.matchAll(MARKDOWN_LINK)) {
+    const raw = match[1];
+    if (raw === void 0) continue;
+    const target = raw.split("#")[0]?.split("?")[0]?.trim() ?? "";
+    if (target === "") continue;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(target) || target.startsWith("//")) continue;
+    if (!/\.(md|markdown)$/i.test(target)) continue;
+    const resolved = posix.normalize(
+      target.startsWith("/") ? target.slice(1) : fromDir === "." ? target : posix.join(fromDir, target)
+    );
+    if (resolved.startsWith("..") || resolved === "" || resolved === ".") continue;
+    if (resolved === fromPath || found.includes(resolved)) continue;
+    found.push(resolved);
+    if (found.length >= MAX_REFERENCED_DOCUMENTS) break;
+  }
+  return found;
+}
+
+// src/policy/parsers/labels.ts
+function parseLabels(payload) {
+  if (!Array.isArray(payload)) return [];
+  const labels = [];
+  for (const entry of payload) {
+    if (entry === null || typeof entry !== "object") continue;
+    const record = entry;
+    const name = typeof record.name === "string" ? record.name.trim() : "";
+    if (name === "") continue;
+    const description = typeof record.description === "string" ? record.description.trim() : "";
+    const color = typeof record.color === "string" ? record.color.trim() : "";
+    labels.push({
+      name,
+      description: description === "" ? null : description,
+      color: color === "" ? null : color
+    });
+  }
+  return labels;
+}
+function parseIssueTypes(payload) {
+  const entries = Array.isArray(payload) ? payload : Array.isArray(payload?.issue_types) ? payload.issue_types : [];
+  const types = [];
+  for (const entry of entries) {
+    const name = typeof entry === "string" ? entry : entry !== null && typeof entry === "object" ? entry.name : void 0;
+    if (typeof name !== "string") continue;
+    const trimmed = name.trim();
+    if (trimmed !== "" && !types.includes(trimmed)) {
+      types.push(trimmed);
+    }
+  }
+  return types;
+}
+
+// src/policy/parsers/templates.ts
+import { basename, extname } from "path";
+
+// src/policy/parsers/issue-forms.ts
+function emptyTemplateMetadata() {
+  return { name: null, about: null, title: null, labels: [], type: null, assignees: [] };
+}
+var TOP_LEVEL_KEY = /^([A-Za-z_][A-Za-z0-9_-]*):(?:\s+(.*))?$/;
+function topLevelRegions(source) {
+  const regions = /* @__PURE__ */ new Map();
+  const lines = source.split(/\r?\n/);
+  let current = null;
+  for (const line of lines) {
+    const match = /^[^\s#-]/.test(line) ? TOP_LEVEL_KEY.exec(line) : null;
+    if (match?.[1] !== void 0) {
+      current = { key: match[1], inline: (match[2] ?? "").trim(), block: [] };
+      if (!regions.has(current.key)) {
+        regions.set(current.key, current);
+      }
+      continue;
+    }
+    current?.block.push(line);
+  }
+  return regions;
+}
+function stripComment(value) {
+  let quote = null;
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (quote !== null) {
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "#" && (i === 0 || /\s/.test(value[i - 1] ?? ""))) {
+      return value.slice(0, i);
+    }
+  }
+  return value;
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if (first === '"' && last === '"') {
+      return trimmed.slice(1, -1).replace(/\\(["\\])/g, "$1");
+    }
+    if (first === "'" && last === "'") {
+      return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+  }
+  return trimmed;
+}
+function splitFlow(inner) {
+  const parts = [];
+  let buffer = "";
+  let quote = null;
+  for (const char of inner) {
+    if (quote !== null) {
+      if (char === quote) quote = null;
+      buffer += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      buffer += char;
+      continue;
+    }
+    if (char === ",") {
+      parts.push(buffer);
+      buffer = "";
+      continue;
+    }
+    buffer += char;
+  }
+  parts.push(buffer);
+  return parts.map(unquote).filter((part) => part !== "");
+}
+function readScalar(region) {
+  if (region === void 0) return null;
+  const inline = stripComment(region.inline).trim();
+  if (inline !== "" && inline !== "|" && inline !== ">" && inline !== "|-" && inline !== ">-") {
+    const value = unquote(inline);
+    return value === "" ? null : value;
+  }
+  const collected = region.block.filter((line) => line.trim() !== "").map((line) => line.trim()).join(inline.startsWith(">") ? " " : "\n").trim();
+  return collected === "" ? null : collected;
+}
+function readSequence(region) {
+  if (region === void 0) return [];
+  const inline = stripComment(region.inline).trim();
+  if (inline.startsWith("[")) {
+    const closing = inline.lastIndexOf("]");
+    return splitFlow(inline.slice(1, closing === -1 ? void 0 : closing));
+  }
+  if (inline !== "") {
+    const single = unquote(inline);
+    return single === "" ? [] : [single];
+  }
+  const items = [];
+  for (const line of region.block) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    if (!trimmed.startsWith("- ") && trimmed !== "-") break;
+    const value = unquote(stripComment(trimmed.slice(1)).trim());
+    if (value === "" || /^[A-Za-z_][A-Za-z0-9_-]*:\s/.test(value)) continue;
+    items.push(value);
+  }
+  return items;
+}
+function parseTemplateMetadata(source) {
+  const regions = topLevelRegions(source);
+  return {
+    name: readScalar(regions.get("name")),
+    // Issue Forms spell it `description`, legacy markdown templates `about`.
+    about: readScalar(regions.get("about")) ?? readScalar(regions.get("description")),
+    title: readScalar(regions.get("title")),
+    labels: readSequence(regions.get("labels")),
+    type: readScalar(regions.get("type")),
+    assignees: readSequence(regions.get("assignees"))
+  };
+}
+function extractFrontMatter(source) {
+  const normalized = source.replace(/^\uFEFF/, "");
+  if (!/^---[ \t]*\r?\n/.test(normalized)) return null;
+  const rest = normalized.slice(normalized.indexOf("\n") + 1);
+  const closing = /^---[ \t]*$/m.exec(rest);
+  if (closing?.index === void 0) return null;
+  return rest.slice(0, closing.index);
+}
+
+// src/policy/parsers/templates.ts
+function parseIssueTemplateFile(relPath, content) {
+  const extension = extname(relPath).toLowerCase();
+  const isForm = extension === ".yml" || extension === ".yaml";
+  const metadataSource = isForm ? content : extractFrontMatter(content);
+  const metadata = metadataSource === null ? emptyTemplateMetadata() : parseTemplateMetadata(metadataSource);
+  return {
+    path: relPath,
+    format: isForm ? "form" : "markdown",
+    origin: "filesystem",
+    // A template with no `name:` is still addressable by its file name, which
+    // is what GitHub falls back to for legacy markdown templates.
+    name: metadata.name ?? basename(relPath, extension),
+    about: metadata.about,
+    title: metadata.title,
+    labels: metadata.labels,
+    type: metadata.type,
+    assignees: metadata.assignees,
+    content
+  };
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asNameList(value, key) {
+  const entries = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.nodes) ? value.nodes : [];
+  return entries.map(
+    (entry) => typeof entry === "string" ? entry : asString(isRecord(entry) ? entry[key] : null)
+  ).filter((entry) => entry !== null && entry !== "");
+}
+function parseOrganizationTemplates(payload) {
+  const repository = isRecord(payload) && isRecord(payload.data) ? payload.data.repository : null;
+  const entries = isRecord(repository) ? repository.issueTemplates : null;
+  if (!Array.isArray(entries)) return [];
+  const templates = [];
+  for (const entry of entries) {
+    if (!isRecord(entry)) continue;
+    const name = asString(entry.name);
+    if (name === null) continue;
+    templates.push({
+      // The filename is the stable identity; the display name is not unique.
+      path: asString(entry.filename) ?? name,
+      format: "markdown",
+      origin: "organization",
+      name,
+      about: asString(entry.about),
+      title: asString(entry.title),
+      labels: asNameList(entry.labels, "name"),
+      // GraphQL exposes no Issue Type on a template, so it stays unknown here
+      // rather than being guessed from the name.
+      type: null,
+      assignees: asNameList(entry.assignees, "login"),
+      content: asString(entry.body) ?? ""
+    });
+  }
+  return templates;
+}
+
+// src/policy/types.ts
+var POLICY_SCHEMA_VERSION = 1;
+var MAX_POLICY_DOCUMENT_BYTES = 64 * 1024;
+
+// src/policy/discovery.ts
+var DISCOVERY_TIMEOUT_MS = 1e4;
+var POLICY_DIRECTORIES = [".github", "", "docs"];
+var defaultExec = (command, args, options) => run(command, args, { cwd: options.cwd, timeout: options.timeout });
+function toRelativePath(root, absolute) {
+  return relative(root, absolute).split(sep).join("/");
+}
+async function listDirectory(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => !entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readCapped(path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+  if (Buffer.byteLength(raw, "utf-8") <= MAX_POLICY_DOCUMENT_BYTES) {
+    return { content: raw, truncated: false };
+  }
+  const clipped = Buffer.from(raw, "utf-8").subarray(0, MAX_POLICY_DOCUMENT_BYTES).toString("utf-8");
+  return { content: clipped, truncated: true };
+}
+async function findFile(dir, names) {
+  const entries = await listDirectory(dir);
+  const wanted = names.map((name) => name.toLowerCase());
+  for (const name of wanted) {
+    const hit = entries.find((entry) => entry.toLowerCase() === name);
+    if (hit !== void 0) return hit;
+  }
+  return null;
+}
+var TEMPLATE_EXTENSIONS = [".yml", ".yaml", ".md", ".markdown"];
+function isTemplateFile(name) {
+  const lower = name.toLowerCase();
+  if (lower === "config.yml" || lower === "config.yaml") return false;
+  return TEMPLATE_EXTENSIONS.some((extension) => lower.endsWith(extension));
+}
+async function discoverIssueTemplates(root) {
+  const templates = [];
+  const sources = [];
+  for (const base of POLICY_DIRECTORIES) {
+    const baseDir = base === "" ? root : join(root, base);
+    const templateDir = await findDirectory(baseDir, "ISSUE_TEMPLATE") ?? null;
+    if (templateDir !== null) {
+      const names = (await listDirectory(templateDir)).filter(isTemplateFile).sort();
+      for (const name of names) {
+        const filePath = join(templateDir, name);
+        const file = await readCapped(filePath);
+        if (file === null) continue;
+        const relPath = toRelativePath(root, filePath);
+        templates.push(parseIssueTemplateFile(relPath, file.content));
+        sources.push({
+          kind: "issue-templates",
+          origin: "filesystem",
+          path: relPath,
+          status: "found",
+          detail: file.truncated ? "content truncated" : null
+        });
+      }
+    }
+    const singleFile = await findFile(baseDir, [
+      "ISSUE_TEMPLATE.md",
+      "ISSUE_TEMPLATE.yml",
+      "ISSUE_TEMPLATE.yaml",
+      "ISSUE_TEMPLATE.markdown"
+    ]);
+    if (singleFile !== null) {
+      const filePath = join(baseDir, singleFile);
+      const file = await readCapped(filePath);
+      if (file !== null) {
+        const relPath = toRelativePath(root, filePath);
+        templates.push(parseIssueTemplateFile(relPath, file.content));
+        sources.push({
+          kind: "issue-templates",
+          origin: "filesystem",
+          path: relPath,
+          status: "found",
+          detail: file.truncated ? "content truncated" : null
+        });
+      }
+    }
+  }
+  return { templates, sources };
+}
+async function findDirectory(parent, name) {
+  let entries;
+  try {
+    entries = (await readdir(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return null;
+  }
+  const hit = entries.find((entry) => entry.toLowerCase() === name.toLowerCase());
+  return hit === void 0 ? null : join(parent, hit);
+}
+var PR_TEMPLATE_FILES = [
+  "PULL_REQUEST_TEMPLATE.md",
+  "PULL_REQUEST_TEMPLATE.markdown",
+  "PULL_REQUEST_TEMPLATE.txt",
+  "PULL_REQUEST_TEMPLATE"
+];
+async function discoverPullRequestTemplates(root) {
+  const templates = [];
+  const sources = [];
+  const collect = async (filePath) => {
+    const file = await readCapped(filePath);
+    if (file === null) return;
+    const relPath = toRelativePath(root, filePath);
+    templates.push({
+      path: relPath,
+      name: relPath.split("/").pop() ?? relPath,
+      content: file.content
+    });
+    sources.push({
+      kind: "pull-request-template",
+      origin: "filesystem",
+      path: relPath,
+      status: "found",
+      detail: file.truncated ? "content truncated" : null
+    });
+  };
+  for (const base of POLICY_DIRECTORIES) {
+    const baseDir = base === "" ? root : join(root, base);
+    const single = await findFile(baseDir, PR_TEMPLATE_FILES);
+    if (single !== null && !await isDirectory(join(baseDir, single))) {
+      await collect(join(baseDir, single));
+    }
+    const templateDir = await findDirectory(baseDir, "PULL_REQUEST_TEMPLATE");
+    if (templateDir !== null) {
+      for (const name of (await listDirectory(templateDir)).sort()) {
+        if (!/\.(md|markdown|txt)$/i.test(name)) continue;
+        await collect(join(templateDir, name));
+      }
+    }
+  }
+  return { templates, sources };
+}
+async function discoverCodeowners(root) {
+  for (const base of POLICY_DIRECTORIES) {
+    const baseDir = base === "" ? root : join(root, base);
+    const name = await findFile(baseDir, ["CODEOWNERS"]);
+    if (name === null) continue;
+    const file = await readCapped(join(baseDir, name));
+    if (file === null) continue;
+    const relPath = toRelativePath(root, join(baseDir, name));
+    return {
+      content: file.content,
+      sources: [
+        {
+          kind: "codeowners",
+          origin: "filesystem",
+          path: relPath,
+          status: "found",
+          detail: file.truncated ? "content truncated" : null
+        }
+      ]
+    };
+  }
+  return { content: null, sources: [] };
+}
+var ROOT_DOCUMENT_FILES = ["CONTRIBUTING.md", "CODE_OF_CONDUCT.md"];
+var SCOPED_DOCUMENT_FILES = ["AGENTS.md", "CLAUDE.md"];
+function scopeLadder(scope) {
+  if (scope === null || scope === "") return [""];
+  const segments = scope.split("/").filter((segment) => segment !== "");
+  const ladder = [""];
+  let current = "";
+  for (const segment of segments) {
+    current = current === "" ? segment : `${current}/${segment}`;
+    ladder.push(current);
+  }
+  return ladder;
+}
+async function discoverDocuments(root, scope) {
+  const documents = [];
+  const sources = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = async (filePath, kind, docScope, referencedFrom) => {
+    const relPath = toRelativePath(root, filePath);
+    if (seen.has(relPath)) return null;
+    const file = await readCapped(filePath);
+    if (file === null) return null;
+    seen.add(relPath);
+    const document = {
+      path: relPath,
+      kind,
+      scope: docScope,
+      referencedFrom,
+      content: file.content
+    };
+    documents.push(document);
+    sources.push({
+      kind: "docs",
+      origin: "filesystem",
+      path: relPath,
+      status: "found",
+      detail: file.truncated ? "content truncated" : null
+    });
+    return document;
+  };
+  for (const base of POLICY_DIRECTORIES) {
+    const baseDir = base === "" ? root : join(root, base);
+    for (const wanted of ROOT_DOCUMENT_FILES) {
+      const name = await findFile(baseDir, [wanted]);
+      if (name === null) continue;
+      const kind = classifyDocument(name);
+      if (kind === null) continue;
+      await collect(join(baseDir, name), kind, "", null);
+    }
+  }
+  const indexes = [];
+  for (const level of scopeLadder(scope)) {
+    const levelDir = level === "" ? root : join(root, level);
+    for (const wanted of SCOPED_DOCUMENT_FILES) {
+      const name = await findFile(levelDir, [wanted]);
+      if (name === null) continue;
+      const kind = classifyDocument(name);
+      if (kind === null) continue;
+      const document = await collect(join(levelDir, name), kind, level, null);
+      if (document !== null && kind === "agents") {
+        indexes.push(document);
+      }
+    }
+  }
+  for (const index of indexes) {
+    for (const target of extractReferencedDocuments(index.content, index.path)) {
+      await collect(join(root, target), "referenced", index.scope, index.path);
+    }
+  }
+  return { documents, sources };
+}
+async function discoverBaseBranch(root, exec = defaultExec) {
+  const options = { cwd: root, timeout: DISCOVERY_TIMEOUT_MS };
+  try {
+    const remoteHead = await exec(
+      "git",
+      ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+      options
+    );
+    if (remoteHead.exitCode === 0) {
+      const name = remoteHead.stdout.trim().replace(/^origin\//, "");
+      if (name !== "") {
+        return {
+          baseBranch: name,
+          sources: [
+            {
+              kind: "base-branch",
+              origin: "git",
+              path: null,
+              status: "found",
+              detail: "origin/HEAD"
+            }
+          ]
+        };
+      }
+    }
+    for (const candidate of ["main", "master"]) {
+      const check = await exec(
+        "git",
+        ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`],
+        options
+      );
+      if (check.exitCode === 0) {
+        return {
+          baseBranch: candidate,
+          sources: [
+            {
+              kind: "base-branch",
+              origin: "git",
+              path: null,
+              status: "found",
+              detail: `refs/heads/${candidate}`
+            }
+          ]
+        };
+      }
+    }
+  } catch {
+    return {
+      baseBranch: null,
+      sources: [
+        {
+          kind: "base-branch",
+          origin: "git",
+          path: null,
+          status: "unavailable",
+          detail: "git could not be executed"
+        }
+      ]
+    };
+  }
+  return { baseBranch: null, sources: [] };
+}
+async function discoverGitHubSlug(root, exec = defaultExec) {
+  let url = "";
+  try {
+    const result = await exec("git", ["remote", "get-url", "origin"], {
+      cwd: root,
+      timeout: DISCOVERY_TIMEOUT_MS
+    });
+    if (result.exitCode !== 0) return null;
+    url = result.stdout.trim();
+  } catch {
+    return null;
+  }
+  if (url === "") return null;
+  const match = /[/:]([^/:\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(url);
+  if (match?.[1] === void 0 || match[2] === void 0) return null;
+  return { owner: match[1], repo: match[2] };
+}
+async function ghJson(root, args, exec) {
+  let result;
+  try {
+    result = await exec("gh", args, { cwd: root, timeout: DISCOVERY_TIMEOUT_MS });
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.trim().split("\n")[0] ?? "";
+    return { error: stderr === "" ? `gh exited with ${result.exitCode}` : stderr };
+  }
+  try {
+    return { value: JSON.parse(result.stdout) };
+  } catch {
+    return { error: "gh returned unparseable JSON" };
+  }
+}
+var LABEL_PAGE_SIZE = 200;
+async function discoverLabels(root, exec = defaultExec) {
+  const outcome = await ghJson(
+    root,
+    ["label", "list", "--json", "name,description,color", "--limit", String(LABEL_PAGE_SIZE)],
+    exec
+  );
+  if ("error" in outcome) {
+    return {
+      labels: [],
+      sources: [
+        { kind: "labels", origin: "gh", path: null, status: "unavailable", detail: outcome.error }
+      ]
+    };
+  }
+  const labels = parseLabels(outcome.value);
+  return {
+    labels,
+    sources: [
+      {
+        kind: "labels",
+        origin: "gh",
+        path: null,
+        status: "found",
+        detail: `${labels.length} label(s)`
+      }
+    ]
+  };
+}
+async function discoverIssueTypes(root, owner, exec = defaultExec) {
+  if (owner === null || owner === "") {
+    return { types: [], sources: [] };
+  }
+  const outcome = await ghJson(root, ["api", `orgs/${owner}/issue-types`], exec);
+  if ("error" in outcome) {
+    return {
+      types: [],
+      sources: [
+        {
+          kind: "issue-types",
+          origin: "gh",
+          path: null,
+          // A personal account (404) and a plan without Issue Types (403) are
+          // the common answers here, so the detail carries what gh said.
+          status: "unavailable",
+          detail: outcome.error
+        }
+      ]
+    };
+  }
+  const types = parseIssueTypes(outcome.value);
+  return {
+    types,
+    sources: [
+      {
+        kind: "issue-types",
+        origin: "gh",
+        path: null,
+        status: "found",
+        detail: `${types.length} type(s)`
+      }
+    ]
+  };
+}
+var ORGANIZATION_TEMPLATES_QUERY = `query($owner:String!,$name:String!){
+  repository(owner:$owner,name:$name){
+    issueTemplates{
+      name
+      title
+      about
+      filename
+      body
+      assignees(first:10){nodes{login}}
+      labels(first:20){nodes{name}}
+    }
+  }
+}`;
+async function discoverOrganizationTemplates(root, slug, exec = defaultExec) {
+  if (slug === null) {
+    return { templates: [], sources: [] };
+  }
+  const outcome = await ghJson(
+    root,
+    [
+      "api",
+      "graphql",
+      "-f",
+      `query=${ORGANIZATION_TEMPLATES_QUERY}`,
+      "-f",
+      `owner=${slug.owner}`,
+      "-f",
+      `name=${slug.repo}`
+    ],
+    exec
+  );
+  if ("error" in outcome) {
+    return {
+      templates: [],
+      sources: [
+        {
+          kind: "issue-templates",
+          origin: "gh",
+          path: null,
+          status: "unavailable",
+          detail: outcome.error
+        }
+      ]
+    };
+  }
+  const templates = parseOrganizationTemplates(outcome.value);
+  if (templates.length === 0) {
+    return { templates, sources: [] };
+  }
+  return {
+    templates,
+    sources: templates.map((template) => ({
+      kind: "issue-templates",
+      origin: "gh",
+      path: null,
+      status: "found",
+      detail: `organization default "${template.name}"`
+    }))
+  };
+}
+
+// src/policy/resolve.ts
+import { isAbsolute, normalize, sep as sep2 } from "path";
+function normalizeScope(scope) {
+  if (scope === null || scope === void 0) return null;
+  const trimmed = scope.trim();
+  if (trimmed === "" || trimmed === "." || isAbsolute(trimmed)) return null;
+  const normalized = normalize(trimmed).split(sep2).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+  if (normalized === "" || normalized === "." || normalized.startsWith("..")) return null;
+  return normalized;
+}
+function emptyPolicy(root, scope, enabled, sources) {
+  return {
+    schemaVersion: POLICY_SCHEMA_VERSION,
+    root,
+    scope,
+    enabled,
+    issues: { templates: [], types: [], labels: [], titleConvention: null },
+    pullRequests: { template: null, templates: [], baseBranch: null, titleConvention: null },
+    git: { branchConvention: null, commitConvention: null },
+    docs: [],
+    codeowners: null,
+    sources
+  };
+}
+function disabledSource(kind) {
+  return {
+    kind,
+    origin: "config",
+    path: null,
+    status: "disabled",
+    detail: "disabled by configuration"
+  };
+}
+var DECLARATION_KINDS = {
+  issues: "issue-templates",
+  pullRequests: "pull-request-template",
+  git: "base-branch"
+};
+async function resolvePolicy(root, scope, options) {
+  const warn = options.warn ?? printWarning;
+  const config = await loadPolicyConfig({
+    projectRoot: root,
+    env: options.env,
+    cli: options.cli,
+    warn
+  });
+  if (!config.enabled) {
+    return emptyPolicy(root, scope, false, [
+      { kind: "docs", origin: "config", path: null, status: "disabled", detail: "policy.enabled" }
+    ]);
+  }
+  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 wantsOrgTemplates = toggles.issueTemplates && templateDiscovery.templates.length === 0;
+  const [baseBranch, slug] = await Promise.all([
+    discoverBaseBranch(root, options.exec),
+    toggles.issueTypes || wantsOrgTemplates ? discoverGitHubSlug(root, options.exec) : Promise.resolve(null)
+  ]);
+  const [labels, issueTypes, orgTemplates] = await Promise.all([
+    toggles.labels ? discoverLabels(root, options.exec) : Promise.resolve({ labels: [], sources: [disabledSource("labels")] }),
+    toggles.issueTypes ? discoverIssueTypes(root, slug?.owner ?? null, options.exec) : Promise.resolve({ types: [], sources: [disabledSource("issue-types")] }),
+    wantsOrgTemplates ? discoverOrganizationTemplates(root, slug, options.exec) : Promise.resolve({ templates: [], sources: [] })
+  ]);
+  const sources = [
+    ...templateDiscovery.sources,
+    ...orgTemplates.sources,
+    ...issueTypes.sources,
+    ...labels.sources,
+    ...prTemplates.sources,
+    ...baseBranch.sources,
+    ...documents.sources,
+    ...codeowners.sources
+  ];
+  const discoveredPullRequests = {};
+  if (baseBranch.baseBranch !== null) {
+    discoveredPullRequests.baseBranch = baseBranch.baseBranch;
+  }
+  const issues = mergeConfigLayers({
+    defaults: { titleConvention: null },
+    project: config.issues
+  });
+  const pullRequests = mergeConfigLayers({
+    defaults: { baseBranch: null, titleConvention: null },
+    discovered: discoveredPullRequests,
+    project: config.pullRequests
+  });
+  const git = mergeConfigLayers({
+    defaults: { branchConvention: null, commitConvention: null },
+    project: config.git
+  });
+  for (const group of ["issues", "pullRequests", "git"]) {
+    for (const key of Object.keys(config[group])) {
+      sources.push({
+        kind: DECLARATION_KINDS[group],
+        origin: "config",
+        path: null,
+        status: "found",
+        detail: `${group}.${key} declared`
+      });
+    }
+  }
+  return {
+    schemaVersion: POLICY_SCHEMA_VERSION,
+    root,
+    scope,
+    enabled: true,
+    issues: {
+      templates: [...templateDiscovery.templates, ...orgTemplates.templates],
+      types: issueTypes.types,
+      labels: labels.labels,
+      titleConvention: issues.titleConvention ?? null
+    },
+    pullRequests: {
+      template: prTemplates.templates[0]?.content ?? null,
+      templates: prTemplates.templates,
+      baseBranch: pullRequests.baseBranch ?? null,
+      titleConvention: pullRequests.titleConvention ?? null
+    },
+    git: {
+      branchConvention: git.branchConvention ?? null,
+      commitConvention: git.commitConvention ?? null
+    },
+    docs: documents.documents,
+    codeowners: codeowners.content,
+    sources
+  };
+}
+var cache = /* @__PURE__ */ new Map();
+async function loadRepositoryPolicy(options = {}) {
+  const root = options.root ?? await getProjectRoot();
+  const scope = normalizeScope(options.scope);
+  if (options.cache === false) {
+    return resolvePolicy(root, scope, options);
+  }
+  const key = `${root}\0${scope ?? ""}`;
+  const cached = cache.get(key);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const pending = resolvePolicy(root, scope, options);
+  cache.set(key, pending);
+  try {
+    return await pending;
+  } catch (err) {
+    cache.delete(key);
+    throw err;
+  }
+}
+
+// src/commands/policy.ts
+function groupSources(sources) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const bucket = grouped.get(source.kind);
+    if (bucket === void 0) {
+      grouped.set(source.kind, [source]);
+    } else {
+      bucket.push(source);
+    }
+  }
+  return grouped;
+}
+function describeSource(source) {
+  const where = source.path ?? source.origin;
+  const detail = source.detail === null ? "" : ` \u2014 ${source.detail}`;
+  return `${source.status === "found" ? "" : `[${source.status}] `}${where}${detail}`;
+}
+function render(policy) {
+  const lines = [];
+  const push = (line = "") => {
+    lines.push(line);
+  };
+  push(`Repository: ${policy.root}`);
+  push(`Scope:      ${policy.scope ?? "(root)"}`);
+  if (!policy.enabled) {
+    push();
+    push("Policy discovery is disabled (policy.enabled = false).");
+    console.log(lines.join("\n"));
+    return;
+  }
+  push();
+  push("Issues");
+  push(`  templates: ${policy.issues.templates.length}`);
+  for (const template of policy.issues.templates) {
+    const labels = template.labels.length > 0 ? ` labels=[${template.labels.join(", ")}]` : "";
+    const type = template.type === null ? "" : ` type=${template.type}`;
+    push(`    - ${template.path} (${template.format}, ${template.origin})${type}${labels}`);
+  }
+  push(`  types:  ${policy.issues.types.length > 0 ? policy.issues.types.join(", ") : "(none)"}`);
+  push(`  labels: ${policy.issues.labels.length}`);
+  for (const label of policy.issues.labels) {
+    push(`    - ${label.name}${label.description === null ? "" : ` \u2014 ${label.description}`}`);
+  }
+  push(`  titleConvention: ${policy.issues.titleConvention ?? "(none)"}`);
+  push();
+  push("Pull Requests");
+  push(`  template:  ${policy.pullRequests.templates[0]?.path ?? "(none)"}`);
+  for (const template of policy.pullRequests.templates.slice(1)) {
+    push(`    - ${template.path}`);
+  }
+  push(`  baseBranch:      ${policy.pullRequests.baseBranch ?? "(none)"}`);
+  push(`  titleConvention: ${policy.pullRequests.titleConvention ?? "(none)"}`);
+  push();
+  push("Git");
+  push(`  branchConvention: ${policy.git.branchConvention ?? "(none)"}`);
+  push(`  commitConvention: ${policy.git.commitConvention ?? "(none)"}`);
+  push();
+  push(`Documents: ${policy.docs.length}`);
+  for (const doc of policy.docs) {
+    const scope = doc.scope === "" ? "root" : doc.scope;
+    const from = doc.referencedFrom === null ? "" : ` \u2190 ${doc.referencedFrom}`;
+    push(`  - ${doc.path} (${doc.kind}, scope=${scope})${from}`);
+  }
+  push();
+  push(`CODEOWNERS: ${policy.codeowners === null ? "(none)" : "found"}`);
+  push();
+  push("Sources");
+  for (const [kind, entries] of groupSources(policy.sources)) {
+    push(`  ${kind}`);
+    for (const entry of entries) {
+      push(`    - ${describeSource(entry)}`);
+    }
+  }
+  console.log(lines.join("\n"));
+}
+async function runPolicy(options = {}) {
+  let policy;
+  try {
+    policy = await loadRepositoryPolicy({ scope: options.scope ?? null });
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (options.json === true) {
+    console.log(JSON.stringify(policy, null, 2));
+    return 0;
+  }
+  render(policy);
+  const unavailable = policy.sources.filter((source) => source.status === "unavailable");
+  if (unavailable.length > 0) {
+    console.log("");
+    printWarning(
+      `${unavailable.length} source(s) could not be consulted; the policy above is incomplete.`
+    );
+  } else if (policy.sources.length === 0) {
+    console.log("");
+    printInfo("This repository declares no policy sources; Issue Flow defaults apply.");
+  }
+  return 0;
+}
+export {
+  runPolicy
+};
+//# sourceMappingURL=policy-NP4ZAVF6.js.map