maxsimcli 4.9.0 → 4.11.0

package/dist/mcp-server.cjs

@@ -39,6 +39,7 @@ let child_process = require("child_process");
 require("node:events");
 let node_child_process = require("node:child_process");
 let node_util = require("node:util");
+let node_crypto = require("node:crypto");
 
 //#region ../../node_modules/zod/v3/helpers/util.js
 var util$2;
@@ -38059,9 +38060,9 @@ async function postPlanComment(phaseIssueNumber, planNumber, planContent) {
 /**
 * Close an issue. Optionally post a reason comment before closing.
 *
-* Uses `state_reason: 'completed'` by default.
+* @param stateReason - 'completed' (default) or 'not_planned' (rollback/cancel)
 */
-async function closeIssue(issueNumber, reason) {
+async function closeIssue(issueNumber, reason, stateReason = "completed") {
 	return withGhResult(async () => {
 		const octokit = getOctokit();
 		const { owner, repo } = await getRepoInfo();
@@ -38076,7 +38077,7 @@ async function closeIssue(issueNumber, reason) {
 			repo,
 			issue_number: issueNumber,
 			state: "closed",
-			state_reason: "completed"
+			state_reason: stateReason
 		});
 	});
 }
@@ -38098,7 +38099,7 @@ async function reopenIssue(issueNumber) {
 /**
 * Fetch a single issue by number.
 *
-* Returns number, id, title, state, and body.
+* Returns number, id, title, state, body, updated_at, labels, and comments_url.
 */
 async function getPhaseIssue(phaseIssueNumber) {
 	return withGhResult(async () => {
@@ -38109,12 +38110,16 @@ async function getPhaseIssue(phaseIssueNumber) {
 			repo,
 			issue_number: phaseIssueNumber
 		});
+		const labels = response.data.labels.map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean);
 		return {
 			number: response.data.number,
 			id: response.data.id,
 			title: response.data.title,
 			state: response.data.state,
-			body: response.data.body ?? ""
+			body: response.data.body ?? "",
+			updated_at: response.data.updated_at,
+			labels,
+			comments_url: response.data.comments_url
 		};
 	});
 }
@@ -38122,7 +38127,7 @@ async function getPhaseIssue(phaseIssueNumber) {
 * List all sub-issues of a phase Issue.
 *
 * Uses GitHub's native sub-issues API.
-* Returns each sub-issue's number, id, title, and state.
+* Returns each sub-issue's number, id, title, state, and updated_at.
 */
 async function listPhaseSubIssues(phaseIssueNumber) {
 	return withGhResult(async () => {
@@ -38136,7 +38141,8 @@ async function listPhaseSubIssues(phaseIssueNumber) {
 			number: issue.number,
 			id: issue.id,
 			title: issue.title,
-			state: issue.state
+			state: issue.state,
+			updated_at: issue.updated_at ?? ""
 		}));
 	});
 }
@@ -38258,6 +38264,13 @@ function mappingFilePath(cwd) {
 	return planningPath(cwd, MAPPING_FILENAME);
 }
 /**
+* Compute a SHA-256 hash of an issue body string.
+* Used for external edit detection (WIRE-06).
+*/
+function hashBody(body) {
+	return (0, node_crypto.createHash)("sha256").update(body).digest("hex");
+}
+/**
 * Load and parse the mapping file (local cache).
 *
 * Returns null if the file does not exist.
@@ -38287,6 +38300,39 @@ function saveMapping(cwd, mapping) {
 	node_fs.default.mkdirSync(dir, { recursive: true });
 	node_fs.default.writeFileSync(filePath, JSON.stringify(mapping, null, 2) + "\n", "utf-8");
 }
+/**
+* Update a specific task's issue mapping within a phase.
+*
+* Load-modify-save pattern. Creates phase entry if it does not exist.
+* Merges partial data with existing entry (if any).
+*
+* @throws If mapping file does not exist (must be initialized first via saveMapping)
+*/
+function updateTaskMapping(cwd, phaseNum, taskId, data) {
+	const mapping = loadMapping(cwd);
+	if (!mapping) throw new Error("github-issues.json does not exist. Run project setup first.");
+	if (!mapping.phases[phaseNum]) mapping.phases[phaseNum] = {
+		tracking_issue: {
+			number: 0,
+			id: 0,
+			node_id: "",
+			item_id: "",
+			status: "To Do"
+		},
+		plan: "",
+		tasks: {}
+	};
+	const existing = mapping.phases[phaseNum].tasks[taskId];
+	const defaults = {
+		number: 0,
+		id: 0,
+		node_id: "",
+		item_id: "",
+		status: "To Do"
+	};
+	mapping.phases[phaseNum].tasks[taskId] = Object.assign(defaults, existing, data);
+	saveMapping(cwd, mapping);
+}
 
 //#endregion
 //#region src/mcp/utils.ts
