issue-flow 0.9.0 → 0.11.0

package/dist/apply-WUJHDD7A.js

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+import "./chunk-3D4A4B46.js";
+import {
+  loadRepositoryPolicy
+} from "./chunk-47VIN33V.js";
+import {
+  getProjectRoot
+} from "./chunk-VQ5VN7DF.js";
+import "./chunk-HC2MT7BX.js";
+
+// src/scaffold/apply.ts
+import { access, mkdir, writeFile } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+
+// src/scaffold/plan.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// src/conventions/defaults.ts
+var DEFAULT_ISSUE_TYPES = [
+  {
+    name: "Idea",
+    slug: "idea",
+    order: 1,
+    summary: "A hypothesis, opportunity or perceived problem, not yet analysed.",
+    executable: false,
+    native: false
+  },
+  {
+    name: "Research",
+    slug: "research",
+    order: 2,
+    summary: "An investigation that produces knowledge: analysis, benchmark, feasibility.",
+    executable: false,
+    native: false
+  },
+  {
+    name: "Epic",
+    slug: "epic",
+    order: 3,
+    summary: "An umbrella objective delivered through sub-issues.",
+    executable: false,
+    native: false
+  },
+  {
+    name: "Feature",
+    slug: "feature",
+    order: 4,
+    summary: "A new capability or a change to what the product does.",
+    executable: true,
+    native: true
+  },
+  {
+    name: "Bug",
+    slug: "bug",
+    order: 5,
+    summary: "Existing behaviour that diverges from what is expected.",
+    executable: true,
+    native: true
+  },
+  {
+    name: "Task",
+    slug: "task",
+    order: 6,
+    summary: "Concrete work that is neither a feature nor a bug.",
+    executable: true,
+    native: true
+  }
+];
+var NON_TYPES = [
+  {
+    concept: "Documentation",
+    instead: "`Task` + label `docs`",
+    why: "The work is a task; what varies is the area it touches."
+  },
+  {
+    concept: "Maintenance, chore",
+    instead: "`Task`",
+    why: "That is already what `Task` means."
+  },
+  {
+    concept: "Refactor, technical debt",
+    instead: "`Task` + label `tech-debt`",
+    why: "A cross-cutting characteristic, not a distinct nature of work."
+  },
+  {
+    concept: "Security",
+    instead: "the real type (`Bug`/`Task`/`Feature`) + label `security`",
+    why: "It cuts across every type; as a type it would hide whether the item is a flaw or preventive work."
+  },
+  {
+    concept: "Spike, investigation",
+    instead: "`Research`",
+    why: "The same concept under a different name."
+  },
+  {
+    concept: "Enhancement",
+    instead: "`Feature`",
+    why: "A change to what the product does is a feature, whether it is new or an improvement."
+  },
+  {
+    concept: "Proposal, RFC",
+    instead: "`Research`, and an ADR for the decision it produces",
+    why: "The issue carries the investigation; the decision belongs in a document that outlives it."
+  },
+  {
+    concept: "Question",
+    instead: "a Discussion, or `Research` when it needs work",
+    why: "A question that needs no work is not a backlog item."
+  }
+];
+var DEFAULT_LABELS = [
+  { name: "api", description: "Public interfaces and contracts", color: "006b75" },
+  { name: "backend", description: "Server-side code", color: "5319e7" },
+  { name: "frontend", description: "User-facing code", color: "bfd4f2" },
+  { name: "database", description: "Schema, queries and migrations", color: "c2e0c6" },
+  { name: "infra", description: "Infrastructure, CI and deployment", color: "f9d0c4" },
+  { name: "docs", description: "Documentation", color: "0075ca" },
+  { name: "security", description: "Security or privacy impact", color: "d93f0b" },
+  {
+    name: "tech-debt",
+    description: "Debt paid down rather than capability added",
+    color: "e4e669"
+  },
+  { name: "blocked", description: "Waiting on something outside this repository", color: "b60205" },
+  { name: "good first issue", description: "Good for newcomers", color: "7057ff" }
+];
+var FALLBACK_TYPE_LABELS = DEFAULT_ISSUE_TYPES.map((type) => ({
+  name: `type:${type.slug}`,
+  description: type.summary,
+  color: type.executable ? "1d76db" : "d4c5f9"
+}));
+var DEFAULT_COMMIT_CONVENTION = "Conventional Commits \u2014 type(scope): subject";
+
+// src/scaffold/assets.ts
+function acceptanceCriteriaField() {
+  return [
+    "  - type: textarea",
+    "    id: acceptance",
+    "    attributes:",
+    "      label: Acceptance criteria",
+    "      description: How anyone can tell this is done. Checks that fail today and pass afterwards.",
+    "      value: |",
+    "        - [ ] ",
+    "    validations:",
+    "      required: true"
+  ].join("\n");
+}
+function referencesField() {
+  return [
+    "  - type: textarea",
+    "    id: references",
+    "    attributes:",
+    "      label: References",
+    "      description: Links, related issues, prior discussion, evidence."
+  ].join("\n");
+}
+function renderIssueForm(type) {
+  const header = [
+    `name: "${emojiFor(type.slug)} ${type.name}"`,
+    `description: "${type.summary}"`,
+    `type: "${type.name}"`,
+    "body:"
+  ];
+  const bodies = {
+    idea: [
+      "  - type: markdown",
+      "    attributes:",
+      "      value: |",
+      "        Quick capture. Only the first field is required \u2014 triage fills in the rest.",
+      "        An Idea is **not approved work**: no agent implements it.",
+      "  - type: textarea",
+      "    id: idea",
+      "    attributes:",
+      "      label: The idea",
+      "      description: What it is, in a few lines. It does not have to be solved or complete.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: problem",
+      "    attributes:",
+      "      label: Problem or opportunity",
+      "      description: What pain or gain is behind it? Leave blank if you do not know yet.",
+      referencesField(),
+      "  - type: textarea",
+      "    id: questions",
+      "    attributes:",
+      "      label: Open questions",
+      "      description: What would have to be answered before deciding anything."
+    ],
+    research: [
+      "  - type: textarea",
+      "    id: question",
+      "    attributes:",
+      "      label: Question to answer",
+      "      description: The decision this investigation has to unblock.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: context",
+      "    attributes:",
+      "      label: Context",
+      "      description: What is already known, and why the question is open.",
+      "  - type: textarea",
+      "    id: deliverable",
+      "    attributes:",
+      "      label: Expected deliverable",
+      "      description: A conclusion and a recommendation. Say where durable knowledge will be written down.",
+      "    validations:",
+      "      required: true",
+      referencesField()
+    ],
+    epic: [
+      "  - type: markdown",
+      "    attributes:",
+      "      value: |",
+      "        An Epic is never executed directly: it is delivered through its sub-issues.",
+      "  - type: textarea",
+      "    id: objective",
+      "    attributes:",
+      "      label: Objective",
+      "      description: The state of the product this Epic describes.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: scope",
+      "    attributes:",
+      "      label: Scope",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: out-of-scope",
+      "    attributes:",
+      "      label: Out of scope",
+      "      description: What this Epic deliberately does not cover. Absence here is what makes scope creep arguable.",
+      "  - type: textarea",
+      "    id: children",
+      "    attributes:",
+      "      label: Known sub-issues",
+      "      description: Add them as sub-issues once they exist; list what you already foresee."
+    ],
+    feature: [
+      "  - type: textarea",
+      "    id: problem",
+      "    attributes:",
+      "      label: Problem",
+      "      description: What is not possible today, and for whom.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: objective",
+      "    attributes:",
+      "      label: Objective",
+      "      description: What becomes true when this is done.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: scope",
+      "    attributes:",
+      "      label: Scope and out of scope",
+      "      description: What is included, and what is deliberately not.",
+      acceptanceCriteriaField(),
+      "  - type: textarea",
+      "    id: dependencies",
+      "    attributes:",
+      "      label: Dependencies and risks",
+      "      description: What has to exist first, and what could go wrong.",
+      referencesField()
+    ],
+    bug: [
+      "  - type: textarea",
+      "    id: current",
+      "    attributes:",
+      "      label: Current behaviour",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: expected",
+      "    attributes:",
+      "      label: Expected behaviour",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: steps",
+      "    attributes:",
+      "      label: Steps to reproduce",
+      "      value: |",
+      "        1.",
+      "        2.",
+      "        3.",
+      "    validations:",
+      "      required: true",
+      "  - type: input",
+      "    id: environment",
+      "    attributes:",
+      "      label: Environment",
+      "      description: Where it happens \u2014 environment, version, component, browser.",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: evidence",
+      "    attributes:",
+      "      label: Evidence",
+      "      description: Logs, request and response, screenshot, trace id, affected URL.",
+      "  - type: dropdown",
+      "    id: impact",
+      "    attributes:",
+      "      label: Impact",
+      "      options:",
+      '        - "Data loss or improper exposure"',
+      '        - "Feature unavailable, no workaround"',
+      '        - "Feature degraded, workaround exists"',
+      '        - "Cosmetic or low consequence"',
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: done",
+      "    attributes:",
+      "      label: How to tell it is fixed",
+      "      description: The check that fails today and passes afterwards.",
+      "    validations:",
+      "      required: true"
+    ],
+    task: [
+      "  - type: textarea",
+      "    id: what",
+      "    attributes:",
+      "      label: What has to be done",
+      "    validations:",
+      "      required: true",
+      "  - type: textarea",
+      "    id: why",
+      "    attributes:",
+      "      label: Why",
+      "      description: The reason this is worth doing now.",
+      "    validations:",
+      "      required: true",
+      acceptanceCriteriaField(),
+      referencesField()
+    ]
+  };
+  const body = bodies[type.slug];
+  if (body === void 0) {
+    throw new Error(`No Issue Form body defined for type "${type.slug}"`);
+  }
+  return `${[...header, ...body].join("\n")}
+`;
+}
+function emojiFor(slug) {
+  const map = {
+    idea: "\u{1F4A1}",
+    research: "\u{1F52C}",
+    epic: "\u{1F5FA}\uFE0F",
+    feature: "\u2728",
+    bug: "\u{1F41B}",
+    task: "\u{1F527}"
+  };
+  return map[slug] ?? "\u{1F4CC}";
+}
+function renderIssueTemplateConfig() {
+  return [
+    "blank_issues_enabled: true",
+    "contact_links:",
+    "  - name: How this backlog works",
+    "    url: https://github.com/fabioassuncao/issue-flow/blob/main/docs/conventions.md",
+    "    about: Issue types, what each one authorizes, labels and the lifecycle.",
+    ""
+  ].join("\n");
+}
+function renderPullRequestTemplate() {
+  return [
+    "## What changed",
+    "",
+    "<!-- What this Pull Request does, and why. One paragraph is enough. -->",
+    "",
+    "## How it was tested",
+    "",
+    '<!-- The checks you ran, and what they proved. "CI is green" is not a test plan. -->',
+    "",
+    "## Related issues",
+    "",
+    "<!--",
+    "One `Closes #N` per issue this resolves, each on its own line and as plain body",
+    "text \u2014 GitHub only auto-closes when the line is not inside a code fence.",
+    "-->",
+    "",
+    "## Notes for reviewers",
+    "",
+    '<!-- Where to start, and anything you are unsure about. Write "N/A" rather than deleting a section. -->',
+    ""
+  ].join("\n");
+}
+function renderAgentsMd(projectName, referenced) {
+  const lines = [
+    `# ${projectName}`,
+    "",
+    "This file is an **index**. It holds no rule, command or convention of its own \u2014",
+    "those live in the documents referenced below, which are the source of truth.",
+    "",
+    "> Document once. Reference everywhere it is needed.",
+    "",
+    "## Start here",
+    ""
+  ];
+  for (const path of referenced) {
+    lines.push(`- [\`${path}\`](${path})`);
+  }
+  if (referenced.length === 0) {
+    lines.push("- [`README.md`](README.md) \u2014 what this project is, and how to run it");
+  }
+  lines.push(
+    "",
+    "## Working on an issue",
+    "",
+    "- [`docs/conventions.md`](docs/conventions.md) \u2014 issue types, labels, branches,",
+    "  commits and Pull Requests: what this repository expects and what it does not",
+    "",
+    "## What does not belong in this file",
+    "",
+    "Anything that can live in a document of its own: build and test commands, code",
+    "style, architecture rules, testing strategy, operational procedures. If it is a",
+    "rule, a standard or reusable knowledge, it belongs in its own document and this",
+    "file only points at it.",
+    "",
+    "An instruction that today exists **only** here does not stay here: move it to the",
+    "right document and leave a reference behind. Duplicated instructions in an agent",
+    "file age out of sight and start contradicting the source without anyone noticing.",
+    ""
+  );
+  return lines.join("\n");
+}
+function renderClaudeMd() {
+  return "Read and follow the instructions in AGENTS.md.\n";
+}
+function renderConventionsDoc(hasIssueTypes) {
+  const typeRows = DEFAULT_ISSUE_TYPES.map(
+    (t) => `| **${t.name}** | ${t.summary} | ${t.executable ? "Yes, once it is ready" : "**No**"} |`
+  ).join("\n");
+  const nonTypeRows = NON_TYPES.map((n) => `| ${n.concept} | ${n.instead} | ${n.why} |`).join("\n");
+  const labelRows = DEFAULT_LABELS.map((l) => `| \`${l.name}\` | ${l.description} |`).join("\n");
+  const typeMechanism = hasIssueTypes ? "This organization has GitHub Issue Types, so the type lives in the **native field**." : [
+    "This organization has no GitHub Issue Types, so the type is carried by a",
+    "`type:*` label. If Issue Types are enabled later, move to them and drop these",
+    "labels \u2014 keeping both would create a second truth that drifts."
+  ].join("\n");
+  return `# Conventions
+
+How work is recorded, classified and executed in this repository.
+
+## Principles
+
+1. **An open issue is not approved work.** Recording is cheap; executing requires
+   explicit authorization.
+2. **Native structure before textual convention.** The order of preference is
+   native feature > structured field > label > free text. Nothing GitHub already
+   models is re-implemented as a title prefix or a label.
+3. **Each piece of information in one place.** If something has a field, it does
+   not also have a label.
+4. **Capturing an idea is not bureaucratic.** The Idea form has one required
+   field. The cost of recording a thought has to stay near zero.
+
+## Issue types
+
+${typeMechanism}
+
+| Type | What it is | Authorizes execution? |
+|---|---|---|
+${typeRows}
+
+### Choosing the type
+
+In order \u2014 the first "yes" decides:
+
+1. **Is something broken?** \u2192 \`Bug\`, even if the expected behaviour never worked.
+2. **Is the question still unanswered?** \u2192 \`Research\`.
+3. **Is it just a record, with no analysis yet?** \u2192 \`Idea\`.
+4. **Is it large and delivered in parts?** \u2192 \`Epic\`, with sub-issues.
+5. **Does it change what the product does?** \u2192 \`Feature\`.
+6. **None of the above** \u2192 \`Task\`.
+
+### What is deliberately not a type
+
+A type per flavour of work fragments the backlog without improving a single
+query.
+
+| Concept | Represent it as | Why |
+|---|---|---|
+${nonTypeRows}
+
+## Labels
+
+Labels are the last resort, for what has no native representation: technical
+area, component and cross-cutting characteristic.
+
+| Label | Meaning |
+|---|---|
+${labelRows}
+
+**Never use a label for** priority, type, state or size when a field exists for
+it: the label becomes a second truth that ages on its own.
+
+## Branches and commits
+
+- Branch: \`issue/{N}-{slug}\`
+- Commit: ${DEFAULT_COMMIT_CONVENTION}
+
+The commit type must match the nature of the change. A bug fix committed as
+\`feat:\` corrupts the changelog and any version bump derived from the history.
+
+## Pull Requests
+
+Follow \`.github/PULL_REQUEST_TEMPLATE.md\`. Keep every section it defines and
+answer the ones that do not apply with one line saying why \u2014 a deleted section
+reads as an unanswered one to automated review.
+
+Link the issues with one \`Closes #N\` per issue, as plain body text.
+
+## Agent entry points
+
+\`AGENTS.md\` is the canonical entry point for any coding agent, of any vendor.
+It is an index: it says which documents to read, and holds no rule of its own.
+
+\`CLAUDE.md\` exists only as the Claude Code integration and contains a single
+line pointing at \`AGENTS.md\`. Any other agent adapter follows the same rule.
+
+\`\`\`text
+CLAUDE.md  \u2192  AGENTS.md  \u2192  specialized documentation  \u2192  single source of truth
+\`\`\`
+`;
+}
+function renderLabelsFile(includeTypeLabels) {
+  const labels = includeTypeLabels ? [...FALLBACK_TYPE_LABELS, ...DEFAULT_LABELS] : DEFAULT_LABELS;
+  return `${JSON.stringify(
+    labels.map((label) => ({
+      name: label.name,
+      description: label.description,
+      color: label.color
+    })),
+    null,
+    2
+  )}
+`;
+}
+
+// src/scaffold/plan.ts
+function action(path, kind, tier, reason, content) {
+  return content === void 0 ? { path, kind, tier, reason } : { path, kind, tier, reason, content };
+}
+function isClaudeBridge(content) {
+  const meaningful = content.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#"));
+  if (meaningful.length === 0 || meaningful.length > 2) return false;
+  return meaningful.every((line) => /agents\.md/i.test(line));
+}
+async function buildScaffoldPlan(state) {
+  const { policy } = state;
+  const actions = [];
+  const notes = [];
+  const localTemplates = policy.issues.templates.filter((t) => t.origin === "filesystem");
+  const orgTemplates = policy.issues.templates.filter((t) => t.origin === "organization");
+  if (localTemplates.length > 0) {
+    actions.push(
+      action(
+        ".github/ISSUE_TEMPLATE/",
+        "keep",
+        "required",
+        `${localTemplates.length} Issue Template(s) already declared in this repository.`
+      )
+    );
+  } else if (orgTemplates.length > 0) {
+    actions.push(
+      action(
+        ".github/ISSUE_TEMPLATE/",
+        "keep",
+        "required",
+        `The organization serves ${orgTemplates.length} Issue Template(s) to this repository; a local copy would fork them.`
+      )
+    );
+    notes.push(
+      "Issue Templates come from the organization. Change them there, not here \u2014 a local copy stops tracking the original the moment either is edited."
+    );
+  } else {
+    for (const type of DEFAULT_ISSUE_TYPES) {
+      const path = `.github/ISSUE_TEMPLATE/${type.order}-${type.slug}.yml`;
+      actions.push(
+        action(
+          path,
+          "create",
+          "required",
+          `Issue Form for the "${type.name}" type.`,
+          renderIssueForm(type)
+        )
+      );
+    }
+    const configPath = ".github/ISSUE_TEMPLATE/config.yml";
+    actions.push(
+      action(
+        configPath,
+        await state.exists(configPath) ? "keep" : "create",
+        "required",
+        "Template chooser: keeps blank issues enabled and links the conventions.",
+        renderIssueTemplateConfig()
+      )
+    );
+  }
+  if (policy.pullRequests.templates.length > 0) {
+    actions.push(
+      action(
+        policy.pullRequests.templates[0]?.path ?? ".github/PULL_REQUEST_TEMPLATE.md",
+        "keep",
+        "required",
+        "A Pull Request template already exists."
+      )
+    );
+  } else {
+    actions.push(
+      action(
+        ".github/PULL_REQUEST_TEMPLATE.md",
+        "create",
+        "required",
+        "Gives every Pull Request a body that review can rely on.",
+        renderPullRequestTemplate()
+      )
+    );
+  }
+  const agents = policy.docs.find((doc) => doc.kind === "agents" && doc.scope === "");
+  const claude = policy.docs.find((doc) => doc.kind === "claude" && doc.scope === "");
+  const referenced = policy.docs.filter((doc) => doc.kind === "contributing" || doc.kind === "referenced").map((doc) => doc.path);
+  if (agents === void 0) {
+    actions.push(
+      action(
+        "AGENTS.md",
+        "create",
+        "required",
+        "The canonical entry point for any coding agent, as an index of the real documentation.",
+        renderAgentsMd(state.projectName, referenced)
+      )
+    );
+  } else {
+    actions.push(action("AGENTS.md", "keep", "required", "Already the canonical entry point."));
+  }
+  if (claude === void 0) {
+    actions.push(
+      action(
+        "CLAUDE.md",
+        "create",
+        "recommended",
+        "One-line bridge to AGENTS.md, so Claude Code reads the canonical source.",
+        renderClaudeMd()
+      )
+    );
+  } else if (isClaudeBridge(claude.content)) {
+    actions.push(action("CLAUDE.md", "keep", "recommended", "Already a bridge to AGENTS.md."));
+  } else if (agents === void 0) {
+    notes.push(
+      "CLAUDE.md carries its own instructions and there is no AGENTS.md. Move that content into AGENTS.md and reduce CLAUDE.md to the one-line bridge; nothing here rewrites it for you."
+    );
+    actions.push(
+      action(
+        "CLAUDE.md",
+        "review",
+        "recommended",
+        "Holds instructions of its own; AGENTS.md should be the canonical source."
+      )
+    );
+  } else {
+    notes.push(
+      "AGENTS.md and CLAUDE.md both carry instructions. Two copies of the same rules diverge the first time only one is edited \u2014 keep AGENTS.md and reduce CLAUDE.md to the one-line bridge."
+    );
+    actions.push(
+      action(
+        "CLAUDE.md",
+        "review",
+        "recommended",
+        "Duplicates instructions that AGENTS.md already owns."
+      )
+    );
+  }
+  const hasContributing = policy.docs.some((doc) => doc.kind === "contributing");
+  const conventionsPath = "docs/conventions.md";
+  const conventionsExists = await state.exists(conventionsPath);
+  if (conventionsExists) {
+    actions.push(
+      action(conventionsPath, "keep", "recommended", "Conventions are already documented.")
+    );
+  } else if (orgTemplates.length > 0) {
+    actions.push(
+      action(
+        conventionsPath,
+        "keep",
+        "recommended",
+        "The conventions are the organization's; documenting them again here would fork them."
+      )
+    );
+  } else if (hasContributing && localTemplates.length > 0) {
+    actions.push(
+      action(
+        conventionsPath,
+        "keep",
+        "recommended",
+        "CONTRIBUTING.md and the Issue Templates already document how this repository works."
+      )
+    );
+  } else {
+    actions.push(
+      action(
+        conventionsPath,
+        "create",
+        "recommended",
+        "The source of truth for issue types, labels, branches and commits.",
+        renderConventionsDoc(policy.issues.types.length > 0)
+      )
+    );
+  }
+  const labelsPath = ".github/labels.json";
+  if (policy.issues.labels.length > 0) {
+    actions.push(
+      action(
+        labelsPath,
+        "keep",
+        "contextual",
+        `This repository already has ${policy.issues.labels.length} label(s); Issue Flow never rewrites a taxonomy.`
+      )
+    );
+  } else if (await state.exists(labelsPath)) {
+    actions.push(action(labelsPath, "keep", "contextual", "A labels file already exists."));
+  } else {
+    const includeTypeLabels = policy.issues.types.length === 0;
+    actions.push(
+      action(
+        labelsPath,
+        "create",
+        "contextual",
+        includeTypeLabels ? "A baseline label set, including type labels because this organization has no Issue Types." : "A baseline label set. Type labels are omitted: this organization has native Issue Types.",
+        renderLabelsFile(includeTypeLabels)
+      )
+    );
+  }
+  if (policy.issues.types.length === 0) {
+    notes.push(
+      "No GitHub Issue Types were found. They are an organization-level setting and cannot be created from here; defining them there is better than the `type:*` labels this proposes as a fallback."
+    );
+  }
+  return { root: policy.root, actions, notes };
+}
+
+// src/scaffold/apply.ts
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function applyScaffoldPlan(plan) {
+  const written = [];
+  const skipped = [];
+  for (const item of plan.actions) {
+    if (item.kind !== "create" || item.content === void 0) continue;
+    const absolute = join2(plan.root, item.path);
+    if (await exists(absolute)) {
+      skipped.push(item.path);
+      continue;
+    }
+    await mkdir(dirname(absolute), { recursive: true });
+    await writeFile(absolute, item.content, "utf-8");
+    written.push(item.path);
+  }
+  return { written, skipped };
+}
+async function resolveRepositoryState(options = {}) {
+  const root = options.root ?? await getProjectRoot();
+  const policy = await loadRepositoryPolicy({ root, scope: options.scope ?? null });
+  return {
+    policy,
+    projectName: basename(root),
+    exists: (relPath) => exists(join2(root, relPath))
+  };
+}
+async function planRepositoryScaffold(options = {}) {
+  return buildScaffoldPlan(await resolveRepositoryState(options));
+}
+export {
+  applyScaffoldPlan,
+  planRepositoryScaffold,
+  resolveRepositoryState
+};
+//# sourceMappingURL=apply-WUJHDD7A.js.map