@bobbyg603/mog 1.3.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbyg603/mog",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "One command to go from GitHub issue to pull request, powered by Claude Code in a Docker sandbox",
   "module": "src/index.ts",
   "type": "module",

package/src/github.ts

@@ -4,6 +4,7 @@ export interface Issue {
   title: string;
   body: string;
   labels: string;
+  comments: string;
 }
 
 export function fetchIssue(repo: string, issueNum: string): Issue {
@@ -12,7 +13,7 @@ export function fetchIssue(repo: string, issueNum: string): Issue {
   const proc = Bun.spawnSync([
     "gh", "issue", "view", issueNum,
     "--repo", repo,
-    "--json", "title,body,labels",
+    "--json", "title,body,labels,comments",
   ]);
 
   if (proc.exitCode !== 0) {
@@ -21,10 +22,15 @@ export function fetchIssue(repo: string, issueNum: string): Issue {
 
   const json = JSON.parse(proc.stdout.toString());
 
+  const comments = (json.comments || [])
+    .map((c: { author: { login: string }; body: string }) => `**@${c.author.login}:** ${c.body}`)
+    .join("\n\n");
+
   return {
     title: json.title,
     body: json.body || "No description provided.",
     labels: json.labels?.map((l: { name: string }) => l.name).join(", ") || "none",
+    comments,
   };
 }
 
@@ -70,6 +76,57 @@ export function listIssues(repo: string, verbose: boolean): void {
   }
 }
 
+export interface PRFeedback {
+  prNumber: number;
+  prUrl: string;
+  reviews: string;
+}
+
+export function fetchPRFeedback(repo: string, branchName: string): PRFeedback | null {
+  const proc = Bun.spawnSync([
+    "gh", "pr", "list",
+    "--repo", repo,
+    "--head", branchName,
+    "--state", "open",
+    "--json", "number,url",
+  ]);
+
+  if (proc.exitCode !== 0) return null;
+
+  const prs = JSON.parse(proc.stdout.toString());
+  if (prs.length === 0) return null;
+
+  const prNumber = prs[0].number;
+  const prUrl = prs[0].url;
+
+  // Fetch review comments
+  const reviewProc = Bun.spawnSync([
+    "gh", "pr", "view", String(prNumber),
+    "--repo", repo,
+    "--json", "reviews,comments",
+  ]);
+
+  let reviews = "";
+  if (reviewProc.exitCode === 0) {
+    const data = JSON.parse(reviewProc.stdout.toString());
+
+    const reviewEntries = (data.reviews || [])
+      .filter((r: { body: string }) => r.body?.trim())
+      .map((r: { author: { login: string }; state: string; body: string }) =>
+        `**@${r.author.login}** (${r.state}):\n${r.body}`
+      );
+
+    const commentEntries = (data.comments || [])
+      .map((c: { author: { login: string }; body: string }) =>
+        `**@${c.author.login}:**\n${c.body}`
+      );
+
+    reviews = [...reviewEntries, ...commentEntries].join("\n\n");
+  }
+
+  return { prNumber, prUrl, reviews };
+}
+
 export function pushAndCreatePR(
   repo: string,
   worktreeDir: string,
@@ -77,7 +134,8 @@ export function pushAndCreatePR(
   defaultBranch: string,
   issueNum: string,
   issue: Issue,
-  summary?: string
+  summary?: string,
+  existingPR?: PRFeedback,
 ): void {
   // Check for unpushed commits or uncommitted changes
   const unpushed = Bun.spawnSync(["git", "log", `origin/${defaultBranch}..HEAD`, "--oneline"], { cwd: worktreeDir });
@@ -107,14 +165,44 @@ export function pushAndCreatePR(
     }
   }
 
-  // Push
+  // Squash all commits into one
+  const commitCount = Bun.spawnSync(["git", "rev-list", "--count", `${defaultBranch}..HEAD`], { cwd: worktreeDir });
+  const count = parseInt(commitCount.stdout.toString().trim(), 10) || 0;
+  if (count > 1) {
+    log.info(`Squashing ${count} commits into one...`);
+    const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
+    const squash = Bun.spawnSync(["git", "reset", "--soft", defaultBranch], { cwd: worktreeDir });
+    if (squash.exitCode === 0) {
+      const msg = `${prefix}: ${issue.title.toLowerCase()} (#${issueNum})`;
+      Bun.spawnSync(["git", "commit", "-m", msg], { cwd: worktreeDir });
+      log.ok("Commits squashed.");
+    } else {
+      log.warn("Failed to squash — pushing individual commits instead.");
+    }
+  }
+
+  // Push (force-with-lease when updating an existing PR)
   log.info(`Pushing branch '${branchName}' to origin...`);
-  const push = Bun.spawnSync(["git", "push", "-u", "origin", branchName], { cwd: worktreeDir });
+  const pushArgs = existingPR
+    ? ["git", "push", "--force-with-lease", "-u", "origin", branchName]
+    : ["git", "push", "-u", "origin", branchName];
+  const push = Bun.spawnSync(pushArgs, { cwd: worktreeDir });
   if (push.exitCode !== 0) {
     log.die("Failed to push. Check your git credentials.");
   }
   log.ok("Branch pushed.");
 
+  if (existingPR) {
+    // Update existing PR
+    log.ok("Existing PR updated!");
+    console.log(`\x1b[0;32m${existingPR.prUrl}\x1b[0m`);
+    console.log();
+    log.ok(`All done! Issue #${issueNum} → Branch '${branchName}' → PR updated.`);
+    log.info(`Worktree: ${worktreeDir}`);
+    log.info(`To clean up the worktree later: git worktree remove ${worktreeDir}`);
+    return;
+  }
+
   // Create PR
   log.info("Opening pull request...");
 

package/src/index.ts

@@ -1,9 +1,12 @@
 #!/usr/bin/env bun
 
-import { fetchIssue, listIssues } from "./github";
+import fs from "fs";
+import path from "path";
+import { fetchIssue, listIssues, fetchPRFeedback } from "./github";
 import { detectRepo, ensureRepo, createWorktree } from "./worktree";
 import { runClaude } from "./sandbox";
 import { pushAndCreatePR } from "./github";
+import type { PRFeedback } from "./github";
 import { log } from "./log";
 
 const SANDBOX_NAME = "mog";
@@ -111,30 +114,54 @@ async function main() {
     console.log("  mog list [--verbose]           — list open issues (auto-detect repo)");
     console.log("  mog <owner/repo> list [--verbose] — list open issues for a repo");
     console.log();
+    console.log("Options:");
+    console.log("  --include <file>              — copy a file into the worktree (repeatable)");
+    console.log("  --fresh                       — ignore existing PR, start a brand new one");
+    console.log();
     console.log("Example:");
     console.log("  mog init");
     console.log("  mog 123");
+    console.log("  mog 123 --include .env");
     console.log("  mog workingdevshero/automate-it 123");
     console.log("  mog list");
     console.log("  mog list --verbose");
     return;
   }
 
+  // Parse --include and --fresh flags
+  const includeFiles: string[] = [];
+  const filteredArgs: string[] = [];
+  let fresh = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--include" && i + 1 < args.length) {
+      const filePath = path.resolve(args[i + 1]!);
+      if (!fs.existsSync(filePath)) {
+        log.die(`Include file not found: ${args[i + 1]}`);
+      }
+      includeFiles.push(filePath);
+      i++; // skip the path argument
+    } else if (args[i] === "--fresh") {
+      fresh = true;
+    } else {
+      filteredArgs.push(args[i]!);
+    }
+  }
+
   let repo: string;
   let issueNum: string;
 
-  if (/^\d+$/.test(args[0])) {
+  if (/^\d+$/.test(filteredArgs[0])) {
     // mog <issue_number> — auto-detect repo
     const detected = detectRepo();
     if (!detected) {
       log.die("Could not detect repo from git remote. Run from inside a git repo or use: mog <owner/repo> <issue_num>");
     }
     repo = detected;
-    issueNum = args[0];
-  } else if (args.length >= 2) {
+    issueNum = filteredArgs[0];
+  } else if (filteredArgs.length >= 2) {
     // mog <owner/repo> <issue_number>
-    repo = args[0];
-    issueNum = args[1];
+    repo = filteredArgs[0];
+    issueNum = filteredArgs[1];
     if (!/^\d+$/.test(issueNum)) {
       log.die(`Invalid issue number: '${issueNum}'. Must be a positive integer.`);
     }
@@ -146,9 +173,14 @@ async function main() {
     console.log("  mog list [--verbose]           — list open issues (auto-detect repo)");
     console.log("  mog <owner/repo> list [--verbose] — list open issues for a repo");
     console.log();
+    console.log("Options:");
+    console.log("  --include <file>              — copy a file into the worktree (repeatable)");
+    console.log("  --fresh                       — ignore existing PR, start a brand new one");
+    console.log();
     console.log("Example:");
     console.log("  mog init");
     console.log("  mog 123");
+    console.log("  mog 123 --include .env");
     console.log("  mog workingdevshero/automate-it 123");
     console.log("  mog list");
     console.log("  mog list --verbose");
@@ -188,10 +220,32 @@ async function main() {
     reposDir, owner, repoName, defaultBranch, issueNum, issue.title
   );
 
+  // Check for existing PR (unless --fresh)
+  let existingPR: PRFeedback | undefined;
+  if (!fresh) {
+    const pr = fetchPRFeedback(repo, branchName);
+    if (pr) {
+      existingPR = pr;
+      log.ok(`Found existing PR #${pr.prNumber} — will include review feedback and update it.`);
+    }
+  }
+
+  // Copy included files into worktree
+  const copiedFiles: string[] = [];
+  for (const filePath of includeFiles) {
+    const basename = path.basename(filePath);
+    const dest = path.join(worktreeDir, basename);
+    fs.copyFileSync(filePath, dest);
+    copiedFiles.push(dest);
+    log.ok(`Included: ${basename}`);
+  }
+
   // Build prompts
-  const planningPrompt = buildPlanningPrompt(repo, issueNum, issue);
+  const prFeedback = existingPR?.reviews || "";
+  const planningPrompt = buildPlanningPrompt(repo, issueNum, issue, prFeedback);
   const buildingPromptFn = (remaining: string[], plan: string) =>
     buildBuildingPrompt(repo, issueNum, issue, remaining, plan);
+  const reviewPrompt = buildReviewPrompt(repo, issueNum, issue);
 
   // Run Claude in sandbox
   log.info("Launching Claude Code in sandbox...");
@@ -199,10 +253,21 @@ async function main() {
   log.info(`Worktree: ${worktreeDir}`);
   console.log();
 
-  const summary = await runClaude(SANDBOX_NAME, worktreeDir, planningPrompt, buildingPromptFn);
+  const summary = await runClaude(SANDBOX_NAME, worktreeDir, planningPrompt, buildingPromptFn, reviewPrompt);
+
+  // Remove included files so they don't end up in the PR
+  for (const filePath of copiedFiles) {
+    try {
+      fs.unlinkSync(filePath);
+      // Unstage if Claude happened to git add it
+      Bun.spawnSync(["git", "rm", "--cached", "--ignore-unmatch", path.basename(filePath)], { cwd: worktreeDir });
+    } catch {
+      // File may already be gone
+    }
+  }
 
-  // Push and create PR
-  pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue, summary);
+  // Push and create/update PR
+  pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue, summary, existingPR);
 }
 
 function getReposDir(): string {
@@ -254,29 +319,54 @@ function tryRecoverSandbox(reposDir: string): boolean {
   return true;
 }
 
-function buildPlanningPrompt(repo: string, issueNum: string, issue: { title: string; body: string; labels: string }): string {
-  return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
-
-## Issue: ${issue.title}
+function formatIssueContext(issueNum: string, issue: { title: string; body: string; labels: string; comments: string }, prFeedback?: string): string {
+  let context = `## Issue: ${issue.title}
 
 ### Description
 ${issue.body}
 
 ### Labels
-${issue.labels}
+${issue.labels}`;
+
+  if (issue.comments) {
+    context += `
+
+### Comments
+${issue.comments}`;
+  }
+
+  if (prFeedback) {
+    context += `
+
+### Previous PR Review Feedback
+A previous attempt at this issue was reviewed. Address the following feedback in your implementation:
+
+${prFeedback}`;
+  }
+
+  return context;
+}
+
+function buildPlanningPrompt(repo: string, issueNum: string, issue: { title: string; body: string; labels: string; comments: string }, prFeedback?: string): string {
+  return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
+
+${formatIssueContext(issueNum, issue, prFeedback)}
 
 ## Instructions
 
 Your job in this step is to **plan only** — do NOT implement anything and do NOT commit.
 
 1. Read and understand the codebase structure thoroughly.
-2. Analyze the issue and break it down into small, atomic implementation tasks.
-3. Create a file called \`IMPLEMENTATION_PLAN.md\` in the root of the repository with a checklist of tasks.
+2. **Search the entire codebase** for code related to the issue — look for similar patterns, duplicate logic, and any modules that handle the same concern. Use Grep and Glob liberally to find all relevant locations, not just the most obvious one.
+3. Analyze the issue and break it down into small, atomic implementation tasks.
+4. Create a file called \`IMPLEMENTATION_PLAN.md\` in the root of the repository with a checklist of tasks.
 
 The plan should:
 - Have 3-8 tasks (fewer for simple issues, more for complex ones)
 - Order tasks by dependency (implement foundations first)
 - Each task should be a single, atomic unit of work that results in one commit
+- **Include tasks to update ALL locations** where the same pattern or concern exists — not just the most obvious one. If the same logic appears in multiple modules, the plan must cover all of them.
+- If you find duplicate or near-duplicate logic across modules, include a task to consolidate it into a shared utility or function.
 - Use markdown checklist format: \`- [ ] Task description\`
 
 Example format:
@@ -295,7 +385,7 @@ Do NOT implement any code changes. Do NOT make any commits. Only create the plan
 function buildBuildingPrompt(
   repo: string,
   issueNum: string,
-  issue: { title: string; body: string; labels: string },
+  issue: { title: string; body: string; labels: string; comments: string },
   remainingItems: string[],
   planContent: string,
 ): string {
@@ -303,19 +393,13 @@ function buildBuildingPrompt(
   if (remainingItems.length === 0 && !planContent) {
     return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
 
-## Issue: ${issue.title}
-
-### Description
-${issue.body}
-
-### Labels
-${issue.labels}
+${formatIssueContext(issueNum, issue)}
 
 ## Instructions
 1. Read and understand the codebase structure first.
 2. Implement the changes described in the issue above.
 3. Write clean, well-documented code that follows the existing project conventions.
-4. Add or update tests if applicable.
+4. If the project has an existing test suite, add or update tests to cover the changes.
 5. Make sure the code builds/lints without errors if there's a build system.
 6. Commit your changes with a clear commit message referencing issue #${issueNum}.
 
@@ -327,13 +411,7 @@ a message like: "fix: <short description> (#${issueNum})"`;
 
   return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
 
-## Issue: ${issue.title}
-
-### Description
-${issue.body}
-
-### Labels
-${issue.labels}
+${formatIssueContext(issueNum, issue)}
 
 ## Current Implementation Plan
 
@@ -352,6 +430,31 @@ Rules:
 5. Do NOT work on any other tasks after committing.`;
 }
 
+function buildReviewPrompt(
+  repo: string,
+  issueNum: string,
+  issue: { title: string; body: string; labels: string; comments: string },
+): string {
+  return `You are reviewing changes made for GitHub issue #${issueNum} in the repository ${repo}.
+
+${formatIssueContext(issueNum, issue)}
+
+## Instructions
+
+All implementation tasks are complete. Your job is to **review the entire branch** for quality and completeness.
+
+Run \`git diff main...HEAD\` (or the equivalent for the default branch) to see all changes made.
+
+Check for:
+1. **Missed locations**: Search the codebase for similar patterns, logic, or code that handles the same concern as the changes. If the fix or feature was applied in one place but a similar pattern exists elsewhere, apply it there too.
+2. **Code duplication**: If the changes introduced logic that duplicates existing code (or if pre-existing duplication was missed), consolidate it into a shared function or utility.
+3. **Quality issues**: Look for missing edge cases, error handling gaps, or inconsistencies with the rest of the codebase.
+4. **Tests**: If the project has an existing test suite, verify that tests were added or updated to cover the changes. If not, add them. Do not create a test framework or test infrastructure from scratch.
+
+If you find issues, fix them and commit each fix separately with a clear commit message referencing #${issueNum}.
+If everything looks good, do nothing.`;
+}
+
 main().catch((err) => {
   log.die(err.message);
 });

package/src/sandbox.ts

@@ -76,6 +76,7 @@ export async function runClaude(
   worktreeDir: string,
   planningPrompt: string,
   buildingPromptFn: (remainingItems: string[], planContent: string) => string,
+  reviewPrompt?: string,
 ): Promise<string> {
   let lastResult = "";
 
@@ -152,7 +153,14 @@ export async function runClaude(
     }
   }
 
-  // Phase 3 — Cleanup
+  // Phase 3 — Review
+  if (reviewPrompt) {
+    log.info("Phase 3: Reviewing changes for quality and completeness...");
+    const reviewResult = await execClaude(sandboxName, worktreeDir, ["-p", reviewPrompt]);
+    if (reviewResult) lastResult = reviewResult;
+  }
+
+  // Phase 4 — Cleanup
   cleanupPlanFile(sandboxName, worktreeDir);
 
   const finalPlan = readPlanFile(worktreeDir);