@@ -40313,10 +40359,24 @@ function registerGitHubTools(server) {
 			}
 			const result = await createPhaseIssue(phase_number, phase_name, goal, requirements, success_criteria);
 			if (!result.ok) return mcpError(`Phase issue creation failed: ${result.error}`, "Creation failed");
-			return mcpSuccess({
+			const responseData = {
 				issue_number: result.data.number,
 				issue_id: result.data.id
-			}, `Created phase issue #${result.data.number}: [Phase ${phase_number}] ${phase_name}`);
+			};
+			const cwd = detectProjectRoot();
+			if (cwd) {
+				const mapping = loadMapping(cwd);
+				if (mapping && mapping.project_number) {
+					const addResult = await addItemToProject(mapping.project_number, result.data.number);
+					if (addResult.ok) {
+						responseData.item_id = addResult.data.itemId;
+						responseData.project_number = mapping.project_number;
+						const moveResult = await moveItemToStatus(mapping.project_number, addResult.data.itemId, "To Do");
+						if (!moveResult.ok) responseData.board_warning = `Added to board but could not set status: ${moveResult.error}`;
+					} else responseData.board_warning = `Issue created but could not add to board: ${addResult.error}`;
+				}
+			}
+			return mcpSuccess(responseData, `Created phase issue #${result.data.number}: [Phase ${phase_number}] ${phase_name}`);
 		} catch (e) {
 			return mcpError(e.message, "Operation failed");
 		}
@@ -40337,11 +40397,24 @@ function registerGitHubTools(server) {
 			}
 			const result = await createTaskSubIssue(phase_number, task_id, title, body, parent_issue_number);
 			if (!result.ok) return mcpError(`Task issue creation failed: ${result.error}`, "Creation failed");
-			return mcpSuccess({
+			const responseData = {
 				issue_number: result.data.number,
 				issue_id: result.data.id,
 				parent_issue_number
-			}, `Created task sub-issue #${result.data.number}: ${title}`);
+			};
+			const cwd = detectProjectRoot();
+			if (cwd) try {
+				updateTaskMapping(cwd, phase_number, task_id, {
+					number: result.data.number,
+					id: result.data.id,
+					node_id: "",
+					item_id: "",
+					status: "To Do"
+				});
+			} catch (mappingErr) {
+				responseData.mapping_warning = `Issue created but mapping update failed: ${mappingErr.message}`;
+			}
+			return mcpSuccess(responseData, `Created task sub-issue #${result.data.number}: ${title}`);
 		} catch (e) {
 			return mcpError(e.message, "Operation failed");
 		}
@@ -40369,10 +40442,11 @@ function registerGitHubTools(server) {
 			return mcpError(e.message, "Operation failed");
 		}
 	});
-	server.tool("mcp_close_issue", "Close a GitHub issue as completed.", {
+	server.tool("mcp_close_issue", "Close a GitHub issue as completed or not planned.", {
 		issue_number: numberType().describe("GitHub issue number"),
-		reason: stringType().optional().describe("Optional reason comment to post before closing")
-	}, async ({ issue_number, reason }) => {
+		reason: stringType().optional().describe("Optional reason comment to post before closing"),
+		state_reason: enumType(["completed", "not_planned"]).optional().default("completed").describe("Close reason: completed (default) or not_planned (rollback)")
+	}, async ({ issue_number, reason, state_reason }) => {
 		try {
 			try {
 				requireAuth();
@@ -40380,12 +40454,13 @@ function registerGitHubTools(server) {
 				if (e instanceof AuthError) return mcpAuthError$1(e);
 				throw e;
 			}
-			const result = await closeIssue(issue_number, reason);
+			const result = await closeIssue(issue_number, reason, state_reason);
 			if (!result.ok) return mcpError(`Close failed: ${result.error}`, "Close failed");
 			return mcpSuccess({
 				issue_number,
-				closed: true
-			}, `Issue #${issue_number} closed`);
+				closed: true,
+				state_reason
+			}, `Issue #${issue_number} closed (${state_reason})`);
 		} catch (e) {
 			return mcpError(e.message, "Operation failed");
 		}
@@ -40424,7 +40499,10 @@ function registerGitHubTools(server) {
 				id: issue.id,
 				title: issue.title,
 				state: issue.state,
-				body: issue.body
+				body: issue.body,
+				updated_at: issue.updated_at,
+				labels: issue.labels,
+				comments_url: issue.comments_url
 			}, `Issue #${issue.number}: ${issue.title} (${issue.state})`);
 		} catch (e) {
 			return mcpError(e.message, "Operation failed");
@@ -40501,6 +40579,136 @@ function registerGitHubTools(server) {
 			return mcpError(e.message, "Operation failed");
 		}
 	});
