@snipcodeit/mgw 0.2.2 → 0.4.0

package/dist/{index-BiwU0uWA.cjs → index-B-_JvYpz.cjs}

@@ -1,9 +1,10 @@
 'use strict';
 
-var require$$0 = require('fs');
+var require$$2 = require('fs');
 var require$$1 = require('path');
-var require$$0$1 = require('child_process');
-var require$$0$2 = require('events');
+var require$$0 = require('child_process');
+var require$$3 = require('os');
+var require$$0$1 = require('events');
 
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -15,7 +16,7 @@ var hasRequiredState;
 function requireState () {
 	if (hasRequiredState) return state;
 	hasRequiredState = 1;
-	const fs = require$$0;
+	const fs = require$$2;
 	const path = require$$1;
 	function getMgwDir() {
 	  return path.join(process.cwd(), ".mgw");
@@ -84,17 +85,21 @@ function requireState () {
 	  return existing;
 	}
 	function migrateProjectState() {
+	  const warnings = [];
 	  const existing = loadProjectState();
-	  if (!existing) return null;
+	  if (!existing) return { state: null, warnings: [] };
 	  let changed = false;
 	  if (!existing.hasOwnProperty("active_gsd_milestone")) {
 	    existing.active_gsd_milestone = null;
 	    changed = true;
+	    warnings.push("migration: added active_gsd_milestone field");
 	  }
 	  for (const m of existing.milestones || []) {
+	    const mLabel = m.title || m.gsd_milestone_id || "unnamed";
 	    if (!m.hasOwnProperty("gsd_milestone_id")) {
 	      m.gsd_milestone_id = null;
 	      changed = true;
+	      warnings.push(`migration: added gsd_milestone_id to milestone "${mLabel}"`);
 	    }
 	    if (!m.hasOwnProperty("gsd_state")) {
 	      m.gsd_state = null;
@@ -113,8 +118,9 @@ function requireState () {
 	    let entries;
 	    try {
 	      entries = fs.readdirSync(activeDir);
-	    } catch {
+	    } catch (err) {
 	      entries = [];
+	      warnings.push(`migration: could not read active dir: ${err.message}`);
 	    }
 	    for (const file of entries) {
 	      if (!file.endsWith(".json")) continue;
@@ -122,7 +128,8 @@ function requireState () {
 	      let issueState;
 	      try {
 	        issueState = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-	      } catch {
+	      } catch (err) {
+	        warnings.push(`migration: skipping unreadable ${file}: ${err.message}`);
 	        continue;
 	      }
 	      let issueChanged = false;
@@ -137,12 +144,13 @@ function requireState () {
 	      if (issueChanged) {
 	        try {
 	          fs.writeFileSync(filePath, JSON.stringify(issueState, null, 2), "utf-8");
-	        } catch {
+	        } catch (err) {
+	          warnings.push(`migration: failed to write ${file}: ${err.message}`);
 	        }
 	      }
 	    }
 	  }
-	  return existing;
+	  return { state: existing, warnings };
 	}
 	function resolveActiveMilestoneIndex(state) {
 	  if (!state) return -1;
@@ -157,6 +165,159 @@ function requireState () {
 	  }
 	  return -1;
 	}
+	const VALID_LINK_TYPES = /* @__PURE__ */ new Set(["related", "implements", "tracks", "maps-to", "blocked-by"]);
+	function loadCrossRefs() {
+	  const filePath = path.join(getMgwDir(), "cross-refs.json");
+	  const warnings = [];
+	  if (!fs.existsSync(filePath)) {
+	    return { links: [], warnings: [] };
+	  }
+	  let raw;
+	  try {
+	    raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	  } catch (err) {
+	    return { links: [], warnings: [`cross-refs.json parse error: ${err.message}`] };
+	  }
+	  if (!raw || !Array.isArray(raw.links)) {
+	    return { links: [], warnings: ["cross-refs.json missing links array"] };
+	  }
+	  const validLinks = [];
+	  for (let i = 0; i < raw.links.length; i++) {
+	    const link = raw.links[i];
+	    const issues = [];
+	    if (!link || typeof link !== "object") {
+	      warnings.push(`cross-refs link[${i}]: not an object, skipping`);
+	      continue;
+	    }
+	    if (typeof link.a !== "string" || !link.a) {
+	      issues.push('missing "a"');
+	    }
+	    if (typeof link.b !== "string" || !link.b) {
+	      issues.push('missing "b"');
+	    }
+	    if (link.type && !VALID_LINK_TYPES.has(link.type)) {
+	      issues.push(`unknown type "${link.type}"`);
+	    }
+	    if (issues.length > 0) {
+	      warnings.push(`cross-refs link[${i}]: ${issues.join(", ")}, skipping`);
+	      continue;
+	    }
+	    validLinks.push(link);
+	  }
+	  return { links: validLinks, warnings };
+	}
+	function parseDependencies(body) {
+	  if (!body || typeof body !== "string") return [];
+	  const deps = /* @__PURE__ */ new Set();
+	  const linePattern = /(?:depends[\s-]*on|blocked[\s-]*by)[:\s]+([^\n]+)/gi;
+	  let match;
+	  while ((match = linePattern.exec(body)) !== null) {
+	    const refs = match[1];
+	    const numPattern = /#(\d+)/g;
+	    let numMatch;
+	    while ((numMatch = numPattern.exec(refs)) !== null) {
+	      deps.add(parseInt(numMatch[1], 10));
+	    }
+	  }
+	  return Array.from(deps).sort((a, b) => a - b);
+	}
+	function storeDependencies(issueNumber, dependsOn) {
+	  if (!dependsOn || dependsOn.length === 0) return { added: 0, existing: 0 };
+	  const crossRefsPath = path.join(getMgwDir(), "cross-refs.json");
+	  let crossRefs = { links: [] };
+	  if (fs.existsSync(crossRefsPath)) {
+	    try {
+	      crossRefs = JSON.parse(fs.readFileSync(crossRefsPath, "utf-8"));
+	      if (!Array.isArray(crossRefs.links)) crossRefs.links = [];
+	    } catch {
+	      crossRefs = { links: [] };
+	    }
+	  }
+	  let added = 0;
+	  let existing = 0;
+	  const issueRef = `#${issueNumber}`;
+	  for (const dep of dependsOn) {
+	    const depRef = `#${dep}`;
+	    const alreadyExists = crossRefs.links.some(
+	      (l) => l.a === issueRef && l.b === depRef && l.type === "blocked-by"
+	    );
+	    if (alreadyExists) {
+	      existing++;
+	      continue;
+	    }
+	    crossRefs.links.push({
+	      a: issueRef,
+	      b: depRef,
+	      type: "blocked-by",
+	      created: (/* @__PURE__ */ new Date()).toISOString()
+	    });
+	    added++;
+	  }
+	  if (added > 0) {
+	    const mgwDir = getMgwDir();
+	    if (!fs.existsSync(mgwDir)) {
+	      fs.mkdirSync(mgwDir, { recursive: true });
+	    }
+	    fs.writeFileSync(crossRefsPath, JSON.stringify(crossRefs, null, 2), "utf-8");
+	  }
+	  return { added, existing };
+	}
+	function topologicalSort(issues, links) {
+	  if (!issues || issues.length === 0) return [];
+	  if (!links || links.length === 0) return [...issues];
+	  const deps = /* @__PURE__ */ new Map();
+	  const issueSet = new Set(issues.map((i) => i.number));
+	  for (const issue of issues) {
+	    deps.set(issue.number, /* @__PURE__ */ new Set());
+	  }
+	  for (const link of links) {
+	    if (link.type !== "blocked-by") continue;
+	    const aMatch = String(link.a).match(/#(\d+)/);
+	    const bMatch = String(link.b).match(/#(\d+)/);
+	    if (!aMatch || !bMatch) continue;
+	    const a = parseInt(aMatch[1], 10);
+	    const b = parseInt(bMatch[1], 10);
+	    if (issueSet.has(a) && issueSet.has(b) && deps.has(a)) {
+	      deps.get(a).add(b);
+	    }
+	  }
+	  const inDegree = /* @__PURE__ */ new Map();
+	  for (const issue of issues) {
+	    inDegree.set(issue.number, deps.get(issue.number).size);
+	  }
+	  const queue = [];
+	  for (const [num, degree] of inDegree) {
+	    if (degree === 0) queue.push(num);
+	  }
+	  const issueMap = new Map(issues.map((i) => [i.number, i]));
+	  const sorted = [];
+	  while (queue.length > 0) {
+	    queue.sort((a, b) => {
+	      const idxA = issues.findIndex((i) => i.number === a);
+	      const idxB = issues.findIndex((i) => i.number === b);
+	      return idxA - idxB;
+	    });
+	    const num = queue.shift();
+	    sorted.push(issueMap.get(num));
+	    for (const [dependent, depSet] of deps) {
+	      if (depSet.has(num)) {
+	        depSet.delete(num);
+	        inDegree.set(dependent, inDegree.get(dependent) - 1);
+	        if (inDegree.get(dependent) === 0) {
+	          queue.push(dependent);
+	        }
+	      }
+	    }
+	  }
+	  if (sorted.length < issues.length) {
+	    for (const issue of issues) {
+	      if (!sorted.includes(issue)) {
+	        sorted.push(issue);
+	      }
+	    }
+	  }
+	  return sorted;
+	}
 	state = {
 	  getMgwDir,
 	  getActiveDir,
@@ -166,34 +327,312 @@ function requireState () {
 	  loadActiveIssue,
 	  mergeProjectState,
 	  migrateProjectState,
-	  resolveActiveMilestoneIndex
+	  resolveActiveMilestoneIndex,
+	  loadCrossRefs,
+	  VALID_LINK_TYPES,
+	  parseDependencies,
+	  storeDependencies,
+	  topologicalSort
 	};
 	return state;
 }
 
+var errors;
+var hasRequiredErrors;
+
+function requireErrors () {
+	if (hasRequiredErrors) return errors;
+	hasRequiredErrors = 1;
+	class MgwError extends Error {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {string} [opts.code] - Machine-readable error code
+	   * @param {string} [opts.stage] - Pipeline stage where error occurred
+	   * @param {number} [opts.issueNumber] - Related GitHub issue number
+	   * @param {Error}  [opts.cause] - Original error
+	   */
+	  constructor(message, opts) {
+	    super(message);
+	    this.name = "MgwError";
+	    const o = opts || {};
+	    this.code = o.code || "MGW_ERROR";
+	    this.stage = o.stage || null;
+	    this.issueNumber = o.issueNumber || null;
+	    if (o.cause) this.cause = o.cause;
+	  }
+	}
+	class GitHubApiError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {number} [opts.status] - HTTP status code
+	   * @param {string} [opts.endpoint] - API endpoint or gh subcommand
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, { code: "GITHUB_API_ERROR", ...o });
+	    this.name = "GitHubApiError";
+	    this.status = o.status || null;
+	    this.endpoint = o.endpoint || null;
+	  }
+	}
+	class GsdToolError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {string} [opts.command] - GSD subcommand that failed
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, { code: "GSD_TOOL_ERROR", ...o });
+	    this.name = "GsdToolError";
+	    this.command = o.command || null;
+	  }
+	}
+	class StateError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {string} [opts.filePath] - State file path
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, { code: "STATE_ERROR", ...o });
+	    this.name = "StateError";
+	    this.filePath = o.filePath || null;
+	  }
+	}
+	class TimeoutError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {number} [opts.timeoutMs] - Timeout duration in milliseconds
+	   * @param {string} [opts.operation] - Description of the timed-out operation
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, { code: "TIMEOUT_ERROR", ...o });
+	    this.name = "TimeoutError";
+	    this.timeoutMs = o.timeoutMs || null;
+	    this.operation = o.operation || null;
+	  }
+	}
+	class ClaudeNotAvailableError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {'not-installed'|'not-authenticated'|'check-failed'} [opts.reason]
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, { code: "CLAUDE_NOT_AVAILABLE", ...o });
+	    this.name = "ClaudeNotAvailableError";
+	    this.reason = o.reason || null;
+	  }
+	}
+	errors = {
+	  MgwError,
+	  GitHubApiError,
+	  GsdToolError,
+	  StateError,
+	  TimeoutError,
+	  ClaudeNotAvailableError
+	};
+	return errors;
+}
+
+var retry;
+var hasRequiredRetry;
+
+function requireRetry () {
+	if (hasRequiredRetry) return retry;
+	hasRequiredRetry = 1;
+	const MAX_RETRIES = 3;
+	const BACKOFF_BASE_MS = 5e3;
+	const BACKOFF_MAX_MS = 3e5;
+	const TRANSIENT_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+	const TRANSIENT_MESSAGE_PATTERNS = [
+	  "network timeout",
+	  "econnreset",
+	  "econnrefused",
+	  "etimedout",
+	  "socket hang up",
+	  "worktree lock",
+	  "model overload",
+	  "rate limit",
+	  "too many requests",
+	  "service unavailable",
+	  "bad gateway",
+	  "gateway timeout"
+	];
+	const NEEDS_INFO_MESSAGE_PATTERNS = [
+	  "ambiguous",
+	  "missing required field",
+	  "contradictory requirements",
+	  "issue body"
+	];
+	function classifyFailure(error) {
+	  if (!error || typeof error !== "object") {
+	    return { class: "permanent", reason: "no error object provided" };
+	  }
+	  const status = error.status;
+	  const message = (error.message || "").toLowerCase();
+	  const code = (error.code || "").toLowerCase();
+	  if (typeof status === "number") {
+	    if (status === 429) {
+	      return { class: "transient", reason: "rate limit (HTTP 429)" };
+	    }
+	    if (TRANSIENT_STATUS_CODES.has(status)) {
+	      return { class: "transient", reason: `server error (HTTP ${status})` };
+	    }
+	    if (status === 403) {
+	      return { class: "permanent", reason: "forbidden (HTTP 403 \u2014 non-rate-limit)" };
+	    }
+	    if (status >= 400 && status < 500) {
+	      return { class: "permanent", reason: `client error (HTTP ${status})` };
+	    }
+	  }
+	  if (code) {
+	    const networkCodes = /* @__PURE__ */ new Set([
+	      "econnreset",
+	      "econnrefused",
+	      "etimedout",
+	      "enotfound",
+	      "epipe"
+	    ]);
+	    if (networkCodes.has(code)) {
+	      return { class: "transient", reason: `network error (${code.toUpperCase()})` };
+	    }
+	    if (code === "enoent") {
+	      return { class: "permanent", reason: "file not found (ENOENT) \u2014 GSD tools may be missing" };
+	    }
+	  }
+	  for (const pattern of TRANSIENT_MESSAGE_PATTERNS) {
+	    if (message.includes(pattern)) {
+	      return { class: "transient", reason: `transient condition detected: "${pattern}"` };
+	    }
+	  }
+	  for (const pattern of NEEDS_INFO_MESSAGE_PATTERNS) {
+	    if (message.includes(pattern)) {
+	      return { class: "needs-info", reason: `issue requires clarification: "${pattern}"` };
+	    }
+	  }
+	  return {
+	    class: "permanent",
+	    reason: "unknown error \u2014 classified as permanent to prevent runaway retries"
+	  };
+	}
+	function canRetry(issueState) {
+	  if (!issueState || typeof issueState !== "object") return false;
+	  if (issueState.dead_letter === true) return false;
+	  const count = typeof issueState.retry_count === "number" ? issueState.retry_count : 0;
+	  return count < MAX_RETRIES;
+	}
+	function incrementRetry(issueState) {
+	  const current = typeof issueState.retry_count === "number" ? issueState.retry_count : 0;
+	  return Object.assign({}, issueState, { retry_count: current + 1 });
+	}
+	function resetRetryState(issueState) {
+	  return Object.assign({}, issueState, {
+	    retry_count: 0,
+	    last_failure_class: null,
+	    dead_letter: false
+	  });
+	}
+	function getBackoffMs(retryCount) {
+	  const count = Math.max(0, Math.floor(retryCount));
+	  const base = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * Math.pow(2, count));
+	  return Math.floor(Math.random() * (base + 1));
+	}
+	async function withRetry(fn, opts) {
+	  const o = opts || {};
+	  const maxAttempts = (typeof o.maxRetries === "number" ? o.maxRetries : MAX_RETRIES) + 1;
+	  let lastError;
+	  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+	    try {
+	      return await fn();
+	    } catch (err) {
+	      lastError = err;
+	      if (attempt >= maxAttempts - 1) break;
+	      const classification = classifyFailure(err);
+	      if (classification.class !== "transient") break;
+	      const delayMs = getBackoffMs(attempt);
+	      if (delayMs > 0) {
+	        await new Promise((resolve) => setTimeout(resolve, delayMs));
+	      }
+	    }
+	  }
+	  throw lastError;
+	}
+	retry = {
+	  // Constants
+	  MAX_RETRIES,
+	  BACKOFF_BASE_MS,
+	  BACKOFF_MAX_MS,
+	  // Core functions
+	  classifyFailure,
+	  canRetry,
+	  incrementRetry,
+	  resetRetryState,
+	  getBackoffMs,
+	  withRetry
+	};
+	return retry;
+}
+
 var github;
 var hasRequiredGithub;
 
 function requireGithub () {
 	if (hasRequiredGithub) return github;
 	hasRequiredGithub = 1;
-	const { execSync } = require$$0$1;
+	const { execSync } = require$$0;
+	const { TimeoutError, GitHubApiError } = requireErrors();
+	const { withRetry } = requireRetry();
+	const GH_TIMEOUT_MS = 3e4;
+	function parseHttpStatus(stderr) {
+	  if (!stderr) return null;
+	  const match = stderr.match(/HTTP (\d{3})/);
+	  return match ? parseInt(match[1], 10) : null;
+	}
 	function run(cmd) {
-	  return execSync(cmd, {
-	    encoding: "utf-8",
-	    stdio: ["pipe", "pipe", "pipe"]
-	  }).trim();
+	  try {
+	    return execSync(cmd, {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"],
+	      timeout: GH_TIMEOUT_MS
+	    }).trim();
+	  } catch (err) {
+	    if (err.killed) {
+	      throw new TimeoutError(
+	        `gh command timed out after ${GH_TIMEOUT_MS / 1e3}s: ${cmd.slice(0, 80)}`,
+	        { timeoutMs: GH_TIMEOUT_MS, operation: cmd.slice(0, 120) }
+	      );
+	    }
+	    const stderr = (err.stderr || "").trim();
+	    const httpStatus = parseHttpStatus(stderr);
+	    const ghErr = new GitHubApiError(stderr || err.message, {
+	      cause: err,
+	      status: httpStatus
+	    });
+	    if (err.code) ghErr.code = err.code;
+	    throw ghErr;
+	  }
+	}
+	async function runWithRetry(cmd) {
+	  return withRetry(async () => run(cmd));
 	}
-	function getRepo() {
-	  return run("gh repo view --json nameWithOwner -q .nameWithOwner");
+	async function getRepo() {
+	  return runWithRetry("gh repo view --json nameWithOwner -q .nameWithOwner");
 	}
-	function getIssue(number) {
-	  const raw = run(
+	async function getIssue(number) {
+	  const raw = await runWithRetry(
 	    `gh issue view ${number} --json number,title,state,labels,milestone,assignees,body`
 	  );
 	  return JSON.parse(raw);
 	}
-	function listIssues(filters) {
+	async 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)}`;
@@ -201,16 +640,16 @@ function requireGithub () {
 	  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);
+	  const raw = await runWithRetry(cmd);
 	  return JSON.parse(raw);
 	}
-	function getMilestone(number) {
-	  const repo = getRepo();
-	  const raw = run(`gh api repos/${repo}/milestones/${number}`);
+	async function getMilestone(number) {
+	  const repo = await getRepo();
+	  const raw = await runWithRetry(`gh api repos/${repo}/milestones/${number}`);
 	  return JSON.parse(raw);
 	}
-	function getRateLimit() {
-	  const raw = run("gh api rate_limit");
+	async function getRateLimit() {
+	  const raw = await runWithRetry("gh api rate_limit");
 	  const data = JSON.parse(raw);
 	  const core = data.resources.core;
 	  return {
@@ -219,21 +658,21 @@ function requireGithub () {
 	    reset: core.reset
 	  };
 	}
-	function closeMilestone(repo, number) {
-	  const raw = run(
+	async function closeMilestone(repo, number) {
+	  const raw = await runWithRetry(
 	    `gh api repos/${repo}/milestones/${number} --method PATCH -f state=closed`
 	  );
 	  return JSON.parse(raw);
 	}
-	function createRelease(repo, tag, title, opts) {
+	async 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);
+	  return runWithRetry(cmd);
 	}
-	function getProjectNodeId(owner, projectNumber) {
+	async 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 {
@@ -252,7 +691,7 @@ function requireGithub () {
 	  }
 	  return null;
 	}
-	function findExistingBoard(owner, titlePattern) {
+	async function findExistingBoard(owner, titlePattern) {
 	  const pattern = titlePattern.toLowerCase();
 	  try {
 	    const raw = run(
@@ -274,7 +713,7 @@ function requireGithub () {
 	  }
 	  return null;
 	}
-	function getProjectFields(owner, projectNumber) {
+	async 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;
@@ -352,19 +791,19 @@ function requireGithub () {
 	  }
 	  return Object.keys(fields).length > 0 ? fields : null;
 	}
-	function createProject(owner, title) {
-	  const raw = run(
+	async function createProject(owner, title) {
+	  const raw = await runWithRetry(
 	    `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(
+	async function addItemToProject(owner, projectNumber, issueUrl) {
+	  return runWithRetry(
 	    `gh project item-add ${projectNumber} --owner ${JSON.stringify(owner)} --url ${JSON.stringify(issueUrl)}`
 	  );
 	}
-	function postMilestoneStartAnnouncement(opts) {
+	async function postMilestoneStartAnnouncement(opts) {
 	  const {
 	    repo,
 	    milestoneName,
@@ -435,6 +874,8 @@ function requireGithub () {
 	  return { posted: false, method: "none", url: null };
 	}
 	github = {
+	  GH_TIMEOUT_MS,
+	  run,
 	  getRepo,
 	  getIssue,
 	  listIssues,
@@ -517,15 +958,17 @@ function requireOutput () {
 	return output;
 }
 
-var claude;
-var hasRequiredClaude;
+var providerClaude;
+var hasRequiredProviderClaude;
 
-function requireClaude () {
-	if (hasRequiredClaude) return claude;
-	hasRequiredClaude = 1;
-	const { execSync, spawn } = require$$0$1;
+function requireProviderClaude () {
+	if (hasRequiredProviderClaude) return providerClaude;
+	hasRequiredProviderClaude = 1;
+	const { execSync, spawn } = require$$0;
 	const path = require$$1;
-	const fs = require$$0;
+	const fs = require$$2;
+	const { ClaudeNotAvailableError, TimeoutError } = requireErrors();
+	const PROVIDER_ID = "claude";
 	function getCommandsDir() {
 	  const dir = path.join(__dirname, "..", "commands");
 	  if (!fs.existsSync(dir)) {
@@ -536,37 +979,51 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	  }
 	  return dir;
 	}
-	function assertClaudeAvailable() {
+	function assertAvailable() {
 	  try {
 	    execSync("claude --version", {
 	      encoding: "utf-8",
-	      stdio: ["pipe", "pipe", "pipe"]
+	      stdio: ["pipe", "pipe", "pipe"],
+	      timeout: 1e4
 	    });
 	  } 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"
+	    if (err.killed) {
+	      throw new TimeoutError(
+	        "claude --version timed out after 10s",
+	        { timeoutMs: 1e4, operation: "claude --version" }
 	      );
-	    } else {
-	      console.error(
-	        "Error: claude CLI check failed.\nEnsure claude is installed and on your PATH."
+	    }
+	    if (err.code === "ENOENT") {
+	      throw new ClaudeNotAvailableError(
+	        "claude CLI is not installed.\n\nInstall it with:\n  npm install -g @anthropic-ai/claude-code\n\nThen run:\n  claude login",
+	        { reason: "not-installed" }
 	      );
 	    }
-	    process.exit(1);
+	    throw new ClaudeNotAvailableError(
+	      "claude CLI check failed.\nEnsure claude is installed and on your PATH.",
+	      { reason: "check-failed", cause: err }
+	    );
 	  }
 	  try {
 	    execSync("claude auth status", {
 	      encoding: "utf-8",
-	      stdio: ["pipe", "pipe", "pipe"]
+	      stdio: ["pipe", "pipe", "pipe"],
+	      timeout: 1e4
 	    });
-	  } catch {
-	    console.error(
-	      "Error: claude CLI is not authenticated.\n\nRun:\n  claude login\n\nThen retry your command."
+	  } catch (err) {
+	    if (err.killed) {
+	      throw new TimeoutError(
+	        "claude auth status timed out after 10s",
+	        { timeoutMs: 1e4, operation: "claude auth status" }
+	      );
+	    }
+	    throw new ClaudeNotAvailableError(
+	      "claude CLI is not authenticated.\n\nRun:\n  claude login\n\nThen retry your command.",
+	      { reason: "not-authenticated" }
 	    );
-	    process.exit(1);
 	  }
 	}
-	function invokeClaude(commandFile, userPrompt, opts) {
+	function invoke(commandFile, userPrompt, opts) {
 	  const o = opts || {};
 	  const args = ["-p"];
 	  if (commandFile) {
@@ -587,6 +1044,10 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	    const stdio = o.quiet ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
 	    const child = spawn("claude", args, { stdio });
 	    let output = "";
+	    const sigintHandler = () => {
+	      child.kill("SIGINT");
+	    };
+	    process.on("SIGINT", sigintHandler);
 	    if (o.quiet) {
 	      child.stdout.on("data", (chunk) => {
 	        output += chunk.toString();
@@ -596,23 +1057,220 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	      });
 	    }
 	    child.on("error", (err) => {
+	      process.removeListener("SIGINT", sigintHandler);
 	      if (err.code === "ENOENT") {
-	        reject(new Error("claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
+	        reject(new ClaudeNotAvailableError(
+	          "claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code",
+	          { reason: "not-installed" }
+	        ));
 	      } else {
 	        reject(err);
 	      }
 	    });
 	    child.on("close", (code) => {
+	      process.removeListener("SIGINT", sigintHandler);
+	      resolve({ exitCode: code || 0, output });
+	    });
+	  });
+	}
+	providerClaude = { PROVIDER_ID, assertAvailable, invoke, getCommandsDir };
+	return providerClaude;
+}
+
+var providerGemini;
+var hasRequiredProviderGemini;
+
+function requireProviderGemini () {
+	if (hasRequiredProviderGemini) return providerGemini;
+	hasRequiredProviderGemini = 1;
+	const { execSync, spawn } = require$$0;
+	const path = require$$1;
+	const fs = require$$2;
+	const os = require$$3;
+	const PROVIDER_ID = "gemini";
+	function getCommandsDir() {
+	  const dir = path.join(os.homedir(), ".gemini", "commands", "mgw");
+	  if (!fs.existsSync(dir)) {
+	    throw new Error(
+	      `Commands directory not found at: ${dir}
+Run: node bin/mgw-install.cjs --provider gemini
+(or reinstall the mgw package to trigger postinstall)`
+	    );
+	  }
+	  return dir;
+	}
+	function assertAvailable() {
+	  try {
+	    execSync("gemini --version", {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"]
+	    });
+	  } catch (err) {
+	    if (err.code === "ENOENT") {
+	      console.error(
+	        "Error: gemini CLI is not installed.\n\nInstall it with:\n  npm install -g @google/gemini-cli\n\nThen run:\n  gemini auth"
+	      );
+	    } else {
+	      console.error(
+	        "Error: gemini CLI check failed.\nEnsure gemini is installed and on your PATH."
+	      );
+	    }
+	    process.exit(1);
+	  }
+	}
+	function invoke(commandFile, userPrompt, opts) {
+	  const o = opts || {};
+	  if (o.dryRun) {
+	    const dryArgs = ["-p"];
+	    if (o.model) dryArgs.push("--model", o.model);
+	    dryArgs.push(commandFile ? "<system>" + commandFile + "</system> " + (userPrompt || "run") : userPrompt || "run");
+	    console.log("Would invoke: gemini " + dryArgs.join(" "));
+	    return Promise.resolve({ exitCode: 0, output: "" });
+	  }
+	  let effectivePrompt = userPrompt || "run";
+	  if (commandFile) {
+	    const fileContents = fs.readFileSync(commandFile, "utf-8");
+	    effectivePrompt = "<system>\n" + fileContents + "\n</system>\n\n" + effectivePrompt;
+	  }
+	  const args = ["-p"];
+	  if (o.model) {
+	    args.push("--model", o.model);
+	  }
+	  args.push(effectivePrompt);
+	  return new Promise((resolve, reject) => {
+	    const stdio = o.quiet ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+	    const child = spawn("gemini", args, { stdio });
+	    let output = "";
+	    if (o.quiet) {
+	      child.stdout.on("data", function(chunk) {
+	        output += chunk.toString();
+	      });
+	      child.stderr.on("data", function(chunk) {
+	        output += chunk.toString();
+	      });
+	    }
+	    child.on("error", function(err) {
+	      if (err.code === "ENOENT") {
+	        reject(new Error("gemini CLI not found. Install with: npm install -g @google/gemini-cli"));
+	      } else {
+	        reject(err);
+	      }
+	    });
+	    child.on("close", function(code) {
 	      resolve({ exitCode: code || 0, output });
 	    });
 	  });
 	}
-	claude = {
-	  assertClaudeAvailable,
-	  invokeClaude,
-	  getCommandsDir
+	providerGemini = { PROVIDER_ID, assertAvailable, invoke, getCommandsDir };
+	return providerGemini;
+}
+
+var providerOpencode;
+var hasRequiredProviderOpencode;
+
+function requireProviderOpencode () {
+	if (hasRequiredProviderOpencode) return providerOpencode;
+	hasRequiredProviderOpencode = 1;
+	const { execSync, spawn } = require$$0;
+	const path = require$$1;
+	const fs = require$$2;
+	const os = require$$3;
+	const PROVIDER_ID = "opencode";
+	function getCommandsDir() {
+	  const dir = path.join(os.homedir(), ".opencode", "commands", "mgw");
+	  if (!fs.existsSync(dir)) {
+	    throw new Error(
+	      "Commands directory not found at: " + dir + "\nRun: node bin/mgw-install.cjs --provider opencode\n(or reinstall the mgw package to trigger postinstall)"
+	    );
+	  }
+	  return dir;
+	}
+	function assertAvailable() {
+	  try {
+	    execSync("opencode --version", {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"]
+	    });
+	  } catch (err) {
+	    if (err.code === "ENOENT") {
+	      console.error(
+	        "Error: opencode CLI is not installed.\n\nInstall it with:\n  npm install -g opencode-ai\n\n(or see https://opencode.ai for installation instructions)"
+	      );
+	    } else {
+	      console.error(
+	        "Error: opencode CLI check failed.\nEnsure opencode is installed and on your PATH."
+	      );
+	    }
+	    process.exit(1);
+	  }
+	}
+	function invoke(commandFile, userPrompt, opts) {
+	  const o = opts || {};
+	  const args = ["run"];
+	  if (commandFile) {
+	    args.push("--system-prompt", commandFile);
+	  }
+	  if (o.model) {
+	    args.push("--model", o.model);
+	  }
+	  args.push(userPrompt || "run");
+	  if (o.dryRun) {
+	    console.log("Would invoke: opencode " + args.join(" "));
+	    return Promise.resolve({ exitCode: 0, output: "" });
+	  }
+	  return new Promise(function(resolve, reject) {
+	    const stdio = o.quiet ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+	    const child = spawn("opencode", args, { stdio });
+	    let output = "";
+	    if (o.quiet) {
+	      child.stdout.on("data", function(chunk) {
+	        output += chunk.toString();
+	      });
+	      child.stderr.on("data", function(chunk) {
+	        output += chunk.toString();
+	      });
+	    }
+	    child.on("error", function(err) {
+	      if (err.code === "ENOENT") {
+	        reject(new Error("opencode CLI not found. See https://opencode.ai for installation instructions."));
+	      } else {
+	        reject(err);
+	      }
+	    });
+	    child.on("close", function(code) {
+	      resolve({ exitCode: code || 0, output });
+	    });
+	  });
+	}
+	providerOpencode = { PROVIDER_ID, assertAvailable, invoke, getCommandsDir };
+	return providerOpencode;
+}
+
+var providerManager;
+var hasRequiredProviderManager;
+
+function requireProviderManager () {
+	if (hasRequiredProviderManager) return providerManager;
+	hasRequiredProviderManager = 1;
+	const registry = {
+	  claude: requireProviderClaude(),
+	  gemini: requireProviderGemini(),
+	  opencode: requireProviderOpencode()
 	};
-	return claude;
+	function getProvider(providerId) {
+	  const id = providerId || "claude";
+	  const provider = registry[id];
+	  if (!provider) {
+	    const available = Object.keys(registry).join(", ");
+	    throw new Error(`Unknown provider: "${id}". Available: ${available}`);
+	  }
+	  return provider;
+	}
+	function listProviders() {
+	  return Object.keys(registry);
+	}
+	providerManager = { ProviderManager: { getProvider, listProviders } };
+	return providerManager;
 }
 
 var spinner;
@@ -716,6 +1374,160 @@ function requireSpinner () {
 	return spinner;
 }
 
+var logger;
+var hasRequiredLogger;
+
+function requireLogger () {
+	if (hasRequiredLogger) return logger;
+	hasRequiredLogger = 1;
+	const path = require$$1;
+	const fs = require$$2;
+	function getLogDir(repoRoot) {
+	  const root = repoRoot || process.cwd();
+	  const logDir = path.join(root, ".mgw", "logs");
+	  if (!fs.existsSync(logDir)) {
+	    fs.mkdirSync(logDir, { recursive: true });
+	  }
+	  return logDir;
+	}
+	function getLogFile(repoRoot) {
+	  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	  return path.join(getLogDir(repoRoot), `${date}.jsonl`);
+	}
+	function writeLog(entry) {
+	  const { repoRoot, ...rest } = entry;
+	  const record = {
+	    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+	    ...rest
+	  };
+	  try {
+	    const logFile = getLogFile(repoRoot);
+	    fs.appendFileSync(logFile, JSON.stringify(record) + "\n");
+	  } catch {
+	  }
+	}
+	function startTimer(entry) {
+	  const start = Date.now();
+	  return {
+	    finish(status, errorMsg) {
+	      writeLog({
+	        ...entry,
+	        duration_ms: Date.now() - start,
+	        status,
+	        error: errorMsg || void 0
+	      });
+	    }
+	  };
+	}
+	function readLogs(opts) {
+	  const o = opts || {};
+	  const logDir = getLogDir(o.repoRoot);
+	  if (!fs.existsSync(logDir)) return [];
+	  let sinceDate = null;
+	  if (o.since) {
+	    const relativeMatch = o.since.match(/^(\d+)d$/);
+	    if (relativeMatch) {
+	      sinceDate = /* @__PURE__ */ new Date();
+	      sinceDate.setDate(sinceDate.getDate() - parseInt(relativeMatch[1], 10));
+	    } else {
+	      sinceDate = new Date(o.since);
+	    }
+	  }
+	  let files;
+	  try {
+	    files = fs.readdirSync(logDir).filter((f) => f.endsWith(".jsonl")).sort();
+	  } catch {
+	    return [];
+	  }
+	  if (sinceDate) {
+	    const sinceStr = sinceDate.toISOString().slice(0, 10);
+	    files = files.filter((f) => f.replace(".jsonl", "") >= sinceStr);
+	  }
+	  const entries = [];
+	  for (const file of files) {
+	    const filePath = path.join(logDir, file);
+	    let content;
+	    try {
+	      content = fs.readFileSync(filePath, "utf-8");
+	    } catch {
+	      continue;
+	    }
+	    for (const line of content.split("\n")) {
+	      if (!line.trim()) continue;
+	      let entry;
+	      try {
+	        entry = JSON.parse(line);
+	      } catch {
+	        continue;
+	      }
+	      if (o.issue && entry.issue !== o.issue) continue;
+	      if (o.command && entry.command !== o.command) continue;
+	      if (o.stage && entry.stage !== o.stage) continue;
+	      entries.push(entry);
+	    }
+	  }
+	  entries.reverse();
+	  if (o.limit && entries.length > o.limit) {
+	    return entries.slice(0, o.limit);
+	  }
+	  return entries;
+	}
+	function aggregateMetrics(entries) {
+	  if (!entries || entries.length === 0) {
+	    return {
+	      total: 0,
+	      byStatus: {},
+	      byCommand: {},
+	      avgDuration: 0,
+	      failureRate: 0
+	    };
+	  }
+	  const byStatus = {};
+	  const byCommand = {};
+	  let totalDuration = 0;
+	  let durationCount = 0;
+	  let failures = 0;
+	  for (const e of entries) {
+	    byStatus[e.status] = (byStatus[e.status] || 0) + 1;
+	    if (e.status === "error") failures++;
+	    if (e.command) {
+	      if (!byCommand[e.command]) {
+	        byCommand[e.command] = { count: 0, errors: 0, totalDuration: 0 };
+	      }
+	      byCommand[e.command].count++;
+	      if (e.status === "error") byCommand[e.command].errors++;
+	      if (typeof e.duration_ms === "number") {
+	        byCommand[e.command].totalDuration += e.duration_ms;
+	      }
+	    }
+	    if (typeof e.duration_ms === "number") {
+	      totalDuration += e.duration_ms;
+	      durationCount++;
+	    }
+	  }
+	  for (const cmd of Object.keys(byCommand)) {
+	    const c = byCommand[cmd];
+	    c.avgDuration = c.count > 0 ? Math.round(c.totalDuration / c.count) : 0;
+	  }
+	  return {
+	    total: entries.length,
+	    byStatus,
+	    byCommand,
+	    avgDuration: durationCount > 0 ? Math.round(totalDuration / durationCount) : 0,
+	    failureRate: entries.length > 0 ? Math.round(failures / entries.length * 100) : 0
+	  };
+	}
+	logger = {
+	  getLogDir,
+	  getLogFile,
+	  writeLog,
+	  startTimer,
+	  readLogs,
+	  aggregateMetrics
+	};
+	return logger;
+}
+
 var renderer;
 var hasRequiredRenderer;
 
@@ -1189,7 +2001,7 @@ var hasRequiredKeyboard;
 function requireKeyboard () {
 	if (hasRequiredKeyboard) return keyboard;
 	hasRequiredKeyboard = 1;
-	const { EventEmitter } = require$$0$2;
+	const { EventEmitter } = require$$0$1;
 	const DEFAULT_BINDINGS = {
 	  // Scroll
 	  "j": "scroll-down",
@@ -1545,7 +2357,7 @@ function requireGraceful () {
 	  let ms;
 	  try {
 	    ms = Date.now() - new Date(dateStr).getTime();
-	  } catch (e) {
+	  } catch (_e) {
 	    return "-";
 	  }
 	  if (ms < 0) return "now";
@@ -1808,9 +2620,13 @@ function requireTui () {
 }
 
 exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
-exports.requireClaude = requireClaude;
+exports.requireErrors = requireErrors;
 exports.requireGithub = requireGithub;
+exports.requireLogger = requireLogger;
 exports.requireOutput = requireOutput;
+exports.requireProviderClaude = requireProviderClaude;
+exports.requireProviderManager = requireProviderManager;
+exports.requireRetry = requireRetry;
 exports.requireSpinner = requireSpinner;
 exports.requireState = requireState;
 exports.requireTui = requireTui;