@snipcodeit/mgw 0.1.3 → 0.2.1

package/dist/index-CXfe9U4l.cjs

@@ -0,0 +1,1818 @@
+'use strict';
+
+var require$$0 = require('fs');
+var require$$1 = require('path');
+var require$$0$1 = require('child_process');
+var require$$0$2 = require('events');
+
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+var state;
+var hasRequiredState;
+
+function requireState () {
+	if (hasRequiredState) return state;
+	hasRequiredState = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	function getMgwDir() {
+	  return path.join(process.cwd(), ".mgw");
+	}
+	function getActiveDir() {
+	  return path.join(getMgwDir(), "active");
+	}
+	function getCompletedDir() {
+	  return path.join(getMgwDir(), "completed");
+	}
+	function loadProjectState() {
+	  const filePath = path.join(getMgwDir(), "project.json");
+	  try {
+	    const raw = fs.readFileSync(filePath, "utf-8");
+	    return JSON.parse(raw);
+	  } catch {
+	    return null;
+	  }
+	}
+	function writeProjectState(state) {
+	  const mgwDir = getMgwDir();
+	  if (!fs.existsSync(mgwDir)) {
+	    fs.mkdirSync(mgwDir, { recursive: true });
+	  }
+	  const filePath = path.join(mgwDir, "project.json");
+	  fs.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+	}
+	function loadActiveIssue(number) {
+	  const activeDir = getActiveDir();
+	  if (!fs.existsSync(activeDir)) {
+	    return null;
+	  }
+	  const prefix = String(number) + "-";
+	  let entries;
+	  try {
+	    entries = fs.readdirSync(activeDir);
+	  } catch {
+	    return null;
+	  }
+	  const match = entries.find(
+	    (f) => f.startsWith(prefix) && f.endsWith(".json")
+	  );
+	  if (!match) return null;
+	  try {
+	    const raw = fs.readFileSync(path.join(activeDir, match), "utf-8");
+	    return JSON.parse(raw);
+	  } catch {
+	    return null;
+	  }
+	}
+	function mergeProjectState(newMilestones, newPhaseMap, newCurrentMilestone, activeGsdMilestone) {
+	  const existing = loadProjectState();
+	  if (!existing) {
+	    throw new Error("No existing project state found. Cannot merge without a project.json.");
+	  }
+	  existing.milestones = (existing.milestones || []).concat(newMilestones);
+	  existing.phase_map = Object.assign({}, newPhaseMap, existing.phase_map);
+	  if (activeGsdMilestone !== void 0 && activeGsdMilestone !== null) {
+	    existing.active_gsd_milestone = activeGsdMilestone;
+	  } else {
+	    if (!existing.active_gsd_milestone) {
+	      existing.current_milestone = newCurrentMilestone;
+	    }
+	  }
+	  writeProjectState(existing);
+	  return existing;
+	}
+	function migrateProjectState() {
+	  const existing = loadProjectState();
+	  if (!existing) return null;
+	  let changed = false;
+	  if (!existing.hasOwnProperty("active_gsd_milestone")) {
+	    existing.active_gsd_milestone = null;
+	    changed = true;
+	  }
+	  for (const m of existing.milestones || []) {
+	    if (!m.hasOwnProperty("gsd_milestone_id")) {
+	      m.gsd_milestone_id = null;
+	      changed = true;
+	    }
+	    if (!m.hasOwnProperty("gsd_state")) {
+	      m.gsd_state = null;
+	      changed = true;
+	    }
+	    if (!m.hasOwnProperty("roadmap_archived_at")) {
+	      m.roadmap_archived_at = null;
+	      changed = true;
+	    }
+	  }
+	  if (changed) {
+	    writeProjectState(existing);
+	  }
+	  const activeDir = getActiveDir();
+	  if (fs.existsSync(activeDir)) {
+	    let entries;
+	    try {
+	      entries = fs.readdirSync(activeDir);
+	    } catch {
+	      entries = [];
+	    }
+	    for (const file of entries) {
+	      if (!file.endsWith(".json")) continue;
+	      const filePath = path.join(activeDir, file);
+	      let issueState;
+	      try {
+	        issueState = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	      } catch {
+	        continue;
+	      }
+	      let issueChanged = false;
+	      if (!issueState.hasOwnProperty("retry_count")) {
+	        issueState.retry_count = 0;
+	        issueChanged = true;
+	      }
+	      if (!issueState.hasOwnProperty("dead_letter")) {
+	        issueState.dead_letter = false;
+	        issueChanged = true;
+	      }
+	      if (issueChanged) {
+	        try {
+	          fs.writeFileSync(filePath, JSON.stringify(issueState, null, 2), "utf-8");
+	        } catch {
+	        }
+	      }
+	    }
+	  }
+	  return existing;
+	}
+	function resolveActiveMilestoneIndex(state) {
+	  if (!state) return -1;
+	  if (state.active_gsd_milestone) {
+	    const idx = (state.milestones || []).findIndex(
+	      (m) => m.gsd_milestone_id === state.active_gsd_milestone
+	    );
+	    return idx;
+	  }
+	  if (typeof state.current_milestone === "number") {
+	    return state.current_milestone - 1;
+	  }
+	  return -1;
+	}
+	state = {
+	  getMgwDir,
+	  getActiveDir,
+	  getCompletedDir,
+	  loadProjectState,
+	  writeProjectState,
+	  loadActiveIssue,
+	  mergeProjectState,
+	  migrateProjectState,
+	  resolveActiveMilestoneIndex
+	};
+	return state;
+}
+
+var github;
+var hasRequiredGithub;
+
+function requireGithub () {
+	if (hasRequiredGithub) return github;
+	hasRequiredGithub = 1;
+	const { execSync } = require$$0$1;
+	function run(cmd) {
+	  return execSync(cmd, {
+	    encoding: "utf-8",
+	    stdio: ["pipe", "pipe", "pipe"]
+	  }).trim();
+	}
+	function getRepo() {
+	  return run("gh repo view --json nameWithOwner -q .nameWithOwner");
+	}
+	function getIssue(number) {
+	  const raw = run(
+	    `gh issue view ${number} --json number,title,state,labels,milestone,assignees,body`
+	  );
+	  return JSON.parse(raw);
+	}
+	function listIssues(filters) {
+	  const f = filters || {};
+	  let cmd = "gh issue list --json number,title,state,labels,milestone,assignees,createdAt,url,body,comments";
+	  if (f.label) cmd += ` --label ${JSON.stringify(f.label)}`;
+	  if (f.milestone) cmd += ` --milestone ${JSON.stringify(f.milestone)}`;
+	  if (f.assignee && f.assignee !== "all") cmd += ` --assignee ${JSON.stringify(f.assignee)}`;
+	  if (f.state) cmd += ` --state ${f.state}`;
+	  if (f.limit) cmd += ` --limit ${parseInt(f.limit, 10)}`;
+	  const raw = run(cmd);
+	  return JSON.parse(raw);
+	}
+	function getMilestone(number) {
+	  const repo = getRepo();
+	  const raw = run(`gh api repos/${repo}/milestones/${number}`);
+	  return JSON.parse(raw);
+	}
+	function getRateLimit() {
+	  const raw = run("gh api rate_limit");
+	  const data = JSON.parse(raw);
+	  const core = data.resources.core;
+	  return {
+	    remaining: core.remaining,
+	    limit: core.limit,
+	    reset: core.reset
+	  };
+	}
+	function closeMilestone(repo, number) {
+	  const raw = run(
+	    `gh api repos/${repo}/milestones/${number} --method PATCH -f state=closed`
+	  );
+	  return JSON.parse(raw);
+	}
+	function createRelease(repo, tag, title, opts) {
+	  const o = opts || {};
+	  let cmd = `gh release create ${JSON.stringify(tag)} --repo ${JSON.stringify(repo)} --title ${JSON.stringify(title)}`;
+	  if (o.notes) cmd += ` --notes ${JSON.stringify(o.notes)}`;
+	  if (o.draft) cmd += " --draft";
+	  if (o.prerelease) cmd += " --prerelease";
+	  return run(cmd);
+	}
+	function getProjectNodeId(owner, projectNumber) {
+	  const userQuery = `'query($login: String!, $number: Int!) { user(login: $login) { projectV2(number: $number) { id } } }'`;
+	  const orgQuery = `'query($login: String!, $number: Int!) { organization(login: $login) { projectV2(number: $number) { id } } }'`;
+	  try {
+	    const raw = run(
+	      `gh api graphql -f query=${userQuery} -f login=${JSON.stringify(owner)} -F number=${projectNumber} --jq '.data.user.projectV2.id'`
+	    );
+	    if (raw && raw !== "null") return raw;
+	  } catch (_) {
+	  }
+	  try {
+	    const raw = run(
+	      `gh api graphql -f query=${orgQuery} -f login=${JSON.stringify(owner)} -F number=${projectNumber} --jq '.data.organization.projectV2.id'`
+	    );
+	    if (raw && raw !== "null") return raw;
+	  } catch (_) {
+	  }
+	  return null;
+	}
+	function findExistingBoard(owner, titlePattern) {
+	  const pattern = titlePattern.toLowerCase();
+	  try {
+	    const raw = run(
+	      `gh api graphql -f query='query($login: String!) { user(login: $login) { projectsV2(first: 20) { nodes { id number url title } } } }' -f login=${JSON.stringify(owner)} --jq '.data.user.projectsV2.nodes'`
+	    );
+	    const nodes = JSON.parse(raw);
+	    const match = nodes.find((n) => n.title.toLowerCase().includes(pattern));
+	    if (match) return { number: match.number, url: match.url, nodeId: match.id, title: match.title };
+	  } catch (_) {
+	  }
+	  try {
+	    const raw = run(
+	      `gh api graphql -f query='query($login: String!) { organization(login: $login) { projectsV2(first: 20) { nodes { id number url title } } } }' -f login=${JSON.stringify(owner)} --jq '.data.organization.projectsV2.nodes'`
+	    );
+	    const nodes = JSON.parse(raw);
+	    const match = nodes.find((n) => n.title.toLowerCase().includes(pattern));
+	    if (match) return { number: match.number, url: match.url, nodeId: match.id, title: match.title };
+	  } catch (_) {
+	  }
+	  return null;
+	}
+	function getProjectFields(owner, projectNumber) {
+	  const query = `'query($login: String!, $number: Int!) { user(login: $login) { projectV2(number: $number) { fields(first: 20) { nodes { ... on ProjectV2SingleSelectField { id name options { id name } } ... on ProjectV2Field { id name dataType } } } } } }'`;
+	  const orgQuery = `'query($login: String!, $number: Int!) { organization(login: $login) { projectV2(number: $number) { fields(first: 20) { nodes { ... on ProjectV2SingleSelectField { id name options { id name } } ... on ProjectV2Field { id name dataType } } } } } }'`;
+	  let raw;
+	  try {
+	    raw = run(`gh api graphql -f query=${query} -f login=${JSON.stringify(owner)} -F number=${projectNumber} --jq '.data.user.projectV2.fields.nodes'`);
+	  } catch (_) {
+	    try {
+	      raw = run(`gh api graphql -f query=${orgQuery} -f login=${JSON.stringify(owner)} -F number=${projectNumber} --jq '.data.organization.projectV2.fields.nodes'`);
+	    } catch (_2) {
+	      return null;
+	    }
+	  }
+	  const nodes = JSON.parse(raw);
+	  const fields = {};
+	  const statusNode = nodes.find((n) => n.name === "Status" && n.options);
+	  if (statusNode) {
+	    const stageMap = {
+	      "new": "New",
+	      "triaged": "Triaged",
+	      "needs-info": "Needs Info",
+	      "needs-security-review": "Needs Security Review",
+	      "discussing": "Discussing",
+	      "approved": "Approved",
+	      "planning": "Planning",
+	      "executing": "Executing",
+	      "verifying": "Verifying",
+	      "pr-created": "PR Created",
+	      "done": "Done",
+	      "failed": "Failed",
+	      "blocked": "Blocked"
+	    };
+	    const nameToId = Object.fromEntries(statusNode.options.map((o) => [o.name, o.id]));
+	    fields.status = {
+	      field_id: statusNode.id,
+	      field_name: "Status",
+	      type: "SINGLE_SELECT",
+	      options: Object.fromEntries(
+	        Object.entries(stageMap).map(([stage, label]) => [stage, nameToId[label] || ""])
+	      )
+	    };
+	  }
+	  const aiNode = nodes.find((n) => n.name === "AI Agent State" && !n.options);
+	  if (aiNode) {
+	    fields.ai_agent_state = { field_id: aiNode.id, field_name: "AI Agent State", type: "TEXT" };
+	  }
+	  const phaseNode = nodes.find((n) => n.name === "Phase" && !n.options);
+	  if (phaseNode) {
+	    fields.phase = { field_id: phaseNode.id, field_name: "Phase", type: "TEXT" };
+	  }
+	  const routeNode = nodes.find((n) => n.name === "GSD Route" && n.options);
+	  if (routeNode) {
+	    const routeMap = {
+	      "gsd:quick": "quick",
+	      "gsd:quick --full": "quick --full",
+	      "gsd:plan-phase": "plan-phase",
+	      "gsd:new-milestone": "new-milestone"
+	    };
+	    const nameToId = Object.fromEntries(routeNode.options.map((o) => [o.name, o.id]));
+	    fields.gsd_route = {
+	      field_id: routeNode.id,
+	      field_name: "GSD Route",
+	      type: "SINGLE_SELECT",
+	      options: Object.fromEntries(
+	        Object.entries(routeMap).map(([route, label]) => [route, nameToId[label] || ""])
+	      )
+	    };
+	  }
+	  const milestoneNode = nodes.find((n) => n.name === "Milestone");
+	  if (milestoneNode) {
+	    fields.milestone = {
+	      field_id: milestoneNode.id,
+	      field_name: "Milestone",
+	      type: milestoneNode.dataType || (milestoneNode.options ? "SINGLE_SELECT" : "TEXT")
+	    };
+	  }
+	  return Object.keys(fields).length > 0 ? fields : null;
+	}
+	function createProject(owner, title) {
+	  const raw = run(
+	    `gh project create --owner ${JSON.stringify(owner)} --title ${JSON.stringify(title)} --format json`
+	  );
+	  const data = JSON.parse(raw);
+	  return { number: data.number, url: data.url };
+	}
+	function addItemToProject(owner, projectNumber, issueUrl) {
+	  return run(
+	    `gh project item-add ${projectNumber} --owner ${JSON.stringify(owner)} --url ${JSON.stringify(issueUrl)}`
+	  );
+	}
+	function postMilestoneStartAnnouncement(opts) {
+	  const {
+	    repo,
+	    milestoneName,
+	    boardUrl,
+	    issues,
+	    firstIssueNumber
+	  } = opts;
+	  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	  const issueList = Array.isArray(issues) ? issues : [];
+	  const issueRows = issueList.map((i) => {
+	    const assignee = i.assignee ? `@${i.assignee}` : "\u2014";
+	    return `| #${i.number} | ${i.title} | ${assignee} | \`${i.gsdRoute}\` |`;
+	  }).join("\n");
+	  const boardLine = boardUrl ? `**Board:** ${boardUrl}` : "**Board:** _(not configured)_";
+	  const body = [
+	    `> **MGW** \xB7 \`milestone-started\` \xB7 ${timestamp}`,
+	    "",
+	    `## Milestone Execution Started: ${milestoneName}`,
+	    "",
+	    boardLine,
+	    "",
+	    "### Issues in This Milestone",
+	    "",
+	    "| # | Title | Assignee | Route |",
+	    "|---|-------|----------|-------|",
+	    issueRows,
+	    "",
+	    `**${issueList.length} issue(s)** queued for autonomous execution. PRs will be posted on each issue as they complete.`,
+	    "",
+	    "---",
+	    "*Auto-posted by MGW milestone orchestration*"
+	  ].join("\n");
+	  const title = `[MGW] Milestone Started: ${milestoneName}`;
+	  if (repo) {
+	    try {
+	      const [owner, repoName] = repo.split("/");
+	      const repoMetaRaw = run(
+	        `gh api graphql -f query='query { repository(owner: "${owner}", name: "${repoName}") { id discussionCategories(first: 20) { nodes { id name } } } }' --jq '.data.repository'`
+	      );
+	      const repoMeta = JSON.parse(repoMetaRaw);
+	      const categories = repoMeta.discussionCategories && repoMeta.discussionCategories.nodes || [];
+	      const announcements = categories.find((c) => c.name === "Announcements");
+	      if (announcements) {
+	        const repoId = repoMeta.id;
+	        const categoryId = announcements.id;
+	        const bodyEscaped = JSON.stringify(body);
+	        const titleEscaped = JSON.stringify(title);
+	        const resultRaw = run(
+	          `gh api graphql -f query='mutation { createDiscussion(input: { repositoryId: ${JSON.stringify(repoId)}, categoryId: ${JSON.stringify(categoryId)}, title: ${titleEscaped}, body: ${bodyEscaped} }) { discussion { url } } }' --jq '.data.createDiscussion.discussion'`
+	        );
+	        const result = JSON.parse(resultRaw);
+	        if (result && result.url) {
+	          return { posted: true, method: "discussion", url: result.url };
+	        }
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (firstIssueNumber && repo) {
+	    try {
+	      run(
+	        `gh issue comment ${firstIssueNumber} --repo ${JSON.stringify(repo)} --body ${JSON.stringify(body)}`
+	      );
+	      return { posted: true, method: "comment", url: null };
+	    } catch (_) {
+	    }
+	  }
+	  return { posted: false, method: "none", url: null };
+	}
+	github = {
+	  getRepo,
+	  getIssue,
+	  listIssues,
+	  getMilestone,
+	  getRateLimit,
+	  closeMilestone,
+	  createRelease,
+	  getProjectNodeId,
+	  findExistingBoard,
+	  getProjectFields,
+	  createProject,
+	  addItemToProject,
+	  postMilestoneStartAnnouncement
+	};
+	return github;
+}
+
+var output;
+var hasRequiredOutput;
+
+function requireOutput () {
+	if (hasRequiredOutput) return output;
+	hasRequiredOutput = 1;
+	const IS_TTY = process.stdout.isTTY === true;
+	const IS_CI = Boolean(process.env.CI);
+	const USE_COLOR = IS_TTY && !IS_CI && !process.env.NO_COLOR;
+	const COLORS = {
+	  reset: "\x1B[0m",
+	  red: "\x1B[31m",
+	  green: "\x1B[32m",
+	  yellow: "\x1B[33m",
+	  blue: "\x1B[34m",
+	  cyan: "\x1B[36m",
+	  bold: "\x1B[1m",
+	  dim: "\x1B[2m"
+	};
+	function colorize(text, colorCode) {
+	  if (!USE_COLOR) return text;
+	  return `${colorCode}${text}${COLORS.reset}`;
+	}
+	function statusLine(icon, message) {
+	  if (USE_COLOR) {
+	    return `${icon} ${message}`;
+	  }
+	  return message;
+	}
+	function log(message) {
+	  console.log(message);
+	}
+	function error(message) {
+	  const prefix = colorize("error:", COLORS.red);
+	  console.error(`${prefix} ${message}`);
+	}
+	function verbose(message, opts) {
+	  if (opts && (opts.verbose || opts.debug)) {
+	    console.log(colorize(`  ${message}`, COLORS.dim));
+	  }
+	}
+	function debug(message, opts) {
+	  if (opts && opts.debug) {
+	    console.log(colorize(`[debug] ${message}`, COLORS.dim));
+	  }
+	}
+	function formatJson(data) {
+	  return JSON.stringify(data, null, 2);
+	}
+	output = {
+	  IS_TTY,
+	  IS_CI,
+	  USE_COLOR,
+	  COLORS,
+	  colorize,
+	  statusLine,
+	  log,
+	  error,
+	  verbose,
+	  debug,
+	  formatJson
+	};
+	return output;
+}
+
+var claude;
+var hasRequiredClaude;
+
+function requireClaude () {
+	if (hasRequiredClaude) return claude;
+	hasRequiredClaude = 1;
+	const { execSync, spawn } = require$$0$1;
+	const path = require$$1;
+	const fs = require$$0;
+	function getCommandsDir() {
+	  const dir = path.join(__dirname, "..", "commands");
+	  if (!fs.existsSync(dir)) {
+	    throw new Error(
+	      `Commands directory not found at: ${dir}
+This may indicate a corrupted installation. Try reinstalling mgw.`
+	    );
+	  }
+	  return dir;
+	}
+	function assertClaudeAvailable() {
+	  try {
+	    execSync("claude --version", {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"]
+	    });
+	  } catch (err) {
+	    if (err.code === "ENOENT") {
+	      console.error(
+	        "Error: claude CLI is not installed.\n\nInstall it with:\n  npm install -g @anthropic-ai/claude-code\n\nThen run:\n  claude login"
+	      );
+	    } else {
+	      console.error(
+	        "Error: claude CLI check failed.\nEnsure claude is installed and on your PATH."
+	      );
+	    }
+	    process.exit(1);
+	  }
+	  try {
+	    execSync("claude auth status", {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"]
+	    });
+	  } catch {
+	    console.error(
+	      "Error: claude CLI is not authenticated.\n\nRun:\n  claude login\n\nThen retry your command."
+	    );
+	    process.exit(1);
+	  }
+	}
+	function invokeClaude(commandFile, userPrompt, opts) {
+	  const o = opts || {};
+	  const args = ["-p"];
+	  if (commandFile) {
+	    args.push("--system-prompt-file", commandFile);
+	  }
+	  if (o.model) {
+	    args.push("--model", o.model);
+	  }
+	  if (o.json) {
+	    args.push("--output-format", "json");
+	  }
+	  if (userPrompt) {
+	    args.push(userPrompt);
+	  }
+	  if (o.dryRun) {
+	    console.log("Would invoke: claude " + args.join(" "));
+	    return Promise.resolve({ exitCode: 0, output: "" });
+	  }
+	  return new Promise((resolve, reject) => {
+	    const stdio = o.quiet ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+	    const child = spawn("claude", args, { stdio });
+	    let output = "";
+	    if (o.quiet) {
+	      child.stdout.on("data", (chunk) => {
+	        output += chunk.toString();
+	      });
+	      child.stderr.on("data", (chunk) => {
+	        output += chunk.toString();
+	      });
+	    }
+	    child.on("error", (err) => {
+	      if (err.code === "ENOENT") {
+	        reject(new Error("claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
+	      } else {
+	        reject(err);
+	      }
+	    });
+	    child.on("close", (code) => {
+	      resolve({ exitCode: code || 0, output });
+	    });
+	  });
+	}
+	claude = {
+	  assertClaudeAvailable,
+	  invokeClaude,
+	  getCommandsDir
+	};
+	return claude;
+}
+
+var spinner;
+var hasRequiredSpinner;
+
+function requireSpinner () {
+	if (hasRequiredSpinner) return spinner;
+	hasRequiredSpinner = 1;
+	const { IS_TTY, IS_CI, USE_COLOR, COLORS } = requireOutput();
+	const FRAMES = ["|", "/", "-", "\\"];
+	const SUPPORTS_SPINNER = IS_TTY && !IS_CI;
+	function createSpinner(stage) {
+	  let frameIndex = 0;
+	  let intervalId = null;
+	  let startTime = null;
+	  let lastLineLength = 0;
+	  function clearLine() {
+	    if (!SUPPORTS_SPINNER) return;
+	    process.stdout.write("\r" + " ".repeat(lastLineLength) + "\r");
+	  }
+	  function render() {
+	    const frame = FRAMES[frameIndex % FRAMES.length];
+	    frameIndex++;
+	    const elapsed = startTime ? Math.floor((Date.now() - startTime) / 1e3) : 0;
+	    const elapsedStr = elapsed > 0 ? ` (${elapsed}s)` : "";
+	    let line;
+	    if (USE_COLOR) {
+	      line = `${COLORS.cyan}${frame}${COLORS.reset} ${COLORS.bold}${stage}${COLORS.reset}${COLORS.dim}${elapsedStr}${COLORS.reset}`;
+	    } else {
+	      line = `${frame} ${stage}${elapsedStr}`;
+	    }
+	    if (SUPPORTS_SPINNER) {
+	      clearLine();
+	      process.stdout.write(line);
+	      lastLineLength = `${frame} ${stage}${elapsedStr}`.length;
+	    }
+	  }
+	  function start(label) {
+	    if (label) stage = label;
+	    startTime = Date.now();
+	    if (SUPPORTS_SPINNER) {
+	      render();
+	      intervalId = setInterval(render, 100);
+	    } else {
+	      process.stdout.write(`[mgw] ${stage}...
+`);
+	    }
+	  }
+	  function succeed(message) {
+	    _stop();
+	    const text = message || stage;
+	    if (USE_COLOR) {
+	      process.stdout.write(`${COLORS.green}\u2713${COLORS.reset} ${text}
+`);
+	    } else {
+	      process.stdout.write(`[done] ${text}
+`);
+	    }
+	  }
+	  function fail(message) {
+	    _stop();
+	    const text = message || stage;
+	    if (USE_COLOR) {
+	      process.stdout.write(`${COLORS.red}\u2717${COLORS.reset} ${text}
+`);
+	    } else {
+	      process.stdout.write(`[fail] ${text}
+`);
+	    }
+	  }
+	  function stop() {
+	    _stop();
+	  }
+	  function _stop() {
+	    if (intervalId !== null) {
+	      clearInterval(intervalId);
+	      intervalId = null;
+	    }
+	    clearLine();
+	  }
+	  return { start, succeed, fail, stop };
+	}
+	async function withSpinner(stage, fn, opts) {
+	  const o = opts || {};
+	  const spinner = createSpinner(stage);
+	  spinner.start();
+	  try {
+	    const result = await fn();
+	    spinner.succeed(o.successMessage || stage);
+	    return result;
+	  } catch (err) {
+	    spinner.fail(o.failMessage || `${stage} failed`);
+	    throw err;
+	  }
+	}
+	spinner = {
+	  createSpinner,
+	  withSpinner,
+	  SUPPORTS_SPINNER
+	};
+	return spinner;
+}
+
+var renderer;
+var hasRequiredRenderer;
+
+function requireRenderer () {
+	if (hasRequiredRenderer) return renderer;
+	hasRequiredRenderer = 1;
+	let blessed;
+	try {
+	  blessed = require("neo-blessed");
+	} catch (_e) {
+	  try {
+	    blessed = require("blessed");
+	  } catch (_e2) {
+	    blessed = null;
+	  }
+	}
+	function createRenderer() {
+	  if (!blessed) {
+	    return createNoopRenderer();
+	  }
+	  return createBlessedRenderer();
+	}
+	function createBlessedRenderer() {
+	  const screen = blessed.screen({
+	    smartCSR: true,
+	    title: "MGW Issues",
+	    cursor: {
+	      artificial: true,
+	      shape: "line",
+	      blink: true,
+	      color: null
+	    }
+	  });
+	  const header = blessed.box({
+	    top: 0,
+	    left: 0,
+	    width: "100%",
+	    height: 1,
+	    content: " MGW ISSUES  [/] search  [f] filter  [j/k] scroll  [Enter] select  [q] quit  [?] help",
+	    style: {
+	      fg: "brightwhite",
+	      bg: "brightblack",
+	      bold: true
+	    },
+	    tags: false
+	  });
+	  const searchBar = blessed.box({
+	    top: 1,
+	    left: 0,
+	    width: "100%",
+	    height: 1,
+	    content: "Search: ",
+	    style: {
+	      fg: "brightwhite",
+	      bg: "black"
+	    }
+	  });
+	  const issueList = blessed.list({
+	    top: 2,
+	    left: 0,
+	    width: "60%",
+	    height: "100%-5",
+	    // header + search + filterbar + status
+	    style: {
+	      fg: "brightwhite",
+	      bg: "black",
+	      selected: {
+	        fg: "black",
+	        bg: "magenta"
+	      },
+	      border: {
+	        fg: "cyan"
+	      }
+	    },
+	    border: { type: "line" },
+	    scrollable: true,
+	    keys: true,
+	    mouse: true,
+	    items: []
+	  });
+	  const detailPane = blessed.box({
+	    top: 2,
+	    left: "60%",
+	    width: "40%",
+	    height: "100%-5",
+	    style: {
+	      fg: "brightwhite",
+	      bg: "black",
+	      border: {
+	        fg: "cyan"
+	      }
+	    },
+	    border: { type: "line" },
+	    scrollable: true,
+	    keys: true,
+	    mouse: true,
+	    content: "",
+	    tags: false
+	  });
+	  const filterPane = blessed.box({
+	    top: 2,
+	    left: "60%",
+	    width: "40%",
+	    height: "100%-5",
+	    label: " Filters [f] close  [j/k] move  [Space] toggle  [c] clear ",
+	    style: {
+	      fg: "brightwhite",
+	      bg: "black",
+	      border: {
+	        fg: "yellow",
+	        bold: true
+	      },
+	      label: {
+	        fg: "yellow"
+	      }
+	    },
+	    border: { type: "line" },
+	    scrollable: true,
+	    keys: false,
+	    mouse: false,
+	    content: "",
+	    tags: false,
+	    hidden: true
+	  });
+	  const filterBar = blessed.box({
+	    bottom: 1,
+	    left: 0,
+	    width: "100%",
+	    height: 1,
+	    content: " Filter: none",
+	    style: {
+	      fg: "yellow",
+	      bg: "black"
+	    }
+	  });
+	  const statusBar = blessed.box({
+	    bottom: 0,
+	    left: 0,
+	    width: "100%",
+	    height: 1,
+	    content: " 0 issues",
+	    style: {
+	      fg: "brightwhite",
+	      bg: "brightblack"
+	    }
+	  });
+	  const helpOverlay = blessed.box({
+	    top: "center",
+	    left: "center",
+	    width: 56,
+	    height: 22,
+	    label: " Keyboard Shortcuts ",
+	    hidden: true,
+	    border: { type: "line" },
+	    style: {
+	      fg: "brightwhite",
+	      bg: "black",
+	      border: { fg: "cyan" },
+	      label: { fg: "cyan" }
+	    },
+	    content: [
+	      "",
+	      "  Navigation",
+	      "    j / \u2193       Scroll down",
+	      "    k / \u2191       Scroll up",
+	      "    g / Home    Jump to top",
+	      "    G / End     Jump to bottom",
+	      "    PgDn        Page down",
+	      "    PgUp        Page up",
+	      "    Tab         Cycle pane focus",
+	      "    Shift+Tab   Cycle pane reverse",
+	      "",
+	      "  Actions",
+	      "    /           Open search",
+	      "    f           Open/close filter pane",
+	      "    Space       Toggle filter item",
+	      "    c           Clear all filters",
+	      "    Enter       Select issue",
+	      "    q / Esc     Quit / close overlay",
+	      "    Ctrl+C      Force quit",
+	      "    ?           Show this help",
+	      ""
+	    ].join("\n"),
+	    tags: false
+	  });
+	  screen.append(header);
+	  screen.append(searchBar);
+	  screen.append(issueList);
+	  screen.append(detailPane);
+	  screen.append(filterPane);
+	  screen.append(filterBar);
+	  screen.append(statusBar);
+	  screen.append(helpOverlay);
+	  let lastState = null;
+	  let helpVisible = false;
+	  function _formatListItem(issue) {
+	    const num = `#${issue.number}`.padEnd(6);
+	    const title = (issue.title || "").slice(0, 45);
+	    return `${num} ${title}`;
+	  }
+	  function _formatDetail(issue) {
+	    if (!issue) return "(no issue selected)";
+	    const labels = (issue.labels || []).map((l) => typeof l === "object" ? l.name : l).join(", ") || "none";
+	    const assignees = (issue.assignees || []).map((a) => typeof a === "object" ? a.login : a).join(", ") || "unassigned";
+	    const milestone = issue.milestone ? typeof issue.milestone === "object" ? issue.milestone.title : issue.milestone : "none";
+	    const commentCount = Array.isArray(issue.comments) ? issue.comments.length : issue.comments || 0;
+	    return [
+	      `#${issue.number} \u2014 ${issue.title}`,
+	      "",
+	      `Labels:    ${labels}`,
+	      `Assignees: ${assignees}`,
+	      `Milestone: ${milestone}`,
+	      `Comments:  ${commentCount}`,
+	      `URL:       ${issue.url || ""}`,
+	      "",
+	      "\u2500".repeat(40),
+	      "",
+	      issue.body || "(no description)"
+	    ].join("\n");
+	  }
+	  function _formatFilterPane(filterState) {
+	    if (!filterState) return "(no filters available)";
+	    const lines = [];
+	    const labelFocused = filterState.cursorSection === "labels";
+	    lines.push(labelFocused ? " > Labels" : "   Labels");
+	    if (filterState.availableLabels.length === 0) {
+	      lines.push("   (none)");
+	    } else {
+	      filterState.availableLabels.forEach((label, i) => {
+	        const checked = filterState.activeLabels.has(label) ? "x" : " ";
+	        const cursor = labelFocused && i === filterState.cursorIndex ? ">" : " ";
+	        lines.push(`  ${cursor}[${checked}] ${label}`);
+	      });
+	    }
+	    lines.push("");
+	    const msFocused = filterState.cursorSection === "milestones";
+	    lines.push(msFocused ? " > Milestones" : "   Milestones");
+	    if (filterState.availableMilestones.length === 0) {
+	      lines.push("   (none)");
+	    } else {
+	      filterState.availableMilestones.forEach((ms, i) => {
+	        const checked = filterState.activeMilestones.has(ms) ? "x" : " ";
+	        const cursor = msFocused && i === filterState.cursorIndex ? ">" : " ";
+	        lines.push(`  ${cursor}[${checked}] ${ms}`);
+	      });
+	    }
+	    lines.push("");
+	    const stateFocused = filterState.cursorSection === "state";
+	    lines.push(stateFocused ? " > State" : "   State");
+	    const stateOptions = ["open", "closed", "all"];
+	    stateOptions.forEach((opt, i) => {
+	      const selected = filterState.activeState === opt ? "*" : " ";
+	      const cursor = stateFocused && i === filterState.cursorIndex ? ">" : " ";
+	      lines.push(`  ${cursor}(${selected}) ${opt}`);
+	    });
+	    return lines.join("\n");
+	  }
+	  function _formatFilterBar(filterState) {
+	    if (!filterState || filterState.isEmpty) {
+	      return " Filter: none  [f] open filter pane";
+	    }
+	    const parts = [];
+	    if (filterState.activeLabels.size > 0) {
+	      parts.push(`Labels: ${Array.from(filterState.activeLabels).join(", ")}`);
+	    }
+	    if (filterState.activeMilestones.size > 0) {
+	      parts.push(`Milestone: ${Array.from(filterState.activeMilestones).join(", ")}`);
+	    }
+	    if (filterState.activeState !== "open") {
+	      parts.push(`State: ${filterState.activeState}`);
+	    }
+	    return ` Filter: ${parts.join("  |  ")}  [f] edit  [c] clear`;
+	  }
+	  function render(state) {
+	    lastState = state;
+	    const { filtered, selectedIndex, query, focusPane, filterState } = state;
+	    helpVisible = Boolean(state.helpVisible);
+	    const items = filtered.map(_formatListItem);
+	    issueList.setItems(items);
+	    if (filtered.length > 0) {
+	      issueList.select(selectedIndex);
+	    }
+	    const cursor = focusPane === "search" ? "\u2588" : "";
+	    searchBar.setContent(`Search: ${query}${cursor}`);
+	    if (focusPane === "filter") {
+	      detailPane.hide();
+	      filterPane.setContent(_formatFilterPane(filterState || null));
+	      filterPane.show();
+	    } else {
+	      filterPane.hide();
+	      const selectedIssue = filtered[selectedIndex] || null;
+	      detailPane.setContent(_formatDetail(selectedIssue));
+	      detailPane.show();
+	    }
+	    filterBar.setContent(_formatFilterBar(filterState || null));
+	    const filterActive = filterState && !filterState.isEmpty;
+	    const filterHint = filterActive ? "  [c] clear filters" : "";
+	    const searchHint = focusPane === "search" ? "  [Enter] apply  [Esc] cancel" : "  [/] search  [?] help";
+	    statusBar.setContent(
+	      ` ${filtered.length} issue${filtered.length === 1 ? "" : "s"}` + (query ? ` matching "${query}"` : "") + searchHint + filterHint
+	    );
+	    if (helpVisible) {
+	      helpOverlay.show();
+	    } else {
+	      helpOverlay.hide();
+	    }
+	    screen.render();
+	  }
+	  function startKeyboard(keyboard) {
+	    screen.on("keypress", (ch, key) => {
+	      if (key.full === "C-c" || ch === "") {
+	        keyboard.emit("force-quit");
+	        return;
+	      }
+	      if (lastState && lastState.focusPane === "search") {
+	        const name = key.name || "";
+	        if (ch === "" || key.full === "C-c") {
+	          keyboard.dispatch("", key);
+	          return;
+	        }
+	        if (name === "enter" || name === "return") {
+	          keyboard.emit("search-exit");
+	        } else if (name === "escape") {
+	          keyboard.updateSearch("");
+	          keyboard.emit("search-exit");
+	        } else if (name === "backspace") {
+	          const q = lastState.query || "";
+	          keyboard.updateSearch(q.slice(0, -1));
+	        } else if (ch && ch.length === 1 && ch >= " ") {
+	          keyboard.updateSearch((lastState.query || "") + ch);
+	        }
+	        return;
+	      }
+	      if (lastState && lastState.focusPane === "filter") {
+	        const name = key.name || "";
+	        if (name === "j" || key.full === "down") {
+	          keyboard.emit("filter-scroll-down");
+	          return;
+	        }
+	        if (name === "k" || key.full === "up") {
+	          keyboard.emit("filter-scroll-up");
+	          return;
+	        }
+	        if (key.full === "tab") {
+	          keyboard.emit("filter-next-section");
+	          return;
+	        }
+	        if (key.full === "S-tab") {
+	          keyboard.emit("filter-prev-section");
+	          return;
+	        }
+	      }
+	      keyboard.dispatch(key.full || ch || "", key);
+	    });
+	  }
+	  function destroy() {
+	    try {
+	      screen.destroy();
+	    } catch (_e) {
+	    }
+	  }
+	  return { render, startKeyboard, destroy };
+	}
+	function createNoopRenderer() {
+	  return {
+	    render(_state) {
+	    },
+	    startKeyboard(_keyboard) {
+	    },
+	    destroy() {
+	    }
+	  };
+	}
+	renderer = { createRenderer };
+	return renderer;
+}
+
+var search;
+var hasRequiredSearch;
+
+function requireSearch () {
+	if (hasRequiredSearch) return search;
+	hasRequiredSearch = 1;
+	class FuzzySearch {
+	  /**
+	   * @param {Object[]} items - Array of objects to search
+	   * @param {Object} [options={}]
+	   * @param {string[]} [options.keys=['title']] - Object keys to search against
+	   */
+	  constructor(items, options = {}) {
+	    this.items = items;
+	    this.keys = options.keys || ["title"];
+	  }
+	  /**
+	   * Search items by query string.
+	   *
+	   * @param {string} query - Search query (empty string returns all items)
+	   * @returns {Object[]} Matching items sorted by score descending
+	   */
+	  search(query) {
+	    if (!query || typeof query !== "string" || query.trim() === "") {
+	      return this.items.slice();
+	    }
+	    const q = query.toLowerCase().trim();
+	    const scored = this.items.map((item) => ({ item, score: this._score(item, q) })).filter(({ score }) => score > 0);
+	    scored.sort((a, b) => b.score - a.score);
+	    return scored.map(({ item }) => item);
+	  }
+	  /**
+	   * Score a single item against a query.
+	   *
+	   * @param {Object} item
+	   * @param {string} q - Lowercase trimmed query
+	   * @returns {number} Score (0 = no match)
+	   * @private
+	   */
+	  _score(item, q) {
+	    let max = 0;
+	    for (const key of this.keys) {
+	      const rawVal = item[key];
+	      const val = this._normalizeValue(rawVal);
+	      if (val === q) return 100;
+	      if (val.startsWith(q)) {
+	        max = Math.max(max, 80);
+	      } else if (val.includes(q)) {
+	        max = Math.max(max, 60);
+	      } else if (this._fuzzy(val, q)) {
+	        max = Math.max(max, 40);
+	      }
+	    }
+	    return max;
+	  }
+	  /**
+	   * Normalize a value to a searchable lowercase string.
+	   * Arrays (e.g. labels) are joined with space.
+	   *
+	   * @param {*} val
+	   * @returns {string}
+	   * @private
+	   */
+	  _normalizeValue(val) {
+	    if (val === null || val === void 0) return "";
+	    if (Array.isArray(val)) {
+	      return val.map((v) => typeof v === "object" && v !== null ? v.name || JSON.stringify(v) : String(v)).join(" ").toLowerCase();
+	    }
+	    return String(val).toLowerCase();
+	  }
+	  /**
+	   * Check if all characters of `pattern` appear in `str` in order.
+	   *
+	   * @param {string} str
+	   * @param {string} pattern
+	   * @returns {boolean}
+	   * @private
+	   */
+	  _fuzzy(str, pattern) {
+	    let pi = 0;
+	    for (let si = 0; si < str.length && pi < pattern.length; si++) {
+	      if (str[si] === pattern[pi]) pi++;
+	    }
+	    return pi === pattern.length;
+	  }
+	}
+	search = { FuzzySearch };
+	return search;
+}
+
+var keyboard;
+var hasRequiredKeyboard;
+
+function requireKeyboard () {
+	if (hasRequiredKeyboard) return keyboard;
+	hasRequiredKeyboard = 1;
+	const { EventEmitter } = require$$0$2;
+	const DEFAULT_BINDINGS = {
+	  // Scroll
+	  "j": "scroll-down",
+	  "\x1B[B": "scroll-down",
+	  // Down arrow
+	  "\x1B[1;2B": "scroll-down",
+	  // Shift+Down (some terminals)
+	  "k": "scroll-up",
+	  "\x1B[A": "scroll-up",
+	  // Up arrow
+	  "\x1B[1;2A": "scroll-up",
+	  // Shift+Up
+	  // Jump
+	  "g": "jump-top",
+	  "\x1B[H": "jump-top",
+	  // Home
+	  "G": "jump-bottom",
+	  "\x1B[F": "jump-bottom",
+	  // End
+	  "\x1B[5~": "page-up",
+	  // PgUp
+	  "\x1B[6~": "page-down",
+	  // PgDn
+	  // Select / quit
+	  "\r": "select",
+	  // Enter
+	  "\n": "select",
+	  "q": "quit",
+	  "\x1B": "quit",
+	  // Escape (bare — only if not start of sequence)
+	  // Search
+	  "/": "search-focus",
+	  // Focus
+	  "	": "tab-focus",
+	  // Tab
+	  "\x1B[Z": "tab-focus-reverse",
+	  // Shift+Tab
+	  // Help
+	  "?": "help",
+	  // Filter pane
+	  "f": "filter-focus",
+	  // Open filter pane
+	  " ": "filter-toggle",
+	  // Toggle item under cursor (Space)
+	  "c": "filter-clear",
+	  // Clear all filters
+	  // Force quit
+	  "": "force-quit"
+	  // Ctrl+C
+	};
+	class KeyboardHandler extends EventEmitter {
+	  /**
+	   * @param {Record<string, string>} [bindings=DEFAULT_BINDINGS]
+	   *   Map of raw key sequences to action names.
+	   */
+	  constructor(bindings = DEFAULT_BINDINGS) {
+	    super();
+	    this.bindings = Object.assign({}, bindings);
+	  }
+	  /**
+	   * Dispatch a raw key string to the matching action event.
+	   *
+	   * If no binding is found, emits 'unbound' with the key as argument.
+	   *
+	   * @param {string} key - Raw keypress string from terminal
+	   * @param {Object} [meta={}] - Optional metadata (e.g. { shift, ctrl, name })
+	   */
+	  dispatch(key, meta = {}) {
+	    const action = this.bindings[key];
+	    if (action) {
+	      this.emit(action, key, meta);
+	    } else {
+	      this.emit("unbound", key, meta);
+	    }
+	  }
+	  /**
+	   * Emit a search-update event for live search input.
+	   * Called by the renderer when characters are typed in the search input.
+	   *
+	   * @param {string} query - Current search string
+	   */
+	  updateSearch(query) {
+	    this.emit("search-update", query);
+	  }
+	  /**
+	   * Add or override a key binding.
+	   *
+	   * @param {string} key - Raw key sequence
+	   * @param {string} action - Action name to emit
+	   */
+	  bind(key, action) {
+	    this.bindings[key] = action;
+	  }
+	  /**
+	   * Remove a key binding.
+	   *
+	   * @param {string} key - Raw key sequence to unbind
+	   */
+	  unbind(key) {
+	    delete this.bindings[key];
+	  }
+	}
+	keyboard = { KeyboardHandler, DEFAULT_BINDINGS };
+	return keyboard;
+}
+
+var filter;
+var hasRequiredFilter;
+
+function requireFilter () {
+	if (hasRequiredFilter) return filter;
+	hasRequiredFilter = 1;
+	const STATE_OPTIONS = ["open", "closed", "all"];
+	function extractLabels(issues) {
+	  const seen = /* @__PURE__ */ new Set();
+	  for (const issue of issues) {
+	    for (const l of issue.labels || []) {
+	      const name = typeof l === "object" ? l.name : String(l);
+	      if (name) seen.add(name);
+	    }
+	  }
+	  return Array.from(seen).sort();
+	}
+	function extractMilestones(issues) {
+	  const seen = /* @__PURE__ */ new Set();
+	  for (const issue of issues) {
+	    if (issue.milestone) {
+	      const title = typeof issue.milestone === "object" ? issue.milestone.title : String(issue.milestone);
+	      if (title) seen.add(title);
+	    }
+	  }
+	  return Array.from(seen).sort();
+	}
+	class FilterState {
+	  /**
+	   * @param {Object[]} issues - Full unfiltered issue set (used to extract options)
+	   * @param {Object}  [persisted={}] - Hydrated from .mgw/config.json if available
+	   * @param {string[]} [persisted.activeLabels]
+	   * @param {string[]} [persisted.activeMilestones]
+	   * @param {string}   [persisted.activeState]
+	   */
+	  constructor(issues, persisted = {}) {
+	    this.availableLabels = extractLabels(issues);
+	    this.availableMilestones = extractMilestones(issues);
+	    const pl = Array.isArray(persisted.activeLabels) ? persisted.activeLabels : [];
+	    const pm = Array.isArray(persisted.activeMilestones) ? persisted.activeMilestones : [];
+	    const ps = STATE_OPTIONS.includes(persisted.activeState) ? persisted.activeState : "open";
+	    this.activeLabels = new Set(pl.filter((l) => this.availableLabels.includes(l)));
+	    this.activeMilestones = new Set(pm.filter((m) => this.availableMilestones.includes(m)));
+	    this.activeState = ps;
+	    this.cursorSection = "labels";
+	    this.cursorIndex = 0;
+	  }
+	  // ── Cursor navigation ──────────────────────────────────────────────────────
+	  /**
+	   * The ordered list of sections shown in the filter pane.
+	   * @returns {string[]}
+	   */
+	  get sections() {
+	    return ["labels", "milestones", "state"];
+	  }
+	  /**
+	   * Number of items in the cursor's current section.
+	   * @returns {number}
+	   */
+	  get currentSectionLength() {
+	    switch (this.cursorSection) {
+	      case "labels":
+	        return Math.max(this.availableLabels.length, 1);
+	      case "milestones":
+	        return Math.max(this.availableMilestones.length, 1);
+	      case "state":
+	        return STATE_OPTIONS.length;
+	      default:
+	        return 1;
+	    }
+	  }
+	  /**
+	   * Move cursor down within the current section.
+	   */
+	  cursorDown() {
+	    this.cursorIndex = Math.min(this.cursorIndex + 1, this.currentSectionLength - 1);
+	  }
+	  /**
+	   * Move cursor up within the current section.
+	   */
+	  cursorUp() {
+	    this.cursorIndex = Math.max(this.cursorIndex - 1, 0);
+	  }
+	  /**
+	   * Advance to the next section (wraps around).
+	   */
+	  nextSection() {
+	    const idx = this.sections.indexOf(this.cursorSection);
+	    this.cursorSection = this.sections[(idx + 1) % this.sections.length];
+	    this.cursorIndex = 0;
+	  }
+	  /**
+	   * Go to the previous section (wraps around).
+	   */
+	  prevSection() {
+	    const idx = this.sections.indexOf(this.cursorSection);
+	    this.cursorSection = this.sections[(idx - 1 + this.sections.length) % this.sections.length];
+	    this.cursorIndex = 0;
+	  }
+	  // ── Toggle actions ─────────────────────────────────────────────────────────
+	  /**
+	   * Toggle the item under the cursor.
+	   * For labels/milestones: toggle membership in the active set.
+	   * For state: cycle to the selected option.
+	   */
+	  toggleCursor() {
+	    switch (this.cursorSection) {
+	      case "labels": {
+	        const label = this.availableLabels[this.cursorIndex];
+	        if (!label) break;
+	        if (this.activeLabels.has(label)) {
+	          this.activeLabels.delete(label);
+	        } else {
+	          this.activeLabels.add(label);
+	        }
+	        break;
+	      }
+	      case "milestones": {
+	        const ms = this.availableMilestones[this.cursorIndex];
+	        if (!ms) break;
+	        if (this.activeMilestones.has(ms)) {
+	          this.activeMilestones.delete(ms);
+	        } else {
+	          this.activeMilestones.add(ms);
+	        }
+	        break;
+	      }
+	      case "state": {
+	        this.activeState = STATE_OPTIONS[this.cursorIndex];
+	        break;
+	      }
+	    }
+	  }
+	  /**
+	   * Clear all active filters, reset state to 'open'.
+	   */
+	  clearAll() {
+	    this.activeLabels.clear();
+	    this.activeMilestones.clear();
+	    this.activeState = "open";
+	  }
+	  // ── Filtering ──────────────────────────────────────────────────────────────
+	  /**
+	   * Return true if no filters are active (besides state=open which is the default).
+	   * @returns {boolean}
+	   */
+	  get isEmpty() {
+	    return this.activeLabels.size === 0 && this.activeMilestones.size === 0 && this.activeState === "open";
+	  }
+	  /**
+	   * Apply the current filter state to an array of issues.
+	   *
+	   * Label filter: issue must have ALL selected labels.
+	   * Milestone filter: issue must match ANY selected milestone.
+	   * State filter: applied upstream by the GitHub API; in TUI mode
+	   *   we apply it client-side against issue.state.
+	   *
+	   * @param {Object[]} issues - Full unfiltered issue set
+	   * @returns {Object[]} Filtered subset
+	   */
+	  apply(issues) {
+	    return issues.filter((issue) => {
+	      if (this.activeState !== "all") {
+	        const issueState = (issue.state || "open").toLowerCase();
+	        if (issueState !== this.activeState) return false;
+	      }
+	      if (this.activeLabels.size > 0) {
+	        const issueLabels = new Set(
+	          (issue.labels || []).map((l) => typeof l === "object" ? l.name : String(l))
+	        );
+	        for (const required of this.activeLabels) {
+	          if (!issueLabels.has(required)) return false;
+	        }
+	      }
+	      if (this.activeMilestones.size > 0) {
+	        const ms = issue.milestone ? typeof issue.milestone === "object" ? issue.milestone.title : String(issue.milestone) : null;
+	        if (!ms || !this.activeMilestones.has(ms)) return false;
+	      }
+	      return true;
+	    });
+	  }
+	  // ── Serialisation ──────────────────────────────────────────────────────────
+	  /**
+	   * Return a plain object suitable for JSON persistence in .mgw/config.json.
+	   *
+	   * @returns {{activeLabels: string[], activeMilestones: string[], activeState: string}}
+	   */
+	  toJSON() {
+	    return {
+	      activeLabels: Array.from(this.activeLabels),
+	      activeMilestones: Array.from(this.activeMilestones),
+	      activeState: this.activeState
+	    };
+	  }
+	}
+	filter = { FilterState, extractLabels, extractMilestones, STATE_OPTIONS };
+	return filter;
+}
+
+var graceful;
+var hasRequiredGraceful;
+
+function requireGraceful () {
+	if (hasRequiredGraceful) return graceful;
+	hasRequiredGraceful = 1;
+	function isInteractive() {
+	  if (process.env.MGW_NO_TUI === "1") return false;
+	  if (process.env.CI) return false;
+	  return Boolean(process.stdout.isTTY);
+	}
+	function renderStaticTable(issues) {
+	  if (!issues || issues.length === 0) {
+	    console.log("No issues found.");
+	    return;
+	  }
+	  const COL = { num: 6, title: 40, labels: 25, age: 5 };
+	  const totalWidth = COL.num + 1 + COL.title + 1 + COL.labels + 1 + COL.age;
+	  const header = [
+	    "#".padEnd(COL.num),
+	    "Title".padEnd(COL.title),
+	    "Labels".padEnd(COL.labels),
+	    "Age".padEnd(COL.age)
+	  ].join(" ");
+	  const separator = "-".repeat(totalWidth);
+	  console.log(header);
+	  console.log(separator);
+	  for (const issue of issues) {
+	    const num = String(issue.number || "").padEnd(COL.num);
+	    const title = _truncate(issue.title || "", COL.title).padEnd(COL.title);
+	    const labelStr = _formatLabels(issue.labels).slice(0, COL.labels).padEnd(COL.labels);
+	    const age = _relativeAge(issue.createdAt).padEnd(COL.age);
+	    console.log([num, title, labelStr, age].join(" "));
+	  }
+	  console.log(separator);
+	  console.log(`${issues.length} issue${issues.length === 1 ? "" : "s"}`);
+	}
+	function _formatLabels(labels) {
+	  if (!Array.isArray(labels) || labels.length === 0) return "";
+	  return labels.map((l) => typeof l === "object" && l !== null ? l.name : String(l)).join(", ");
+	}
+	function _truncate(str, maxLen) {
+	  if (str.length <= maxLen) return str;
+	  return str.slice(0, maxLen - 1) + "\u2026";
+	}
+	function _relativeAge(dateStr) {
+	  if (!dateStr) return "-";
+	  let ms;
+	  try {
+	    ms = Date.now() - new Date(dateStr).getTime();
+	  } catch (e) {
+	    return "-";
+	  }
+	  if (ms < 0) return "now";
+	  const minutes = Math.floor(ms / 6e4);
+	  const hours = Math.floor(ms / 36e5);
+	  const days = Math.floor(ms / 864e5);
+	  if (days === 0) return hours > 0 ? `${hours}h` : minutes > 0 ? `${minutes}m` : "now";
+	  if (days === 1) return "1d";
+	  if (days < 7) return `${days}d`;
+	  if (days < 30) return `${Math.floor(days / 7)}w`;
+	  if (days < 365) return `${Math.floor(days / 30)}mo`;
+	  return `${Math.floor(days / 365)}yr`;
+	}
+	graceful = { isInteractive, renderStaticTable };
+	return graceful;
+}
+
+var tui;
+var hasRequiredTui;
+
+function requireTui () {
+	if (hasRequiredTui) return tui;
+	hasRequiredTui = 1;
+	const { createRenderer } = requireRenderer();
+	const { FuzzySearch } = requireSearch();
+	const { KeyboardHandler } = requireKeyboard();
+	const { FilterState } = requireFilter();
+	const { isInteractive, renderStaticTable } = requireGraceful();
+	function _loadPersistedFilters() {
+	  try {
+	    const path = require("path");
+	    const fs = require("fs");
+	    const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	    if (!fs.existsSync(configPath)) return {};
+	    const raw = fs.readFileSync(configPath, "utf-8");
+	    const data = JSON.parse(raw);
+	    return data.tuiFilters || {};
+	  } catch (_e) {
+	    return {};
+	  }
+	}
+	function _savePersistedFilters(filterState) {
+	  try {
+	    const path = require("path");
+	    const fs = require("fs");
+	    const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	    let data = {};
+	    if (fs.existsSync(configPath)) {
+	      try {
+	        data = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	      } catch (_e) {
+	      }
+	    }
+	    data.tuiFilters = filterState.toJSON();
+	    fs.writeFileSync(configPath, JSON.stringify(data, null, 2));
+	  } catch (_e) {
+	  }
+	}
+	async function createIssuesBrowser(options) {
+	  const {
+	    issues = [],
+	    onSelect,
+	    onQuit,
+	    initialQuery = "",
+	    initialFilter = {}
+	  } = options;
+	  if (!isInteractive()) {
+	    const displayed = initialQuery ? new FuzzySearch(issues, { keys: ["title", "number", "labels"] }).search(initialQuery) : issues;
+	    renderStaticTable(displayed);
+	    if (typeof onQuit === "function") onQuit();
+	    return;
+	  }
+	  const persisted = _loadPersistedFilters();
+	  const seedFilters = Object.assign({}, persisted);
+	  if (initialFilter.label) seedFilters.activeLabels = [initialFilter.label];
+	  if (initialFilter.milestone) seedFilters.activeMilestones = [initialFilter.milestone];
+	  if (initialFilter.state) seedFilters.activeState = initialFilter.state;
+	  const filterState = new FilterState(issues, seedFilters);
+	  new FuzzySearch(issues, { keys: ["title", "number", "labels"] });
+	  const renderer = createRenderer();
+	  const keyboard = new KeyboardHandler();
+	  const PAGE_SIZE = 10;
+	  let query = initialQuery;
+	  let selectedIndex = 0;
+	  let focusPane = "list";
+	  let running = true;
+	  let helpVisible = false;
+	  function _searchIn(subset, q) {
+	    if (!q) return subset;
+	    return new FuzzySearch(subset, { keys: ["title", "number", "labels"] }).search(q);
+	  }
+	  let filtered = _searchIn(filterState.apply(issues), query);
+	  function draw() {
+	    return renderer.render({
+	      filtered,
+	      selectedIndex,
+	      query,
+	      focusPane,
+	      filterState,
+	      helpVisible
+	    });
+	  }
+	  function clampIndex() {
+	    if (selectedIndex < 0) selectedIndex = 0;
+	    if (filtered.length > 0 && selectedIndex >= filtered.length) {
+	      selectedIndex = filtered.length - 1;
+	    }
+	  }
+	  function refilter() {
+	    filtered = _searchIn(filterState.apply(issues), query);
+	    selectedIndex = 0;
+	  }
+	  keyboard.on("scroll-down", () => {
+	    if (focusPane === "filter") return;
+	    selectedIndex++;
+	    clampIndex();
+	    draw();
+	  });
+	  keyboard.on("scroll-up", () => {
+	    if (focusPane === "filter") return;
+	    selectedIndex--;
+	    clampIndex();
+	    draw();
+	  });
+	  keyboard.on("jump-top", () => {
+	    selectedIndex = 0;
+	    draw();
+	  });
+	  keyboard.on("jump-bottom", () => {
+	    selectedIndex = Math.max(0, filtered.length - 1);
+	    draw();
+	  });
+	  keyboard.on("page-down", () => {
+	    selectedIndex = Math.min(selectedIndex + PAGE_SIZE, Math.max(0, filtered.length - 1));
+	    draw();
+	  });
+	  keyboard.on("page-up", () => {
+	    selectedIndex = Math.max(selectedIndex - PAGE_SIZE, 0);
+	    draw();
+	  });
+	  keyboard.on("select", () => {
+	    if (focusPane === "filter") {
+	      _savePersistedFilters(filterState);
+	      focusPane = "list";
+	      draw();
+	      return;
+	    }
+	    if (filtered.length > 0 && typeof onSelect === "function") {
+	      const issue = filtered[selectedIndex];
+	      running = false;
+	      renderer.destroy();
+	      onSelect(issue);
+	    }
+	  });
+	  keyboard.on("quit", () => {
+	    if (helpVisible) {
+	      helpVisible = false;
+	      draw();
+	      return;
+	    }
+	    if (focusPane === "filter") {
+	      _savePersistedFilters(filterState);
+	      focusPane = "list";
+	      draw();
+	      return;
+	    }
+	    if (focusPane === "search") {
+	      focusPane = "list";
+	      draw();
+	      return;
+	    }
+	    if (running) {
+	      running = false;
+	      renderer.destroy();
+	      if (typeof onQuit === "function") onQuit();
+	    }
+	  });
+	  keyboard.on("force-quit", () => {
+	    if (running) {
+	      running = false;
+	      renderer.destroy();
+	      process.exit(0);
+	    }
+	  });
+	  keyboard.on("tab-focus", () => {
+	    const order = ["list", "detail", "filter"];
+	    const current = order.indexOf(focusPane);
+	    focusPane = order[(current + 1) % order.length];
+	    draw();
+	  });
+	  keyboard.on("tab-focus-reverse", () => {
+	    const order = ["list", "detail", "filter"];
+	    const current = order.indexOf(focusPane);
+	    const base = current === -1 ? 0 : current;
+	    focusPane = order[(base - 1 + order.length) % order.length];
+	    draw();
+	  });
+	  keyboard.on("search-focus", () => {
+	    focusPane = "search";
+	    draw();
+	  });
+	  keyboard.on("search-exit", () => {
+	    focusPane = "list";
+	    draw();
+	  });
+	  keyboard.on("search-update", (newQuery) => {
+	    query = newQuery;
+	    refilter();
+	    draw();
+	  });
+	  keyboard.on("help", () => {
+	    helpVisible = !helpVisible;
+	    draw();
+	  });
+	  keyboard.on("filter-focus", () => {
+	    if (focusPane === "filter") {
+	      _savePersistedFilters(filterState);
+	      focusPane = "list";
+	    } else {
+	      focusPane = "filter";
+	    }
+	    draw();
+	  });
+	  keyboard.on("filter-scroll-down", () => {
+	    filterState.cursorDown();
+	    draw();
+	  });
+	  keyboard.on("filter-scroll-up", () => {
+	    filterState.cursorUp();
+	    draw();
+	  });
+	  keyboard.on("filter-next-section", () => {
+	    filterState.nextSection();
+	    draw();
+	  });
+	  keyboard.on("filter-prev-section", () => {
+	    filterState.prevSection();
+	    draw();
+	  });
+	  keyboard.on("filter-toggle", () => {
+	    if (focusPane !== "filter") return;
+	    filterState.toggleCursor();
+	    refilter();
+	    _savePersistedFilters(filterState);
+	    draw();
+	  });
+	  keyboard.on("filter-clear", () => {
+	    filterState.clearAll();
+	    refilter();
+	    _savePersistedFilters(filterState);
+	    draw();
+	  });
+	  await draw();
+	  if (typeof renderer.startKeyboard === "function") {
+	    renderer.startKeyboard(keyboard);
+	  }
+	}
+	tui = { createIssuesBrowser };
+	return tui;
+}
+
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
+exports.requireClaude = requireClaude;
+exports.requireGithub = requireGithub;
+exports.requireOutput = requireOutput;
+exports.requireSpinner = requireSpinner;
+exports.requireState = requireState;
+exports.requireTui = requireTui;