+	server.tool("mcp_post_comment", "Post a comment on a GitHub issue.", {
+		issue_number: numberType().describe("GitHub issue number"),
+		body: stringType().describe("Comment body (markdown)"),
+		type: enumType([
+			"research",
+			"context",
+			"summary",
+			"verification",
+			"uat",
+			"general"
+		]).optional().describe("Comment type for structured header")
+	}, async ({ issue_number, body, type }) => {
+		try {
+			try {
+				requireAuth();
+			} catch (e) {
+				if (e instanceof AuthError) return mcpAuthError$1(e);
+				throw e;
+			}
+			const result = await postComment(issue_number, type ? `<!-- maxsim:type=${type} -->\n${body}` : body);
+			if (!result.ok) return mcpError(`Comment failed: ${result.error}`, "Comment failed");
+			return mcpSuccess({
+				issue_number,
+				comment_id: result.data.commentId,
+				type: type ?? "general"
+			}, `Comment posted on issue #${issue_number}`);
+		} catch (e) {
+			return mcpError(e.message, "Operation failed");
+		}
+	});
+	server.tool("mcp_batch_create_tasks", "Create multiple task sub-issues for a phase with automatic rollback on failure.", {
+		phase_number: stringType().describe("Phase number (e.g. \"01\")"),
+		parent_issue_number: numberType().describe("Parent phase issue number"),
+		tasks: arrayType(objectType({
+			task_id: stringType().describe("Task ID within the phase"),
+			title: stringType().describe("Task title"),
+			body: stringType().describe("Task body (markdown)")
+		})).describe("List of tasks to create")
+	}, async ({ phase_number, parent_issue_number, tasks }) => {
+		try {
+			try {
+				requireAuth();
+			} catch (e) {
+				if (e instanceof AuthError) return mcpAuthError$1(e);
+				throw e;
+			}
+			const succeeded = [];
+			const failed = [];
+			const created = [];
+			for (const task of tasks) {
+				const result = await createTaskSubIssue(phase_number, task.task_id, task.title, task.body, parent_issue_number);
+				if (result.ok) {
+					created.push({
+						issueNumber: result.data.number,
+						taskId: task.task_id
+					});
+					succeeded.push({
+						task_id: task.task_id,
+						issue_number: result.data.number
+					});
+					const cwd = detectProjectRoot();
+					if (cwd) try {
+						updateTaskMapping(cwd, phase_number, task.task_id, {
+							number: result.data.number,
+							id: result.data.id,
+							node_id: "",
+							item_id: "",
+							status: "To Do"
+						});
+					} catch {}
+				} else {
+					failed.push({
+						task_id: task.task_id,
+						error: result.error
+					});
+					const rolledBack = [];
+					for (const c of [...created].reverse()) if ((await closeIssue(c.issueNumber, "[MAXSIM-ROLLBACK] Partial batch failure", "not_planned")).ok) rolledBack.push(c.issueNumber);
+					return mcpSuccess({
+						succeeded,
+						failed,
+						rolled_back: rolledBack,
+						partial: true
+					}, `Batch failed at task "${task.task_id}". Rolled back ${rolledBack.length} issue(s).`);
+				}
+			}
+			return mcpSuccess({
+				succeeded,
+				failed,
+				rolled_back: [],
+				partial: false
+			}, `Batch created ${succeeded.length} task issue(s) for phase ${phase_number}`);
+		} catch (e) {
+			return mcpError(e.message, "Operation failed");
+		}
+	});
+	server.tool("mcp_detect_external_edits", "Check if a phase issue body was modified outside MAXSIM.", { phase_number: stringType().describe("Phase number (e.g. \"01\")") }, async ({ phase_number }) => {
+		try {
+			try {
+				requireAuth();
+			} catch (e) {
+				if (e instanceof AuthError) return mcpAuthError$1(e);
+				throw e;
+			}
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const mapping = loadMapping(cwd);
+			if (!mapping) return mcpError("github-issues.json not found. Run project setup first.", "Mapping missing");
+			const phaseMapping = mapping.phases[phase_number];
+			if (!phaseMapping) return mcpError(`Phase ${phase_number} not found in mapping`, "Phase not found");
+			const storedHash = phaseMapping.body_hash;
+			const issueNumber = phaseMapping.tracking_issue.number;
+			const issueResult = await getPhaseIssue(issueNumber);
+			if (!issueResult.ok) return mcpError(`Failed to fetch issue #${issueNumber}: ${issueResult.error}`, "Fetch failed");
+			const liveHash = hashBody(issueResult.data.body);
+			if (!storedHash) return mcpSuccess({
+				modified: false,
+				phase_number,
+				issue_number: issueNumber,
+				note: "No stored hash — baseline not yet established"
+			}, `Phase ${phase_number}: no baseline hash stored`);
+			const modified = liveHash !== storedHash;
+			return mcpSuccess({
+				modified,
+				phase_number,
+				issue_number: issueNumber
+			}, modified ? `Phase ${phase_number} issue #${issueNumber} has been externally modified` : `Phase ${phase_number} issue #${issueNumber} matches stored hash`);
+		} catch (e) {
+			return mcpError(e.message, "Operation failed");
+		}
+	});
 }
 
 //#endregion
