@snipcodeit/mgw 0.3.0 → 0.6.0

package/dist/{index-s7v-ifd0.cjs → index-CHrVAIMY.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");
@@ -140,6 +141,10 @@ function requireState () {
 	        issueState.dead_letter = false;
 	        issueChanged = true;
 	      }
+	      if (!issueState.hasOwnProperty("checkpoint")) {
+	        issueState.checkpoint = null;
+	        issueChanged = true;
+	      }
 	      if (issueChanged) {
 	        try {
 	          fs.writeFileSync(filePath, JSON.stringify(issueState, null, 2), "utf-8");
@@ -164,6 +169,148 @@ function requireState () {
 	  }
 	  return -1;
 	}
+	const CHECKPOINT_SCHEMA_VERSION = 1;
+	const CHECKPOINT_STEP_ORDER = ["triage", "plan", "execute", "verify", "pr"];
+	function initCheckpoint(pipelineStep) {
+	  const now = (/* @__PURE__ */ new Date()).toISOString();
+	  return {
+	    schema_version: CHECKPOINT_SCHEMA_VERSION,
+	    pipeline_step: pipelineStep || "triage",
+	    step_progress: {},
+	    last_agent_output: null,
+	    artifacts: [],
+	    resume: {
+	      action: null,
+	      context: {}
+	    },
+	    started_at: now,
+	    updated_at: now,
+	    step_history: []
+	  };
+	}
+	function detectCheckpoint(issueNumber) {
+	  const issueState = loadActiveIssue(issueNumber);
+	  if (!issueState) return null;
+	  const cp = issueState.checkpoint;
+	  if (!cp || typeof cp !== "object") return null;
+	  const step = cp.pipeline_step || "triage";
+	  const stepIndex = CHECKPOINT_STEP_ORDER.indexOf(step);
+	  if (stepIndex <= 0) return null;
+	  return {
+	    pipeline_step: cp.pipeline_step,
+	    step_progress: cp.step_progress || {},
+	    artifacts: cp.artifacts || [],
+	    resume: cp.resume || { action: null, context: {} },
+	    started_at: cp.started_at || null,
+	    updated_at: cp.updated_at || null,
+	    step_history: cp.step_history || []
+	  };
+	}
+	function resumeFromCheckpoint(issueNumber) {
+	  const cp = detectCheckpoint(issueNumber);
+	  if (!cp) return null;
+	  const action = cp.resume && cp.resume.action || null;
+	  const actionToStage = {
+	    "run-plan-checker": "planning",
+	    "spawn-executor": "executing",
+	    "continue-execution": "executing",
+	    "spawn-verifier": "verifying",
+	    "create-pr": "pr-pending",
+	    "begin-execution": "planning"
+	  };
+	  const resumeStage = actionToStage[action] || "planning";
+	  const completedSteps = (cp.step_history || []).map((entry) => entry.step).filter(Boolean);
+	  return {
+	    checkpoint: cp,
+	    resumeStage,
+	    resumeAction: action || "unknown",
+	    completedSteps
+	  };
+	}
+	function atomicWriteJson(filePath, data) {
+	  const tmpPath = filePath + ".tmp";
+	  const content = JSON.stringify(data, null, 2);
+	  fs.writeFileSync(tmpPath, content, "utf-8");
+	  fs.renameSync(tmpPath, filePath);
+	}
+	function clearCheckpoint(issueNumber) {
+	  const activeDir = getActiveDir();
+	  if (!fs.existsSync(activeDir)) {
+	    throw new Error(`No active directory found. Cannot clear checkpoint for #${issueNumber}.`);
+	  }
+	  const prefix = String(issueNumber) + "-";
+	  let entries;
+	  try {
+	    entries = fs.readdirSync(activeDir);
+	  } catch (err) {
+	    throw new Error(`Cannot read active directory: ${err.message}`, { cause: err });
+	  }
+	  const match = entries.find((f) => f.startsWith(prefix) && f.endsWith(".json"));
+	  if (!match) {
+	    throw new Error(`No state file found for issue #${issueNumber}.`);
+	  }
+	  const filePath = path.join(activeDir, match);
+	  let issueState;
+	  try {
+	    issueState = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	  } catch (err) {
+	    throw new Error(`Cannot parse state file for #${issueNumber}: ${err.message}`, { cause: err });
+	  }
+	  const hadCheckpoint = issueState.checkpoint != null;
+	  issueState.checkpoint = null;
+	  atomicWriteJson(filePath, issueState);
+	  return { cleared: hadCheckpoint };
+	}
+	function updateCheckpoint(issueNumber, data) {
+	  const activeDir = getActiveDir();
+	  if (!fs.existsSync(activeDir)) {
+	    throw new Error(`No active directory found. Cannot update checkpoint for #${issueNumber}.`);
+	  }
+	  const prefix = String(issueNumber) + "-";
+	  let entries;
+	  try {
+	    entries = fs.readdirSync(activeDir);
+	  } catch (err) {
+	    throw new Error(`Cannot read active directory: ${err.message}`, { cause: err });
+	  }
+	  const match = entries.find((f) => f.startsWith(prefix) && f.endsWith(".json"));
+	  if (!match) {
+	    throw new Error(`No state file found for issue #${issueNumber}.`);
+	  }
+	  const filePath = path.join(activeDir, match);
+	  let issueState;
+	  try {
+	    issueState = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	  } catch (err) {
+	    throw new Error(`Cannot parse state file for #${issueNumber}: ${err.message}`, { cause: err });
+	  }
+	  if (!issueState.checkpoint || typeof issueState.checkpoint !== "object") {
+	    issueState.checkpoint = initCheckpoint();
+	  }
+	  const cp = issueState.checkpoint;
+	  if (data.pipeline_step !== void 0) {
+	    cp.pipeline_step = data.pipeline_step;
+	  }
+	  if (data.last_agent_output !== void 0) {
+	    cp.last_agent_output = data.last_agent_output;
+	  }
+	  if (data.step_progress && typeof data.step_progress === "object") {
+	    cp.step_progress = Object.assign({}, cp.step_progress, data.step_progress);
+	  }
+	  if (data.resume && typeof data.resume === "object") {
+	    cp.resume = data.resume;
+	  }
+	  if (Array.isArray(data.artifacts) && data.artifacts.length > 0) {
+	    cp.artifacts = (cp.artifacts || []).concat(data.artifacts);
+	  }
+	  if (Array.isArray(data.step_history) && data.step_history.length > 0) {
+	    cp.step_history = (cp.step_history || []).concat(data.step_history);
+	  }
+	  cp.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+	  issueState.checkpoint = cp;
+	  atomicWriteJson(filePath, issueState);
+	  return { updated: true, checkpoint: cp };
+	}
 	const VALID_LINK_TYPES = /* @__PURE__ */ new Set(["related", "implements", "tracks", "maps-to", "blocked-by"]);
 	function loadCrossRefs() {
 	  const filePath = path.join(getMgwDir(), "cross-refs.json");
@@ -317,6 +464,47 @@ function requireState () {
 	  }
 	  return sorted;
 	}
+	function detectProjectState(options = {}) {
+	  const repoRoot = options.repoRoot || process.cwd();
+	  const G = typeof options.githubMilestoneCount === "number" ? options.githubMilestoneCount : 0;
+	  const P = fs.existsSync(path.join(repoRoot, ".planning", "PROJECT.md"));
+	  const R = fs.existsSync(path.join(repoRoot, ".planning", "ROADMAP.md"));
+	  const S = fs.existsSync(path.join(repoRoot, ".planning", "STATE.md"));
+	  const M = fs.existsSync(path.join(repoRoot, ".mgw", "project.json"));
+	  const signals = { P, R, S, M, G };
+	  if (M && G > 0) {
+	    let projectData;
+	    try {
+	      const raw = fs.readFileSync(path.join(repoRoot, ".mgw", "project.json"), "utf-8");
+	      projectData = JSON.parse(raw);
+	    } catch (_e) {
+	      return { stateClass: "Diverged", signals };
+	    }
+	    const milestones = Array.isArray(projectData.milestones) ? projectData.milestones : [];
+	    const currentMilestone = typeof projectData.current_milestone === "number" ? projectData.current_milestone : 1;
+	    const allComplete = milestones.length > 0 && currentMilestone > milestones.length;
+	    if (allComplete) {
+	      return { stateClass: "Extend", signals };
+	    }
+	    const localCount = milestones.length;
+	    const countDiff = Math.abs(localCount - G);
+	    if (countDiff <= 1) {
+	      return { stateClass: "Aligned", signals };
+	    } else {
+	      return { stateClass: "Diverged", signals };
+	    }
+	  }
+	  if (!M && G === 0) {
+	    if (P && (R || S)) {
+	      return { stateClass: "GSD-Mid-Exec", signals };
+	    }
+	    if (P) {
+	      return { stateClass: "GSD-Only", signals };
+	    }
+	    return { stateClass: "Fresh", signals };
+	  }
+	  return { stateClass: "Fresh", signals };
+	}
 	state = {
 	  getMgwDir,
 	  getActiveDir,
@@ -327,11 +515,20 @@ function requireState () {
 	  mergeProjectState,
 	  migrateProjectState,
 	  resolveActiveMilestoneIndex,
+	  CHECKPOINT_SCHEMA_VERSION,
+	  CHECKPOINT_STEP_ORDER,
+	  initCheckpoint,
+	  atomicWriteJson,
+	  detectCheckpoint,
+	  resumeFromCheckpoint,
+	  clearCheckpoint,
+	  updateCheckpoint,
 	  loadCrossRefs,
 	  VALID_LINK_TYPES,
 	  parseDependencies,
 	  storeDependencies,
-	  topologicalSort
+	  topologicalSort,
+	  detectProjectState
 	};
 	return state;
 }
@@ -586,7 +783,7 @@ 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;
@@ -957,16 +1154,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)) {
@@ -977,7 +1175,7 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	  }
 	  return dir;
 	}
-	function assertClaudeAvailable() {
+	function assertAvailable() {
 	  try {
 	    execSync("claude --version", {
 	      encoding: "utf-8",
@@ -1021,7 +1219,7 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	    );
 	  }
 	}
-	function invokeClaude(commandFile, userPrompt, opts) {
+	function invoke(commandFile, userPrompt, opts) {
 	  const o = opts || {};
 	  const args = ["-p"];
 	  if (commandFile) {
@@ -1071,12 +1269,204 @@ This may indicate a corrupted installation. Try reinstalling mgw.`
 	    });
 	  });
 	}
-	claude = {
-	  assertClaudeAvailable,
-	  invokeClaude,
-	  getCommandsDir
+	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 });
+	    });
+	  });
+	}
+	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;
@@ -1187,7 +1577,7 @@ function requireLogger () {
 	if (hasRequiredLogger) return logger;
 	hasRequiredLogger = 1;
 	const path = require$$1;
-	const fs = require$$0;
+	const fs = require$$2;
 	function getLogDir(repoRoot) {
 	  const root = repoRoot || process.cwd();
 	  const logDir = path.join(root, ".mgw", "logs");
@@ -1807,7 +2197,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",
@@ -2426,11 +2816,12 @@ 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;