@snipcodeit/mgw 0.3.0 → 0.4.0

package/dist/lib/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var index$1 = require('../index-s7v-ifd0.cjs');
+var index$1 = require('../index-B-_JvYpz.cjs');
 var require$$0 = require('child_process');
 var require$$1 = require('path');
-var require$$2 = require('os');
-var require$$0$1 = require('fs');
+var require$$3 = require('os');
+var require$$2 = require('fs');
 require('events');
 
 var pipeline;
@@ -153,24 +153,52 @@ function requireGsdAdapter () {
 	hasRequiredGsdAdapter = 1;
 	const { execSync } = require$$0;
 	const path = require$$1;
-	const os = require$$2;
-	const fs = require$$0$1;
+	const os = require$$3;
+	const fs = require$$2;
 	const { TimeoutError, GsdToolError } = index$1.requireErrors();
 	const { STAGES } = requirePipeline();
+	function resolveGsdRoot() {
+	  if (process.env.GSD_TOOLS_PATH) {
+	    return process.env.GSD_TOOLS_PATH;
+	  }
+	  const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	  if (fs.existsSync(configPath)) {
+	    try {
+	      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	      if (config.gsd_path) {
+	        return config.gsd_path;
+	      }
+	    } catch {
+	    }
+	  }
+	  return path.join(os.homedir(), ".claude", "get-shit-done");
+	}
 	function getGsdToolsPath() {
-	  const standard = path.join(
-	    os.homedir(),
-	    ".claude",
-	    "get-shit-done",
-	    "bin",
-	    "gsd-tools.cjs"
-	  );
-	  if (fs.existsSync(standard)) {
-	    return standard;
+	  const root = resolveGsdRoot();
+	  const toolPath = path.join(root, "bin", "gsd-tools.cjs");
+	  if (fs.existsSync(toolPath)) {
+	    return toolPath;
 	  }
+	  const checked = [];
+	  if (process.env.GSD_TOOLS_PATH) {
+	    checked.push(`  GSD_TOOLS_PATH: ${path.join(process.env.GSD_TOOLS_PATH, "bin", "gsd-tools.cjs")}`);
+	  }
+	  const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	  if (fs.existsSync(configPath)) {
+	    try {
+	      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	      if (config.gsd_path) {
+	        checked.push(`  .mgw/config.json gsd_path: ${path.join(config.gsd_path, "bin", "gsd-tools.cjs")}`);
+	      }
+	    } catch {
+	    }
+	  }
+	  const defaultPath = path.join(os.homedir(), ".claude", "get-shit-done", "bin", "gsd-tools.cjs");
+	  checked.push(`  default: ${defaultPath}`);
 	  throw new Error(
-	    `GSD tools not found at ${standard}.
-Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
+	    `GSD tools not found. Checked:
+${checked.join("\n")}
+Set GSD_TOOLS_PATH or add gsd_path to .mgw/config.json`
 	  );
 	}
 	const GSD_TIMEOUT_MS = 15e3;
@@ -289,6 +317,7 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  return { activeMilestone, currentPhase, planCount };
 	}
 	gsdAdapter = {
+	  resolveGsdRoot,
 	  getGsdToolsPath,
 	  invokeGsdTool,
 	  getTimestamp,
@@ -320,7 +349,7 @@ function requireTemplateLoader () {
 	if (hasRequiredTemplateLoader) return templateLoader.exports;
 	hasRequiredTemplateLoader = 1;
 	(function (module) {
-		const fs = require$$0$1;
+		const fs = require$$2;
 		const path = require$$1;
 		const VALID_GSD_ROUTES = [
 		  "quick",
@@ -626,6 +655,21 @@ function requireTemplates () {
 	return templates;
 }
 
+var claude;
+var hasRequiredClaude;
+
+function requireClaude () {
+	if (hasRequiredClaude) return claude;
+	hasRequiredClaude = 1;
+	const provider = index$1.requireProviderClaude();
+	claude = {
+	  assertClaudeAvailable: provider.assertAvailable,
+	  invokeClaude: provider.invoke,
+	  getCommandsDir: provider.getCommandsDir
+	};
+	return claude;
+}
+
 var progress;
 var hasRequiredProgress;
 
@@ -724,6 +768,415 @@ ${header}
 	return progress;
 }
 
+var issueContext;
+var hasRequiredIssueContext;
+
+function requireIssueContext () {
+	if (hasRequiredIssueContext) return issueContext;
+	hasRequiredIssueContext = 1;
+	const { execSync } = require$$0;
+	const fs = require$$2;
+	const path = require$$1;
+	const GH_TIMEOUT_MS = 3e4;
+	const BUDGET = {
+	  vision: 2e3,
+	  priorSummary: 500,
+	  maxPriorSummaries: 5,
+	  currentPlan: 4e3,
+	  milestone: 1e3
+	};
+	const CACHE_TTL_MINUTES = 30;
+	function run(cmd) {
+	  return execSync(cmd, {
+	    encoding: "utf-8",
+	    stdio: ["pipe", "pipe", "pipe"],
+	    timeout: GH_TIMEOUT_MS
+	  }).trim();
+	}
+	function getMgwDir() {
+	  return path.join(process.cwd(), ".mgw");
+	}
+	function getCacheDir() {
+	  const dir = path.join(getMgwDir(), "context-cache");
+	  fs.mkdirSync(dir, { recursive: true });
+	  return dir;
+	}
+	function truncate(str, maxLen) {
+	  if (!str || str.length <= maxLen) return str || "";
+	  return str.slice(0, maxLen) + "...";
+	}
+	function parseMetadata(commentBody) {
+	  const result = { type: null, phase: null, milestone: null, timestamp: null };
+	  if (!commentBody) return result;
+	  const match = commentBody.match(/<!--\s*(mgw:[^\n]*?)-->/);
+	  if (!match) return result;
+	  const header = match[1];
+	  const typeMatch = header.match(/mgw:type=(\S+)/);
+	  const phaseMatch = header.match(/mgw:phase=(\S+)/);
+	  const milestoneMatch = header.match(/mgw:milestone=(\S+)/);
+	  const timestampMatch = header.match(/mgw:timestamp=(\S+)/);
+	  if (typeMatch) result.type = typeMatch[1];
+	  if (phaseMatch) result.phase = parseInt(phaseMatch[1], 10);
+	  if (milestoneMatch) result.milestone = parseInt(milestoneMatch[1], 10);
+	  if (timestampMatch) result.timestamp = timestampMatch[1];
+	  return result;
+	}
+	function formatWithMetadata(content, meta) {
+	  const m = meta || {};
+	  const ts = m.timestamp || (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+	  const parts = [];
+	  if (m.type) parts.push(`mgw:type=${m.type}`);
+	  if (m.phase != null) parts.push(`mgw:phase=${m.phase}`);
+	  if (m.milestone != null) parts.push(`mgw:milestone=${m.milestone}`);
+	  parts.push(`mgw:timestamp=${ts}`);
+	  const header = `<!-- ${parts.join(" ")} -->`;
+	  return `${header}
+${content}`;
+	}
+	async function postPlanningComment(issueNumber, type, content, meta) {
+	  const formatted = formatWithMetadata(content, { ...meta, type });
+	  const tmpFile = path.join(require$$3.tmpdir(), `mgw-comment-${Date.now()}.md`);
+	  try {
+	    fs.writeFileSync(tmpFile, formatted, "utf-8");
+	    run(`gh issue comment ${issueNumber} --body-file ${JSON.stringify(tmpFile)}`);
+	  } finally {
+	    try {
+	      fs.unlinkSync(tmpFile);
+	    } catch (_) {
+	    }
+	  }
+	}
+	async function findPlanningComments(issueNumber, type) {
+	  const raw = run(
+	    `gh issue view ${issueNumber} --json comments --jq '.comments'`
+	  );
+	  const comments = JSON.parse(raw);
+	  const results = [];
+	  for (const c of comments) {
+	    const meta = parseMetadata(c.body);
+	    if (meta.type === type) {
+	      results.push({
+	        body: c.body,
+	        meta,
+	        createdAt: c.createdAt || ""
+	      });
+	    }
+	  }
+	  return results;
+	}
+	async function findLatestComment(issueNumber, type) {
+	  const comments = await findPlanningComments(issueNumber, type);
+	  if (comments.length === 0) return null;
+	  comments.sort((a, b) => {
+	    const tsA = a.meta.timestamp || a.createdAt || "";
+	    const tsB = b.meta.timestamp || b.createdAt || "";
+	    return tsA.localeCompare(tsB);
+	  });
+	  return comments[comments.length - 1];
+	}
+	async function assembleMilestoneContext(milestoneNum) {
+	  const cached = readCache(milestoneNum);
+	  if (cached) return Object.values(cached.summaries);
+	  const raw = run(
+	    `gh issue list --milestone ${JSON.stringify(String(milestoneNum))} --state closed --json number,title --limit 100`
+	  );
+	  const issues = JSON.parse(raw);
+	  const summaries = [];
+	  for (const issue of issues) {
+	    try {
+	      const comment = await findLatestComment(issue.number, "summary");
+	      if (comment) {
+	        const bodyWithoutHeader = comment.body.replace(/<!--[\s\S]*?-->\n?/, "").trim();
+	        summaries.push({
+	          issueNumber: issue.number,
+	          title: issue.title,
+	          summary: truncate(bodyWithoutHeader, BUDGET.priorSummary)
+	        });
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  writeCache(milestoneNum, summaries);
+	  return summaries;
+	}
+	async function assembleIssueContext(issueNumber) {
+	  const raw = run(
+	    `gh issue view ${issueNumber} --json number,title,body,milestone,labels,state`
+	  );
+	  const issue = JSON.parse(raw);
+	  let milestoneContext = [];
+	  if (issue.milestone && issue.milestone.number) {
+	    try {
+	      milestoneContext = await assembleMilestoneContext(issue.milestone.number);
+	    } catch (_) {
+	    }
+	  }
+	  let planComment = null;
+	  let summaryComment = null;
+	  try {
+	    planComment = await findLatestComment(issueNumber, "plan");
+	  } catch (_) {
+	  }
+	  try {
+	    summaryComment = await findLatestComment(issueNumber, "summary");
+	  } catch (_) {
+	  }
+	  return { issue, milestoneContext, planComment, summaryComment };
+	}
+	async function fetchProjectVision() {
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (fs.existsSync(projectJsonPath)) {
+	      const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	      const projectNumber = project.project && project.project.project_board && project.project.project_board.number || "";
+	      if (projectNumber) {
+	        const owner = run("gh repo view --json owner -q .owner.login");
+	        const readme = run(
+	          `gh project view ${projectNumber} --owner ${owner} --json readme -q .readme`
+	        );
+	        if (readme && readme.length > 10) {
+	          const visionMatch = readme.match(/##\s*Vision\s*\n([\s\S]*?)(?=\n##\s|\n$|$)/);
+	          if (visionMatch && visionMatch[1].trim()) {
+	            return visionMatch[1].trim();
+	          }
+	          const lines = readme.split("\n");
+	          const bodyLines = lines.filter((l) => !l.startsWith("# "));
+	          const body = bodyLines.join("\n").trim();
+	          if (body) return body;
+	        }
+	      }
+	    }
+	  } catch (_) {
+	  }
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (fs.existsSync(projectJsonPath)) {
+	      const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	      const description = project.project && project.project.description || "";
+	      if (description) return description;
+	      const projectName = project.project && project.project.name || "";
+	      if (projectName) return `Project: ${projectName}`;
+	    }
+	  } catch (_) {
+	  }
+	  try {
+	    const visionBriefPath = path.join(getMgwDir(), "vision-brief.json");
+	    if (fs.existsSync(visionBriefPath)) {
+	      const brief = JSON.parse(fs.readFileSync(visionBriefPath, "utf-8"));
+	      return brief.vision_summary || brief.description || "";
+	    }
+	  } catch (_) {
+	  }
+	  return "";
+	}
+	async function buildGSDPromptContext(opts) {
+	  const o = opts || {};
+	  const sections = [];
+	  if (o.includeVision) {
+	    try {
+	      const vision = await fetchProjectVision();
+	      if (vision) {
+	        sections.push(`<vision>
+${truncate(vision, BUDGET.vision)}
+</vision>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (o.milestone) {
+	    try {
+	      const milestoneRaw = run(
+	        `gh api repos/$(gh repo view --json nameWithOwner -q .nameWithOwner)/milestones/${o.milestone} --jq '{title: .title, description: .description}'`
+	      );
+	      const milestoneData = JSON.parse(milestoneRaw);
+	      const milestoneInfo = truncate(
+	        `${milestoneData.title}
+${milestoneData.description || ""}`,
+	        BUDGET.milestone
+	      );
+	      sections.push(`<milestone>
+${milestoneInfo}
+</milestone>`);
+	    } catch (_) {
+	    }
+	  }
+	  if (o.includePriorSummaries && o.milestone) {
+	    try {
+	      const summaries = await assembleMilestoneContext(o.milestone);
+	      const prior = summaries.filter((s) => o.issueNumber == null || s.issueNumber !== o.issueNumber).slice(-BUDGET.maxPriorSummaries);
+	      if (prior.length > 0) {
+	        const priorText = prior.map((s) => `### Issue #${s.issueNumber}: ${s.title}
+${s.summary}`).join("\n\n");
+	        sections.push(`<prior_phases>
+${priorText}
+</prior_phases>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (o.includeCurrentPlan && o.issueNumber) {
+	    try {
+	      const planComment = await findLatestComment(o.issueNumber, "plan");
+	      if (planComment) {
+	        const planBody = planComment.body.replace(/<!--[\s\S]*?-->\n?/, "").trim();
+	        sections.push(`<current_phase>
+${truncate(planBody, BUDGET.currentPlan)}
+</current_phase>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (sections.length === 0) return "";
+	  return `<mgw_context>
+
+${sections.join("\n\n")}
+
+</mgw_context>`;
+	}
+	async function safeContext(opts) {
+	  try {
+	    return await buildGSDPromptContext(opts);
+	  } catch (_) {
+	    return "";
+	  }
+	}
+	function readCache(milestoneNum) {
+	  try {
+	    const cachePath = path.join(getCacheDir(), `milestone-${milestoneNum}.json`);
+	    if (!fs.existsSync(cachePath)) return null;
+	    const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+	    const cachedAt = new Date(data.cached_at);
+	    const now = /* @__PURE__ */ new Date();
+	    const ageMinutes = (now - cachedAt) / (1e3 * 60);
+	    if (ageMinutes > (data.ttl_minutes || CACHE_TTL_MINUTES)) return null;
+	    return data;
+	  } catch (_) {
+	    return null;
+	  }
+	}
+	function writeCache(milestoneNum, summaries) {
+	  try {
+	    const cachePath = path.join(getCacheDir(), `milestone-${milestoneNum}.json`);
+	    const summaryMap = {};
+	    for (const s of summaries) {
+	      summaryMap[String(s.issueNumber)] = s;
+	    }
+	    const data = {
+	      milestone: Number(milestoneNum),
+	      cached_at: (/* @__PURE__ */ new Date()).toISOString(),
+	      ttl_minutes: CACHE_TTL_MINUTES,
+	      summaries: summaryMap
+	    };
+	    fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+	  } catch (_) {
+	  }
+	}
+	async function rebuildContextCache() {
+	  const cacheDir = getCacheDir();
+	  try {
+	    const files = fs.readdirSync(cacheDir);
+	    for (const f of files) {
+	      if (f.startsWith("milestone-") && f.endsWith(".json")) {
+	        fs.unlinkSync(path.join(cacheDir, f));
+	      }
+	    }
+	  } catch (_) {
+	  }
+	  let milestones;
+	  try {
+	    const repo = run("gh repo view --json nameWithOwner -q .nameWithOwner");
+	    const raw = run(`gh api repos/${repo}/milestones?state=all --jq '.[].number'`);
+	    milestones = raw.split("\n").filter(Boolean).map(Number);
+	  } catch (_) {
+	    milestones = [];
+	  }
+	  let totalIssues = 0;
+	  for (const num of milestones) {
+	    try {
+	      const summaries = await assembleMilestoneContext(num);
+	      totalIssues += summaries.length;
+	    } catch (_) {
+	    }
+	  }
+	  return { issueCount: totalIssues, milestoneCount: milestones.length };
+	}
+	async function updateProjectReadme() {
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (!fs.existsSync(projectJsonPath)) return false;
+	    const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	    const board = project.project && project.project.project_board || {};
+	    const projectNumber = board.number;
+	    if (!projectNumber) return false;
+	    const owner = run("gh repo view --json owner -q .owner.login");
+	    const projectName = project.project && project.project.name || "";
+	    let visionSummary = "";
+	    try {
+	      const visionBriefPath = path.join(getMgwDir(), "vision-brief.json");
+	      if (fs.existsSync(visionBriefPath)) {
+	        const brief = JSON.parse(fs.readFileSync(visionBriefPath, "utf-8"));
+	        visionSummary = (brief.vision_summary || brief.description || "").slice(0, 500);
+	      }
+	    } catch (_) {
+	    }
+	    if (!visionSummary) {
+	      visionSummary = project.project && project.project.description || "Project initialized via MGW.";
+	    }
+	    const milestones = project.milestones || [];
+	    const tableLines = ["| # | Milestone | Issues | Status |", "|---|-----------|--------|--------|"];
+	    for (let i = 0; i < milestones.length; i++) {
+	      const m = milestones[i];
+	      const name = m.name || m.title || "Unnamed";
+	      const count = (m.issues || []).length;
+	      const doneCount = (m.issues || []).filter((iss) => iss.pipeline_stage === "done").length;
+	      const state = m.gsd_state || "planned";
+	      const progress = count > 0 ? ` (${doneCount}/${count})` : "";
+	      const stateLabel = state.charAt(0).toUpperCase() + state.slice(1);
+	      tableLines.push(`| ${i + 1} | ${name} | ${count}${progress} | ${stateLabel} |`);
+	    }
+	    const boardUrl = board.url || "";
+	    const readmeBody = `# ${projectName}
+
+## Vision
+${visionSummary}
+
+## Milestones
+${tableLines.join("\n")}
+
+## Links
+- [Board](${boardUrl})`;
+	    const tmpFile = path.join(require("os").tmpdir(), `mgw-readme-${Date.now()}.md`);
+	    try {
+	      fs.writeFileSync(tmpFile, readmeBody, "utf-8");
+	      run(`gh project edit ${projectNumber} --owner ${owner} --readme "$(cat ${JSON.stringify(tmpFile)})"`);
+	    } finally {
+	      try {
+	        fs.unlinkSync(tmpFile);
+	      } catch (_) {
+	      }
+	    }
+	    return true;
+	  } catch (_) {
+	    return false;
+	  }
+	}
+	issueContext = {
+	  parseMetadata,
+	  formatWithMetadata,
+	  postPlanningComment,
+	  findPlanningComments,
+	  findLatestComment,
+	  assembleMilestoneContext,
+	  assembleIssueContext,
+	  buildGSDPromptContext,
+	  safeContext,
+	  rebuildContextCache,
+	  fetchProjectVision,
+	  updateProjectReadme
+	};
+	return issueContext;
+}
+
 var lib;
 var hasRequiredLib;
 
@@ -737,13 +1190,15 @@ function requireLib () {
 	  ...requireGsdAdapter(),
 	  ...requireTemplates(),
 	  ...index$1.requireOutput(),
-	  ...index$1.requireClaude(),
+	  ...requireClaude(),
+	  ...index$1.requireProviderManager(),
 	  ...index$1.requireRetry(),
 	  ...index$1.requireSpinner(),
 	  ...requireProgress(),
 	  ...requirePipeline(),
 	  ...index$1.requireErrors(),
-	  ...index$1.requireLogger()
+	  ...index$1.requireLogger(),
+	  ...requireIssueContext()
 	};
 	Object.defineProperty(_exports, "createIssuesBrowser", {
 	  configurable: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snipcodeit/mgw",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "GitHub-native issue-to-PR automation for Claude Code, powered by Get Shit Done",
   "bin": {
     "mgw": "./dist/bin/mgw.cjs"