@@ -40586,6 +40794,57 @@ function registerBoardTools(server) {
 			return mcpError(e.message, "Operation failed");
 		}
 	});
+	server.tool("mcp_sync_check", "Verify local github-issues.json mapping is in sync with live GitHub state.", {}, async () => {
+		try {
+			try {
+				requireAuth();
+			} catch (e) {
+				if (e instanceof AuthError) return mcpAuthError(e);
+				throw e;
+			}
+			const cwd = detectProjectRoot();
+			if (!cwd) return mcpError("No .planning/ directory found", "Project not detected");
+			const mapping = loadMapping(cwd);
+			if (!mapping) return mcpError("github-issues.json not found. Run project setup first.", "Mapping missing");
+			const mismatches = [];
+			const missing_remote = [];
+			for (const [phaseNum, phaseMapping] of Object.entries(mapping.phases)) {
+				const issueNumber = phaseMapping.tracking_issue.number;
+				if (!issueNumber) continue;
+				const issueResult = await getPhaseIssue(issueNumber);
+				if (!issueResult.ok) {
+					if (issueResult.error.includes("NOT_FOUND") || issueResult.error.includes("404")) missing_remote.push({
+						phase_number: phaseNum,
+						issue_number: issueNumber
+					});
+					continue;
+				}
+				const localStatus = phaseMapping.tracking_issue.status;
+				const remoteState = issueResult.data.state;
+				if (remoteState === "closed" && localStatus !== "Done") mismatches.push({
+					phase_number: phaseNum,
+					issue_number: issueNumber,
+					local_state: localStatus,
+					remote_state: remoteState
+				});
+				else if (remoteState === "open" && localStatus === "Done") mismatches.push({
+					phase_number: phaseNum,
+					issue_number: issueNumber,
+					local_state: localStatus,
+					remote_state: remoteState
+				});
+			}
+			const in_sync = mismatches.length === 0 && missing_remote.length === 0;
+			return mcpSuccess({
+				in_sync,
+				mismatches,
+				missing_local: [],
+				missing_remote
+			}, in_sync ? "Local mapping is in sync with GitHub" : `Sync issues found: ${mismatches.length} mismatch(es), ${missing_remote.length} missing remote`);
+		} catch (e) {
+			return mcpError(e.message, "Operation failed");
+		}
+	});
 	server.tool("mcp_search_issues", "Search GitHub issues by label, state, or text query.", {
 		labels: arrayType(stringType()).optional().describe("Filter by label names"),
 		state: enumType([