@snipcodeit/mgw 0.1.0

package/dist/lib/index.cjs

@@ -0,0 +1,395 @@
+'use strict';
+
+var claude = require('../claude-Vp9qvImH.cjs');
+var require$$0 = require('child_process');
+var require$$1 = require('path');
+var require$$2 = require('os');
+var require$$0$1 = require('fs');
+
+var gsd;
+var hasRequiredGsd;
+
+function requireGsd () {
+	if (hasRequiredGsd) return gsd;
+	hasRequiredGsd = 1;
+	const { execSync } = require$$0;
+	const path = require$$1;
+	const os = require$$2;
+	function getGsdToolsPath() {
+	  const standard = path.join(os.homedir(), ".claude", "get-shit-done", "bin", "gsd-tools.cjs");
+	  const fs = require$$0$1;
+	  if (fs.existsSync(standard)) {
+	    return standard;
+	  }
+	  throw new Error(
+	    `GSD tools not found at ${standard}.
+Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
+	  );
+	}
+	function invokeGsdTool(command, args) {
+	  const toolPath = getGsdToolsPath();
+	  const argsStr = Array.isArray(args) ? args.map((a) => JSON.stringify(String(a))).join(" ") : "";
+	  const cmd = `node ${JSON.stringify(toolPath)} ${command}${argsStr ? " " + argsStr : ""}`;
+	  let raw;
+	  try {
+	    raw = execSync(cmd, {
+	      encoding: "utf-8",
+	      stdio: ["pipe", "pipe", "pipe"]
+	    }).trim();
+	  } catch (err) {
+	    const stderr = err.stderr ? err.stderr.trim() : "";
+	    throw new Error(
+	      `GSD tool command failed: ${command}
+` + (stderr ? `stderr: ${stderr}` : `exit code: ${err.status}`)
+	    );
+	  }
+	  if (!raw) return null;
+	  try {
+	    return JSON.parse(raw);
+	  } catch {
+	    return raw;
+	  }
+	}
+	gsd = {
+	  getGsdToolsPath,
+	  invokeGsdTool
+	};
+	return gsd;
+}
+
+var templateLoader = {exports: {}};
+
+var hasRequiredTemplateLoader;
+
+function requireTemplateLoader () {
+	if (hasRequiredTemplateLoader) return templateLoader.exports;
+	hasRequiredTemplateLoader = 1;
+	(function (module) {
+		const fs = require$$0$1;
+		const path = require$$1;
+		const VALID_GSD_ROUTES = [
+		  "quick",
+		  "plan-phase",
+		  "discuss-phase",
+		  "research-phase",
+		  "execute-phase",
+		  "verify-phase",
+		  "new-project",
+		  "new-milestone",
+		  "complete-milestone",
+		  "debug",
+		  "diagnose-issues"
+		];
+		function getTemplatesDir() {
+		  let dir = path.join(__dirname, "..", "templates");
+		  if (fs.existsSync(dir)) return dir;
+		  dir = path.join(__dirname, "..", "..", "templates");
+		  if (fs.existsSync(dir)) return dir;
+		  throw new Error(
+		    `Templates directory not found.
+Checked: ` + path.join(__dirname, "..", "templates") + "\nChecked: " + path.join(__dirname, "..", "..", "templates")
+		  );
+		}
+		function getSchema() {
+		  const schemaPath = path.join(getTemplatesDir(), "schema.json");
+		  return fs.readFileSync(schemaPath, "utf-8");
+		}
+		function validate(output) {
+		  const errors = [];
+		  if (!output.type || typeof output.type !== "string" || output.type.trim() === "") {
+		    errors.push({
+		      field: "type",
+		      error: `Missing or empty type field: ${output.type}`,
+		      suggestion: 'Provide a descriptive type string (e.g. "game", "mobile-app", "api-service", "data-pipeline")'
+		    });
+		  }
+		  if (!output.project) {
+		    errors.push({
+		      field: "project",
+		      error: "Missing project metadata",
+		      suggestion: "Output must include a project object with name and description"
+		    });
+		  } else {
+		    if (!output.project.name || String(output.project.name).trim() === "") {
+		      errors.push({
+		        field: "project.name",
+		        error: "Project name is empty",
+		        suggestion: "Provide a non-empty project_name parameter"
+		      });
+		    }
+		    if (!output.project.description || String(output.project.description).trim() === "") {
+		      errors.push({
+		        field: "project.description",
+		        error: "Project description is empty",
+		        suggestion: "Provide a non-empty description parameter"
+		      });
+		    }
+		  }
+		  if (!Array.isArray(output.milestones) || output.milestones.length === 0) {
+		    errors.push({
+		      field: "milestones",
+		      error: "Milestones array is empty or missing",
+		      suggestion: "Template must define at least one milestone"
+		    });
+		    return { valid: false, errors };
+		  }
+		  const milestoneNames = output.milestones.map((m) => m.name);
+		  const nameSet = new Set(milestoneNames);
+		  if (nameSet.size !== milestoneNames.length) {
+		    const dupes = milestoneNames.filter((n, i) => milestoneNames.indexOf(n) !== i);
+		    errors.push({
+		      field: "milestones",
+		      error: `Duplicate milestone names: ${[...new Set(dupes)].join(", ")}`,
+		      suggestion: "Each milestone must have a unique name"
+		    });
+		  }
+		  for (let mi = 0; mi < output.milestones.length; mi++) {
+		    const milestone = output.milestones[mi];
+		    if (!Array.isArray(milestone.phases) || milestone.phases.length === 0) {
+		      errors.push({
+		        field: `milestones[${mi}].phases`,
+		        error: `Milestone "${milestone.name}" has no phases`,
+		        suggestion: "Each milestone must have at least one phase"
+		      });
+		      continue;
+		    }
+		    for (let pi = 0; pi < milestone.phases.length; pi++) {
+		      const phase = milestone.phases[pi];
+		      const phasePath = `milestones[${mi}].phases[${pi}]`;
+		      if (typeof phase.number !== "number" || !Number.isInteger(phase.number)) {
+		        errors.push({
+		          field: `${phasePath}.number`,
+		          error: `Phase number must be an integer, got: ${phase.number}`,
+		          suggestion: "Use sequential integers starting from 1"
+		        });
+		      }
+		      if (!phase.name || String(phase.name).trim() === "") {
+		        errors.push({
+		          field: `${phasePath}.name`,
+		          error: "Phase name is empty",
+		          suggestion: "Each phase must have a descriptive name"
+		        });
+		      }
+		      if (!phase.description || String(phase.description).trim() === "") {
+		        errors.push({
+		          field: `${phasePath}.description`,
+		          error: "Phase description is empty",
+		          suggestion: "Each phase must have a description"
+		        });
+		      }
+		      if (!VALID_GSD_ROUTES.includes(phase.gsd_route)) {
+		        errors.push({
+		          field: `${phasePath}.gsd_route`,
+		          error: `Invalid GSD route: ${phase.gsd_route}`,
+		          suggestion: `Valid routes: ${VALID_GSD_ROUTES.join(", ")}`
+		        });
+		      }
+		      if (!Array.isArray(phase.issues) || phase.issues.length === 0) {
+		        errors.push({
+		          field: `${phasePath}.issues`,
+		          error: `Phase "${phase.name}" has no issues`,
+		          suggestion: "Each phase must have at least one issue"
+		        });
+		      }
+		    }
+		  }
+		  return {
+		    valid: errors.length === 0,
+		    errors
+		  };
+		}
+		function parseRoadmap(content) {
+		  if (!content || typeof content !== "string") {
+		    return { phases: [], total_phases: 0, completed_phases: 0, error: "No content provided" };
+		  }
+		  const statusMap = {};
+		  const progressTableMatch = content.match(/##\s+Progress[\s\S]*?\n((?:\|[^\n]+\|\n)+)/);
+		  if (progressTableMatch) {
+		    const tableRows = progressTableMatch[1].split("\n").filter((r) => r.trim().startsWith("|"));
+		    for (const row of tableRows) {
+		      if (row.includes("---") || row.toLowerCase().includes("phase") && row.toLowerCase().includes("status")) continue;
+		      const cells = row.split("|").map((c) => c.trim()).filter(Boolean);
+		      if (cells.length >= 3) {
+		        const phaseNum = parseInt(cells[0], 10);
+		        if (!isNaN(phaseNum)) {
+		          statusMap[phaseNum] = cells[2] || "Not Started";
+		        }
+		      }
+		    }
+		  }
+		  const checkboxRe = /- \[([ xX])\]\s+Phase\s+(\d+)[:\s]/gm;
+		  let cbMatch;
+		  while ((cbMatch = checkboxRe.exec(content)) !== null) {
+		    const checked = cbMatch[1].trim().toLowerCase() === "x";
+		    const num = parseInt(cbMatch[2], 10);
+		    if (!isNaN(num)) {
+		      statusMap[num] = checked ? "Complete" : statusMap[num] || "Not Started";
+		    }
+		  }
+		  const phaseSectionRe = /###\s+Phase\s+(\d+)[:\s]+([^\n]+)/g;
+		  const phases = [];
+		  let match;
+		  while ((match = phaseSectionRe.exec(content)) !== null) {
+		    const phaseNumber = parseInt(match[1], 10);
+		    const phaseName = match[2].trim();
+		    const sectionStart = match.index + match[0].length;
+		    const nextSectionMatch = /\n###\s+/g;
+		    nextSectionMatch.lastIndex = sectionStart;
+		    const nextMatch = nextSectionMatch.exec(content);
+		    const sectionEnd = nextMatch ? nextMatch.index : content.length;
+		    const sectionText = content.slice(sectionStart, sectionEnd);
+		    const goalMatch = sectionText.match(/\*\*Goal[:\*]*\*?\*?[:\s]+([^\n]+)/);
+		    const goal = goalMatch ? goalMatch[1].trim().replace(/\*+$/, "") : "";
+		    const reqMatch = sectionText.match(/\*\*Requirements?[:\*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
+		    let requirements = [];
+		    if (reqMatch) {
+		      const reqText = reqMatch[1].trim();
+		      requirements = reqText.split(/[,\n]+/).map((r) => r.trim().replace(/^[-*\s]+/, "").trim()).filter((r) => r.length > 0);
+		    }
+		    const scMatch = sectionText.match(/\*\*Success Criteria[:\*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
+		    let success_criteria = [];
+		    if (scMatch) {
+		      const scText = scMatch[1];
+		      success_criteria = scText.split("\n").map((line) => line.trim().replace(/^[\d]+\.\s*/, "").replace(/^[-*]\s*/, "").trim()).filter((line) => line.length > 0);
+		    }
+		    const status = statusMap[phaseNumber] || "Not Started";
+		    phases.push({
+		      number: phaseNumber,
+		      name: phaseName,
+		      goal,
+		      requirements,
+		      success_criteria,
+		      status
+		    });
+		  }
+		  if (phases.length === 0) {
+		    return { phases: [], total_phases: 0, completed_phases: 0, error: "No phases found in ROADMAP.md" };
+		  }
+		  phases.sort((a, b) => a.number - b.number);
+		  const completedPhases = phases.filter(
+		    (p) => p.status === "Complete" || p.status === "complete" || p.status === "Done"
+		  ).length;
+		  return {
+		    phases,
+		    total_phases: phases.length,
+		    completed_phases: completedPhases
+		  };
+		}
+		if (require.main === module) {
+		  const args = process.argv.slice(2);
+		  const command = args[0];
+		  if (!command || command === "--help" || command === "-h") {
+		    console.log(`Usage:
+  node template-loader.cjs validate      (reads JSON from stdin)
+  node template-loader.cjs schema        (prints templates/schema.json to stdout)
+  node template-loader.cjs parse-roadmap (reads ROADMAP.md from stdin, outputs JSON)
+
+Commands:
+  validate      Validate an AI-generated template from stdin
+  schema        Print the templates/schema.json schema to stdout
+  parse-roadmap Parse a GSD ROADMAP.md from stdin into structured JSON
+
+Valid GSD routes: ${VALID_GSD_ROUTES.join(", ")}
+
+The validate command accepts any JSON object with:
+  - type: any descriptive string (game, mobile-app, api-service, data-pipeline, etc.)
+  - project: { name, description }
+  - milestones: array of milestones with phases and issues
+`);
+		    process.exit(0);
+		  }
+		  if (command === "validate") {
+		    let input = "";
+		    process.stdin.setEncoding("utf-8");
+		    process.stdin.on("data", (chunk) => {
+		      input += chunk;
+		    });
+		    process.stdin.on("end", () => {
+		      try {
+		        const output = JSON.parse(input);
+		        const result = validate(output);
+		        console.log(JSON.stringify(result, null, 2));
+		        process.exit(result.valid ? 0 : 1);
+		      } catch (err) {
+		        console.error(JSON.stringify({
+		          valid: false,
+		          errors: [{ field: "input", error: `Failed to parse stdin as JSON: ${err.message}`, suggestion: "Pipe valid JSON to stdin" }]
+		        }, null, 2));
+		        process.exit(1);
+		      }
+		    });
+		  } else if (command === "schema") {
+		    try {
+		      console.log(getSchema());
+		      process.exit(0);
+		    } catch (err) {
+		      console.error(`Error reading schema: ${err.message}`);
+		      process.exit(1);
+		    }
+		  } else if (command === "parse-roadmap") {
+		    let input = "";
+		    process.stdin.setEncoding("utf-8");
+		    process.stdin.on("data", (chunk) => {
+		      input += chunk;
+		    });
+		    process.stdin.on("end", () => {
+		      try {
+		        const result = parseRoadmap(input);
+		        console.log(JSON.stringify(result, null, 2));
+		        process.exit(result.error ? 1 : 0);
+		      } catch (err) {
+		        console.error(JSON.stringify({
+		          phases: [],
+		          total_phases: 0,
+		          completed_phases: 0,
+		          error: `Failed to parse ROADMAP.md: ${err.message}`
+		        }, null, 2));
+		        process.exit(1);
+		      }
+		    });
+		  } else {
+		    console.error(JSON.stringify({
+		      success: false,
+		      errors: [{ field: "command", error: `Unknown command: ${command}`, suggestion: "Valid commands: validate, schema, parse-roadmap" }]
+		    }, null, 2));
+		    process.exit(1);
+		  }
+		}
+		module.exports = { validate, getSchema, parseRoadmap, VALID_GSD_ROUTES }; 
+	} (templateLoader));
+	return templateLoader.exports;
+}
+
+var templates;
+var hasRequiredTemplates;
+
+function requireTemplates () {
+	if (hasRequiredTemplates) return templates;
+	hasRequiredTemplates = 1;
+	const { validate, getSchema, VALID_GSD_ROUTES } = requireTemplateLoader();
+	templates = { validate, getSchema, VALID_GSD_ROUTES };
+	return templates;
+}
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	lib = {
+	  ...claude.requireState(),
+	  ...claude.requireGithub(),
+	  ...requireGsd(),
+	  ...requireTemplates(),
+	  ...claude.requireOutput(),
+	  ...claude.requireClaude()
+	};
+	return lib;
+}
+
+var libExports = requireLib();
+var index = /*@__PURE__*/claude.getDefaultExportFromCjs(libExports);
+
+module.exports = index;
+0&&(module.exports={getMgwDir,getActiveDir,getCompletedDir,loadProjectState,writeProjectState,loadActiveIssue,mergeProjectState,migrateProjectState,resolveActiveMilestoneIndex,getRepo,getIssue,listIssues,getMilestone,getRateLimit,closeMilestone,createRelease,createProject,addItemToProject,postMilestoneStartAnnouncement,getGsdToolsPath,invokeGsdTool,validate,getSchema,VALID_GSD_ROUTES,IS_TTY,IS_CI,USE_COLOR,COLORS,colorize,statusLine,log,error,verbose,debug,formatJson,assertClaudeAvailable,invokeClaude,getCommandsDir});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@snipcodeit/mgw",
+  "version": "0.1.0",
+  "description": "GitHub-native issue-to-PR automation for Claude Code, powered by Get Shit Done",
+  "bin": {
+    "mgw": "./dist/bin/mgw.cjs"
+  },
+  "main": "./dist/lib/index.cjs",
+  "files": [
+    "dist/",
+    "bin/mgw-install.cjs",
+    "commands/",
+    "templates/"
+  ],
+  "scripts": {
+    "build": "pkgroll --clean-dist --src .",
+    "dev": "pkgroll --watch --src .",
+    "test": "node --test 'test/**/*.test.cjs'",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node ./bin/mgw-install.cjs"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "pkgroll": "^2.26.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/snipcodeit/mgw.git"
+  },
+  "keywords": [
+    "claude-code",
+    "github",
+    "automation",
+    "project-management",
+    "gsd",
+    "cli",
+    "developer-tools",
+    "ai"
+  ],
+  "author": "snipcodeit",
+  "license": "MIT",
+  "homepage": "https://github.com/snipcodeit/mgw",
+  "bugs": {
+    "url": "https://github.com/snipcodeit/mgw/issues"
+  }
+}

package/templates/schema.json

@@ -0,0 +1,164 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "MGW Pipeline Template",
+  "description": "Schema for MGW pipeline templates. Each template defines an opinionated project lifecycle with milestones, phases, and GSD route recommendations.",
+  "type": "object",
+  "required": ["type", "version", "description", "parameters", "milestones"],
+  "properties": {
+    "type": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Project type identifier — any descriptive string (e.g. game, mobile-app, api-service, data-pipeline, saas-platform, etc.)"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$",
+      "description": "Template version (semver)"
+    },
+    "description": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Human-readable template description"
+    },
+    "parameters": {
+      "type": "object",
+      "required": ["required", "optional"],
+      "properties": {
+        "required": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/requiredParameter" },
+          "description": "Parameters the user must provide"
+        },
+        "optional": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/optionalParameter" },
+          "description": "Parameters with smart defaults"
+        }
+      },
+      "additionalProperties": false
+    },
+    "milestones": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/definitions/milestone" },
+      "description": "Ordered milestones for the project lifecycle"
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "requiredParameter": {
+      "type": "object",
+      "required": ["name", "type", "description"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "type": { "type": "string", "enum": ["string"] },
+        "description": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "optionalParameter": {
+      "type": "object",
+      "required": ["name", "type", "default", "description"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "type": { "type": "string", "enum": ["string"] },
+        "default": { "type": "string" },
+        "description": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "milestone": {
+      "type": "object",
+      "required": ["name", "description", "phases"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Milestone name (may contain {prefix} placeholder)"
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1,
+          "description": "What this milestone delivers"
+        },
+        "phases": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/phase" }
+        }
+      },
+      "additionalProperties": false
+    },
+    "phase": {
+      "type": "object",
+      "required": ["number", "name", "description", "gsd_route", "issues"],
+      "properties": {
+        "number": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Phase number within the project"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Phase name"
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1,
+          "description": "What this phase accomplishes"
+        },
+        "gsd_route": {
+          "type": "string",
+          "enum": [
+            "quick",
+            "plan-phase",
+            "discuss-phase",
+            "research-phase",
+            "execute-phase",
+            "verify-phase",
+            "new-project",
+            "new-milestone",
+            "complete-milestone"
+          ],
+          "description": "Recommended GSD workflow for this phase"
+        },
+        "issues": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/issue" },
+          "description": "Issue templates for this phase"
+        }
+      },
+      "additionalProperties": false
+    },
+    "issue": {
+      "type": "object",
+      "required": ["title", "description", "labels"],
+      "properties": {
+        "title": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Issue title (may contain {project_name} or {description} placeholders)"
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Issue description"
+        },
+        "labels": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Labels to apply to the issue"
+        },
+        "depends_on": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": [],
+          "description": "Issue slugs this issue depends on (resolved to GitHub issue numbers during init)"
+        }
+      },
+      "additionalProperties": false
+    }
+  }
+}