@snipcodeit/mgw 0.4.0 → 0.6.0

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

@@ -141,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");
@@ -165,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");
@@ -318,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,
@@ -328,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;
 }