pr-prism 1.1.3 → 1.1.6

package/scripts/pr-prism.ts

@@ -0,0 +1,260 @@
+#!/usr/bin/env tsx
+import { execSync, spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineWizard, runWizard } from "grimoire-wizard";
+import { scrapeIssue } from "./lib/scrape-issues.js";
+
+const SCRIPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+const SIDECAR_DIR = "pr-reviews";
+
+function tryDetectRepo(): string | null {
+  try {
+    const remote = execSync("git remote get-url origin", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const m = remote.match(/github\.com[:/]([^/]+)\/([^/\s]+?)(?:\.git)?$/);
+    return m ? `${m[1]}/${m[2]}` : null;
+  } catch {
+    return null;
+  }
+}
+
+interface ThreadsSidecar { prNumber: number; owner: string; repo: string; threadIds: string[]; }
+
+function delegate(script: string, args: string[]): never {
+  const result = spawnSync(
+    join(SCRIPTS_DIR, "node_modules", ".bin", "tsx"),
+    [join(SCRIPTS_DIR, "scripts", script), ...args],
+    { stdio: "inherit" },
+  );
+  process.exit(result.status ?? 1);
+}
+
+const BACK = "__BACK__" as const;
+
+async function prompt(id: string, message: string, options: { value: string; label: string }[], goBackOnEsc = false): Promise<string> {
+  const config = defineWizard({
+    meta: { name: "pr-prism" },
+    steps: [{ id, type: "select" as const, message, options }],
+  });
+  const answers = await runWizard(config, {
+    onCancel: goBackOnEsc ? (() => {}) : (() => process.exit(0)),
+  });
+  const selected = answers?.[id];
+  if (!selected) return goBackOnEsc ? BACK : (process.exit(0), "");
+  return selected as string;
+}
+
+function findSidecars(): { prNumber: number; threadCount: number }[] {
+  if (!existsSync(SIDECAR_DIR)) return [];
+  return readdirSync(SIDECAR_DIR)
+    .filter((f) => f.startsWith(".threads-") && f.endsWith(".json"))
+    .flatMap((f) => {
+      try {
+        const raw = JSON.parse(readFileSync(join(SIDECAR_DIR, f), "utf-8")) as Partial<ThreadsSidecar>;
+        return typeof raw.prNumber === "number" && Array.isArray(raw.threadIds)
+          ? [{ prNumber: raw.prNumber, threadCount: raw.threadIds.length }]
+          : [];
+      } catch {
+        return [];
+      }
+    })
+    .sort((a, b) => b.prNumber - a.prNumber);
+}
+
+async function handleResolveFlow(args: string[], fromMenu = false): Promise<boolean> {
+  if (args.length > 0) { delegate("resolve-pr-threads.ts", args); return true; }
+
+  const sidecars = findSidecars();
+  if (sidecars.length === 0) {
+    delegate("resolve-pr-threads.ts", []);
+    return true;
+  }
+
+  const prChoice = await prompt("pr", "Which PR to resolve threads for?", sidecars.map((s) => ({
+    value: String(s.prNumber),
+    label: `PR #${s.prNumber}  (${s.threadCount} thread${s.threadCount === 1 ? "" : "s"})`,
+  })), fromMenu);
+  if (prChoice === BACK) return false;
+
+  const mode = await prompt("mode", "How do you want to resolve?", [
+    { value: "all", label: "Resolve all scraped threads" },
+    { value: "auto", label: "Smart auto-resolve (outdated + applied suggestions)" },
+    { value: "preview", label: "Dry-run preview (no changes)" },
+    { value: "auto-preview", label: "Smart auto-resolve preview (dry run)" },
+    { value: "unresolve", label: "Re-open resolved threads" },
+  ], true);
+  if (mode === BACK) return false;
+
+  const flags: string[] = [prChoice];
+  if (mode === "auto") flags.push("--auto");
+  if (mode === "preview") flags.push("--dry-run");
+  if (mode === "auto-preview") flags.push("--auto", "--dry-run");
+  if (mode === "unresolve") flags.push("--unresolve");
+
+  delegate("resolve-pr-threads.ts", flags);
+  return true;
+}
+
+async function handleIssueFlow(args: string[], fromMenu = false): Promise<boolean> {
+  const hasPositional = args.some((a, i) => !a.startsWith("--") && args[i - 1] !== "--repo" && args[i - 1] !== "--state");
+  if (hasPositional) { await scrapeIssue(args); return true; }
+
+  const state = await prompt("state", "Which issues to list?", [
+    { value: "open", label: "Open issues" },
+    { value: "closed", label: "Closed issues" },
+    { value: "all", label: "All issues" },
+  ], fromMenu);
+  if (state === BACK) return false;
+
+  const stateArgs = state !== "open" ? ["--state", state] : [];
+  await scrapeIssue([...args, ...stateArgs]);
+  return true;
+}
+
+interface GhRepo { nameWithOwner: string; isPrivate: boolean; description: string; }
+
+function listUserRepos(visibility: "public" | "private"): GhRepo[] {
+  try {
+    const out = execSync(
+      `gh repo list --json nameWithOwner,isPrivate,description --limit 30 --${visibility}`,
+      { encoding: "utf-8", stdio: "pipe" },
+    ).trim();
+    return JSON.parse(out) as GhRepo[];
+  } catch {
+    return [];
+  }
+}
+
+async function selectRepo(): Promise<string | null | typeof BACK> {
+  const detected = tryDetectRepo();
+  const useLabel = detected ? `Use current repo (${detected})` : "Auto-detect from git remote";
+
+  while (true) {
+    const choice = await prompt("repo", "Which repository?", [
+      { value: "current", label: useLabel },
+      { value: "my-public", label: "Pick from my public repos" },
+      { value: "my-private", label: "Pick from my private repos" },
+      { value: "other", label: "Enter owner/repo manually" },
+    ], true);
+    if (choice === BACK) return BACK;
+    if (choice === "current") return null;
+
+    if (choice === "my-public" || choice === "my-private") {
+      const visibility = choice === "my-public" ? "public" : "private";
+      console.log(`\nLoading ${visibility} repos…`);
+      const repos = listUserRepos(visibility);
+      if (repos.length === 0) {
+        console.log(`No ${visibility} repos found.\n`);
+        continue;
+      }
+      const picked = await prompt("pick-repo", `Select a ${visibility} repo:`, repos.map((r) => ({
+        value: r.nameWithOwner,
+        label: `${r.nameWithOwner}${r.description ? "  — " + r.description.slice(0, 60) : ""}`,
+      })), true);
+      if (picked === BACK) continue;
+      return picked;
+    }
+
+    const config = defineWizard({
+      meta: { name: "pr-prism" },
+      steps: [{ id: "repo", type: "text" as const, message: "Enter owner/repo (e.g. facebook/react):" }],
+    });
+    const answers = await runWizard(config, { onCancel: () => {} });
+    const repo = (answers?.repo as string)?.trim();
+    if (!repo) continue;
+    if (!repo.includes("/")) {
+      console.log("Invalid format. Use: owner/repo\n");
+      continue;
+    }
+    return repo;
+  }
+}
+
+async function mainMenu(): Promise<void> {
+  while (true) {
+    const action = await prompt("action", "pr-prism — what do you want to do?", [
+      { value: "pr", label: "Scrape PR reviews" },
+      { value: "issue", label: "Scrape issue comments" },
+      { value: "resolve", label: "Resolve PR review threads" },
+    ]);
+
+    if (action === "resolve") {
+      const done = await handleResolveFlow([], true);
+      if (!done) continue;
+      return;
+    }
+
+    const repoOverride = await selectRepo();
+    if (repoOverride === BACK) continue;
+    const repoArgs = repoOverride ? ["--repo", repoOverride] : [];
+
+    switch (action) {
+      case "pr": delegate("scrape-pr-reviews.ts", repoArgs); break;
+      case "issue": {
+        const done = await handleIssueFlow(repoArgs, true);
+        if (!done) continue;
+        return;
+      }
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const subcommand = args[0];
+  const rest = args.slice(1);
+
+  switch (subcommand) {
+    case "pr":
+      delegate("scrape-pr-reviews.ts", rest);
+      break;
+
+    case "issue":
+      await handleIssueFlow(rest);
+      break;
+
+    case "resolve":
+      await handleResolveFlow(rest);
+      break;
+
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(`
+pr-prism — strip noise from GitHub PRs and issues for LLM agents
+
+USAGE
+  pr-prism                             interactive menu
+  pr-prism pr [number|url]             scrape PR review comments
+  pr-prism issue [number|url]          scrape issue comments
+  pr-prism resolve [number] [flags]    resolve PR review threads
+
+OPTIONS
+  --repo owner/repo     target a different repo (default: auto-detect)
+  --state open|closed   filter issues by state (default: open)
+
+RESOLVE FLAGS
+  --auto                smart auto-resolve (re-fetches live state)
+  --thread PRRT_xxx     resolve specific thread(s) by ID (repeatable)
+  --dry-run             preview without mutating
+  --tag-agents          post @mention comment after resolving
+  --unresolve           re-open resolved threads
+  --comment "…"         attach custom message
+`);
+      break;
+
+    default:
+      if (subcommand?.startsWith("http")) {
+        if (subcommand.includes("/pull/")) {
+          delegate("scrape-pr-reviews.ts", [subcommand, ...rest]);
+        } else {
+          await scrapeIssue([subcommand, ...rest]);
+        }
+        break;
+      }
+      await mainMenu();
+  }
+}
+
+main().catch((err: unknown) => { console.error((err as Error).message); process.exit(1); });

package/scripts/resolve-pr-threads.ts

@@ -11,6 +11,7 @@
  *   pnpm run pr-resolve                        — latest .threads-*.json
  *   pnpm run pr-resolve -- 42                  — explicit PR number
  *   pnpm run pr-resolve -- 42 --auto           — smart auto-resolve (re-fetches from GitHub)
+ *   pnpm run pr-resolve -- 42 --thread PRRT_xxx — resolve specific thread(s)
  *   pnpm run pr-resolve -- 42 --auto --dry-run — preview auto-resolve classifications
  *   pnpm run pr-resolve -- 42 --auto --tag-agents — auto-resolve + tag agents
  *   pnpm run pr-resolve -- 42 --dry-run        — preview without mutating
@@ -133,7 +134,7 @@ function mutateThread(threadId: string, unresolve: boolean): boolean {
   const reqFile = join(tmpdir(), ".pr-resolve-req.json");
   writeFileSync(reqFile, JSON.stringify({ query: mutation, variables: { id: threadId } }), "utf-8");
   try {
-    const result = JSON.parse(run(`gh api https://api.github.com/graphql --input ${reqFile}`));
+    const result = JSON.parse(run(`gh api https://api.github.com/graphql --input "${reqFile}"`));
     const key = unresolve ? "unresolveReviewThread" : "resolveReviewThread";
     return result.data?.[key]?.thread != null;
   } catch {
@@ -157,7 +158,7 @@ function fetchThreadsLive(owner: string, repo: string, prNumber: number): AutoPa
   const reqFile = join(tmpdir(), ".pr-auto-resolve-req.json");
   writeFileSync(reqFile, JSON.stringify({ query: AUTO_GRAPHQL_QUERY, variables: { owner, repo, prNumber } }), "utf-8");
   try {
-    return JSON.parse(run(`gh api https://api.github.com/graphql --input ${reqFile}`)) as AutoPayload;
+    return JSON.parse(run(`gh api https://api.github.com/graphql --input "${reqFile}"`)) as AutoPayload;
   } catch (err) {
     console.error("gh API failed fetching threads. Is gh authenticated?");
     console.error((err as Error).message);
@@ -355,9 +356,30 @@ async function main(): Promise<void> {
   const shouldTag = args.includes("--tag-agents");
   const commentIdx = args.indexOf("--comment");
   const customComment = commentIdx !== -1 ? args[commentIdx + 1] : null;
+  const threadFlags: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--thread") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("--")) {
+        console.error("--thread requires a thread ID. Usage: pr-prism resolve <PR> --thread <THREAD_ID>");
+        process.exit(1);
+      }
+      threadFlags.push(next);
+      i++;
+    }
+  }
   const prArg = args.find((a) => /^\d+$/.test(a));
   const prNumber = prArg != null ? parseInt(prArg, 10) : null;
 
+  if (isAuto && threadFlags.length > 0) {
+    console.error("--auto and --thread are incompatible.");
+    process.exit(1);
+  }
+  if (threadFlags.length > 0 && prNumber === null) {
+    console.error("--thread requires a PR number. Usage: pnpm run pr-resolve -- <PR> --thread <THREAD_ID>");
+    process.exit(1);
+  }
+
   if (isAuto) {
     if (prNumber === null) {
       console.error("--auto requires a PR number. Usage: pnpm run pr-resolve -- <PR> --auto");
@@ -385,20 +407,45 @@ async function main(): Promise<void> {
     return;
   }
 
-  let sidecarPath = findSidecar(prNumber);
-  if (!sidecarPath) {
-    console.log("\n⚡ No sidecar found — running pr-review to generate it…\n");
-    runScrape(prNumber);
-    sidecarPath = findSidecar(prNumber);
+  let owner: string;
+  let repo: string;
+  let threadIds: string[];
+  let resolvedPr: number;
+
+  if (threadFlags.length > 0) {
+    const sidecarPath = findSidecar(prNumber);
+    if (sidecarPath) {
+      const sidecar = JSON.parse(readFileSync(sidecarPath, "utf-8")) as ThreadsSidecar;
+      owner = sidecar.owner;
+      repo = sidecar.repo;
+      resolvedPr = sidecar.prNumber;
+    } else {
+      const remote = run("git remote get-url origin");
+      const m = remote.match(/github\.com[:/]([^/]+)\/([^/\s.]+)/);
+      if (!m) { console.error("Could not detect GitHub repo."); process.exit(1); }
+      owner = m[1];
+      repo = m[2].replace(/\.git$/, "");
+      resolvedPr = prNumber ?? 0;
+    }
+    threadIds = threadFlags;
+  } else {
+    let sidecarPath = findSidecar(prNumber);
     if (!sidecarPath) {
-      console.log("ℹ️  pr-review ran but found no inline review threads to resolve.");
-      process.exit(0);
+      console.log("\n⚡ No sidecar found — running pr-review to generate it…\n");
+      runScrape(prNumber);
+      sidecarPath = findSidecar(prNumber);
+      if (!sidecarPath) {
+        console.log("ℹ️  pr-review ran but found no inline review threads to resolve.");
+        process.exit(0);
+      }
     }
+    const sidecar = JSON.parse(readFileSync(sidecarPath, "utf-8")) as ThreadsSidecar;
+    threadIds = sidecar.threadIds;
+    owner = sidecar.owner;
+    repo = sidecar.repo;
+    resolvedPr = sidecar.prNumber;
   }
 
-  const sidecar = JSON.parse(readFileSync(sidecarPath, "utf-8")) as ThreadsSidecar;
-  const { threadIds, owner, repo } = sidecar;
-  const resolvedPr = sidecar.prNumber;
   const action = isUnresolve ? "Unresolve" : "Resolve";
 
   console.log(`\n${action} ${threadIds.length} thread(s) in ${owner}/${repo} #${resolvedPr}${isDryRun ? " [DRY RUN]" : ""}\n`);

package/scripts/scrape-pr-reviews.ts

@@ -21,8 +21,8 @@ import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync } from "
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { defineWizard, runWizard } from "grimoire-wizard";
+import { isBot, stripNoise, renderSuggestions, formatTokenSummary } from "./lib/sanitize.js";
 
-const KNOWN_BOTS = ["github-actions", "dependabot", "coderabbitai", "changeset-bot", "codeantai"];
 const OUT_DIR = "pr-reviews";
 const CACHE_FILE = join(OUT_DIR, ".scraped-ids.json");
 
@@ -62,9 +62,9 @@ function run(cmd: string): string {
 function detectRepo(): { owner: string; repo: string } {
   try {
     const remote = run("git remote get-url origin");
-    const m = remote.match(/github\.com[:/]([^/]+)\/([^/\s.]+)/);
+    const m = remote.match(/github\.com[:/]([^/]+)\/([^/\s]+?)(?:\.git)?$/);
     if (!m) throw new Error();
-    return { owner: m[1], repo: m[2].replace(/\.git$/, "") };
+    return { owner: m[1], repo: m[2] };
   } catch {
     console.error("❌ Could not detect GitHub repo. Run from a GitHub repo or pass a URL.");
     process.exit(1);
@@ -113,7 +113,7 @@ function fetchPr(owner: string, repo: string, prNumber: number): PrPayload {
   const reqFile = join(tmpdir(), ".pr-review-req.json");
   writeFileSync(reqFile, JSON.stringify({ query: GRAPHQL_QUERY, variables: { owner, repo, prNumber } }), "utf-8");
   try {
-    return JSON.parse(run(`gh api https://api.github.com/graphql --input ${reqFile}`)) as PrPayload;
+    return JSON.parse(run(`gh api https://api.github.com/graphql --input "${reqFile}"`)) as PrPayload;
   } catch (err) {
     console.error("❌ gh API failed. Is gh authenticated? Run: gh auth login");
     console.error((err as Error).message);
@@ -128,42 +128,20 @@ function loadCache(): Set<string> {
   try { return new Set((JSON.parse(readFileSync(CACHE_FILE, "utf-8")) as IdCache).seen); } catch { return new Set(); }
 }
 function saveCache(seen: Set<string>): void { writeFileSync(CACHE_FILE, JSON.stringify({ seen: [...seen] }, null, 2), "utf-8"); }
-function isBot(login: string): boolean { const l = login.toLowerCase(); return l.endsWith("[bot]") || KNOWN_BOTS.some((b) => l.includes(b)); }
-
-const NOISE_DOMAINS = [
-  "twitter.com/intent", "x.com/intent",
-  "reddit.com/submit",
-  "linkedin.com/sharing",
-  "app.codeant.ai", "codeant.ai/feedback",
-];
-
-function stripNoise(body: string): string {
-  return body
-    .replace(/<a\s[^>]*href=['"]([^'"]+)['"][^>]*>[\s\S]*?<\/a>/gi, (match, url: string) =>
-      NOISE_DOMAINS.some((d) => url.includes(d)) ? "" : match,
-    )
-    .replace(/\[([^\]]*)\]\((https?:\/\/[^)]+)\)/g, (match, _text, url: string) =>
-      NOISE_DOMAINS.some((d) => url.includes(d)) ? "" : match,
-    )
-    .replace(/^[\s·|—\-]+$/gm, "")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
 
-function renderSuggestions(body: string): string {
-  return body.replace(/```suggestion\n([\s\S]*?)```/g, (_, code: string) => {
-    const lines = code.trimEnd().split("\n").map((l: string) => `+ ${l}`).join("\n");
-    return `\n**SUGGESTED CHANGE:**\n\`\`\`diff\n${lines}\n\`\`\`\n`;
-  });
-}
 
-function appendComment(out: string, c: GhComment, prefix: string, threadId?: string): string {
+
+interface AppendResult { text: string; rawChars: number; cleanedChars: number; }
+
+function appendComment(out: string, c: GhComment, prefix: string, threadId?: string): AppendResult {
+  const rawChars = c.body.length;
   const body = renderSuggestions(stripNoise(c.body)).trim();
-  if (!body) return out;
+  if (!body) return { text: out, rawChars, cleanedChars: 0 };
   const meta = threadId
     ? `thread \`${threadId}\` · \`#${c.databaseId}\``
     : `\`#${c.databaseId}\``;
-  return out + prefix + `## 💬 **${c.author.login}** · ${meta}\n\n${body}\n\n---\n\n`;
+  const appended = prefix + `${c.author.login} ${meta}\n${body}\n\n---\n\n`;
+  return { text: out + appended, rawChars, cleanedChars: body.length };
 }
 
 function ensureGitignore(): void {
@@ -190,17 +168,28 @@ function ensureGitignore(): void {
   console.log("📝 Appended pr-reviews output entries to .gitignore");
 }
 
+function parseRepoFlag(args: string[]): { owner: string; repo: string } | null {
+  const idx = args.indexOf("--repo");
+  if (idx === -1 || !args[idx + 1]) return null;
+  const parts = args[idx + 1].split("/");
+  if (parts.length !== 2) return null;
+  return { owner: parts[0], repo: parts[1] };
+}
+
 async function main(): Promise<void> {
-  const arg = process.argv[2];
+  const args = process.argv.slice(2);
+  const repoFlag = parseRepoFlag(args);
+  const positional = args.filter((a, i) => a !== "--repo" && args[i - 1] !== "--repo");
+  const arg = positional[0];
   let owner: string, repo: string, prNumber: number;
 
   if (arg?.startsWith("http")) {
     ({ owner, repo, prNumber } = parsePrUrl(arg));
   } else if (arg && /^\d+$/.test(arg)) {
-    ({ owner, repo } = detectRepo());
+    ({ owner, repo } = repoFlag ?? detectRepo());
     prNumber = parseInt(arg, 10);
   } else {
-    ({ owner, repo } = detectRepo());
+    ({ owner, repo } = repoFlag ?? detectRepo());
     const prs = listOpenPrs(owner, repo);
     console.log(`\nFound ${prs.length} open PR(s) in ${owner}/${repo}\n`);
     prNumber = await selectPr(prs);
@@ -212,8 +201,11 @@ async function main(): Promise<void> {
   mkdirSync(OUT_DIR, { recursive: true });
   ensureGitignore();
   const cache = loadCache();
-  let output = `# PR Review — ${owner}/${repo} #${prNumber}\n\n`;
+  const header = `PR #${prNumber} -- ${owner}/${repo}\n\n`;
+  let body = "";
   let count = 0;
+  let totalRawChars = 0;
+  let totalCleanedChars = 0;
   const emittedThreadIds: string[] = [];
 
   for (const thread of pr.reviewThreads.nodes) {
@@ -222,9 +214,13 @@ async function main(): Promise<void> {
       const key = String(c.databaseId);
       if (thread.isResolved || isBot(c.author.login)) { cache.add(key); continue; }
       if (cache.has(key)) continue;
-      const filePrefix = c.path ? `### 📄 File: \`${c.path}\`\n\n` : "";
-      const outdatedPrefix = thread.isOutdated ? `### ⚠️ OUTDATED / SUPERSEDED\n\n` : "";
-      output = appendComment(output, c, filePrefix + outdatedPrefix, firstInThread ? thread.id : undefined);
+      const filePrefix = c.path ? `[${c.path}] ` : "";
+      const outdatedPrefix = thread.isOutdated ? "[OUTDATED] " : "";
+      const result = appendComment(body, c, filePrefix + outdatedPrefix, firstInThread ? thread.id : undefined);
+      if (result.cleanedChars === 0) { cache.add(key); continue; }
+      body = result.text;
+      totalRawChars += result.rawChars;
+      totalCleanedChars += result.cleanedChars;
       cache.add(key); count++;
       if (firstInThread) { emittedThreadIds.push(thread.id); firstInThread = false; }
     }
@@ -234,10 +230,19 @@ async function main(): Promise<void> {
     const key = String(c.databaseId);
     if (isBot(c.author.login) || !c.body.trim()) { cache.add(key); continue; }
     if (cache.has(key)) continue;
-    output = appendComment(output, c, "");
+    const result = appendComment(body, c, "");
+    if (result.cleanedChars === 0) { cache.add(key); continue; }
+    body = result.text;
+    totalRawChars += result.rawChars;
+    totalCleanedChars += result.cleanedChars;
     cache.add(key); count++;
   }
 
+  const tokenSummary = count > 0
+    ? formatTokenSummary(totalRawChars, totalCleanedChars) + "\n\n"
+    : "";
+  const output = header + tokenSummary + body;
+
   saveCache(cache);
   const outFile = join(OUT_DIR, `new-${new Date().toISOString().replace(/[:.]/g, "-")}.md`);
   writeFileSync(outFile, output, "utf-8");

package/.github/workflows/release.yml

@@ -1,123 +0,0 @@
-# Automated Release Workflow
-# ─────────────────────────
-# Bumps version, creates Git tag, and publishes a GitHub Release
-# when a PR is merged into `main`.
-#
-# Version bump is determined by PR labels:
-#   - `major` → breaking changes (1.0.0 → 2.0.0)
-#   - `minor` → new features    (1.0.0 → 1.1.0)
-#   - `patch` → bug fixes       (1.0.0 → 1.0.1)  [default]
-#   - `no-release` → skip entirely
-#
-# Template Note:
-#   - Ensure labels `major`, `minor`, `patch`, `no-release` exist in your repo
-#   - For npm publish: uncomment the publish step and add NPM_TOKEN secret
-#   - Works with dev → main merge flow out of the box
-#   - GITHUB_TOKEN won't trigger downstream workflows; use a PAT if needed
-
-name: Release
-
-on:
-  pull_request:
-    types: [closed]
-    branches: [main]
-
-jobs:
-  release:
-    if: >
-      github.event.pull_request.merged == true &&
-      !contains(github.event.pull_request.labels.*.name, 'no-release')
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          ref: main
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-
-      - name: Configure Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Determine version bump
-        id: bump
-        env:
-          LABELS: ${{ toJson(github.event.pull_request.labels.*.name) }}
-        run: |
-          if echo "$LABELS" | grep -q '"major"'; then
-            echo "type=major" >> "$GITHUB_OUTPUT"
-          elif echo "$LABELS" | grep -q '"minor"'; then
-            echo "type=minor" >> "$GITHUB_OUTPUT"
-          else
-            echo "type=patch" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Bump version in package.json
-        id: version
-        run: |
-          if ! node -e "const p = require('./package.json'); if (!p.version) process.exit(1);" 2>/dev/null; then
-            echo "No version found in package.json — initializing to 0.1.0"
-            npm pkg set version=0.1.0
-          fi
-          NEW_VERSION=$(npm version ${{ steps.bump.outputs.type }} --no-git-tag-version)
-          echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-          echo "Bumped to $NEW_VERSION (${{ steps.bump.outputs.type }})"
-
-      - name: Build release notes from commits
-        id: notes
-        env:
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_URL: ${{ github.event.pull_request.html_url }}
-          BUMP_TYPE: ${{ steps.bump.outputs.type }}
-        run: |
-          PREV_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
-          if [ -n "$PREV_TAG" ]; then
-            COMMITS=$(git log "$PREV_TAG"..HEAD --pretty=format:"- %s (%h)" --no-merges)
-          else
-            COMMITS=$(git log --pretty=format:"- %s (%h)" --no-merges -20)
-          fi
-
-          {
-            echo "body<<RELEASE_EOF"
-            echo "## What Changed"
-            echo ""
-            echo "**PR:** [#${PR_NUMBER} — ${PR_TITLE}](${PR_URL})"
-            echo "**Bump:** \`${BUMP_TYPE}\`"
-            echo ""
-            echo "### Commits"
-            echo ""
-            echo "$COMMITS"
-            echo ""
-            echo "RELEASE_EOF"
-          } >> "$GITHUB_OUTPUT"
-
-      - name: Commit version bump and create tag
-        run: |
-          git add package.json package-lock.json 2>/dev/null || git add package.json
-          git commit -m "chore(release): ${{ steps.version.outputs.version }}"
-          git tag -a "${{ steps.version.outputs.version }}" \
-            -m "Release ${{ steps.version.outputs.version }} — ${{ github.event.pull_request.title }}"
-          git push origin main --follow-tags
-
-      - name: Create GitHub Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAG: ${{ steps.version.outputs.version }}
-        run: |
-          gh release create "$TAG" \
-            --title "$TAG — ${{ github.event.pull_request.title }}" \
-            --notes "${{ steps.notes.outputs.body }}" \
-            --latest
-
-      # npm publish is handled by publish.yml (triggered by the tag created above)