@bobbyg603/mog 1.0.2 → 1.1.0

package/README.md

@@ -1,4 +1,4 @@
-<img width="300" alt="claude moggin" src="https://github.com/user-attachments/assets/089db43c-7381-4e62-87bc-af2e7cd0129f" />
+<img width="300" alt="claude moggin" src="https://github.com/user-attachments/assets/bed005f3-12c3-47ee-8b6e-6974ed4e0a79" />
 
 
 # mog — Sandboxed Claude Issue Mogging
@@ -91,7 +91,8 @@ mog sparx-tech/hub-firmware 45
 | Environment Variable | Default | Description |
 |---|---|---|
 | `MOG_REPOS_DIR` | `~/mog-repos` | Where repos are cloned and worktrees created (also the sandbox workspace) |
-| `MOG_MAX_CONTINUATIONS` | `5` | Max times Claude is re-prompted if it stops without committing |
+| `MOG_MAX_ITERATIONS` | `10` | Max build loop iterations per issue |
+| `MOG_MAX_CONTINUATIONS` | — | Legacy alias for `MOG_MAX_ITERATIONS` |
 
 ## Worktree management
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbyg603/mog",
-  "version": "1.0.2",
+  "version": "1.1.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/index.ts

@@ -133,8 +133,10 @@ async function main() {
     reposDir, owner, repoName, defaultBranch, issueNum, issue.title
   );
 
-  // Build prompt
-  const prompt = buildPrompt(repo, issueNum, issue);
+  // Build prompts
+  const planningPrompt = buildPlanningPrompt(repo, issueNum, issue);
+  const buildingPromptFn = (remaining: string[], plan: string) =>
+    buildBuildingPrompt(repo, issueNum, issue, remaining, plan);
 
   // Run Claude in sandbox
   log.info("Launching Claude Code in sandbox...");
@@ -142,7 +144,7 @@ async function main() {
   log.info(`Worktree: ${worktreeDir}`);
   console.log();
 
-  await runClaude(SANDBOX_NAME, worktreeDir, prompt);
+  await runClaude(SANDBOX_NAME, worktreeDir, planningPrompt, buildingPromptFn);
 
   // Push and create PR
   pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue);
@@ -197,7 +199,7 @@ function tryRecoverSandbox(reposDir: string): boolean {
   return true;
 }
 
-function buildPrompt(repo: string, issueNum: string, issue: { title: string; body: string; labels: string }): string {
+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}
@@ -208,6 +210,52 @@ ${issue.body}
 ### Labels
 ${issue.labels}
 
+## 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.
+
+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
+- Use markdown checklist format: \`- [ ] Task description\`
+
+Example format:
+\`\`\`markdown
+# Implementation Plan for #${issueNum}
+
+- [ ] Add the FooBar interface to src/types.ts
+- [ ] Implement the FooBar service in src/services/foobar.ts
+- [ ] Update the main handler to use FooBar service
+- [ ] Add unit tests for FooBar service
+\`\`\`
+
+Do NOT implement any code changes. Do NOT make any commits. Only create the plan file.`;
+}
+
+function buildBuildingPrompt(
+  repo: string,
+  issueNum: string,
+  issue: { title: string; body: string; labels: string },
+  remainingItems: string[],
+  planContent: string,
+): string {
+  // Fallback: no plan — use original single-shot prompt
+  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}
+
 ## Instructions
 1. Read and understand the codebase structure first.
 2. Implement the changes described in the issue above.
@@ -218,6 +266,35 @@ ${issue.labels}
 
 When you are done, make a single commit (or a small, logical set of commits) with
 a message like: "fix: <short description> (#${issueNum})"`;
+  }
+
+  const currentTask = remainingItems[0]?.replace("- [ ] ", "") || "Complete remaining work";
+
+  return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
+
+## Issue: ${issue.title}
+
+### Description
+${issue.body}
+
+### Labels
+${issue.labels}
+
+## Current Implementation Plan
+
+${planContent}
+
+## Instructions
+
+Implement ONLY the following task:
+**${currentTask}**
+
+Rules:
+1. Implement ONLY this one task — do not work on other unchecked items.
+2. Write clean code that follows the existing project conventions.
+3. Update \`IMPLEMENTATION_PLAN.md\` to check off the completed item (change \`- [ ]\` to \`- [x]\`).
+4. Commit ALL changes (including the updated plan file) with a message like: "feat: ${currentTask.toLowerCase()} (#${issueNum})"
+5. Do NOT work on any other tasks after committing.`;
 }
 
 main().catch((err) => {

package/src/sandbox.ts

@@ -1,3 +1,4 @@
+import fs from "fs";
 import { log } from "./log";
 
 interface StreamEvent {
@@ -15,36 +16,149 @@ interface StreamEvent {
   is_error?: boolean;
 }
 
-const MAX_CONTINUATIONS = parseInt(process.env.MOG_MAX_CONTINUATIONS || "5", 10);
-const CONTINUE_PROMPT = `You stopped before finishing. The task is not done yet — there are no commits.
-Continue where you left off. Do NOT re-plan. Execute the implementation now and commit when done.`;
+const MAX_ITERATIONS = parseInt(
+  process.env.MOG_MAX_ITERATIONS || process.env.MOG_MAX_CONTINUATIONS || "30",
+  10,
+);
+const MAX_STALLS = 2;
+const PLAN_FILENAME = "IMPLEMENTATION_PLAN.md";
 
-export async function runClaude(sandboxName: string, worktreeDir: string, prompt: string): Promise<void> {
-  // Initial run
-  await execClaude(sandboxName, worktreeDir, ["-p", prompt]);
-
-  // Continue loop: if no commits were made, nudge Claude to keep going
-  for (let i = 0; i < MAX_CONTINUATIONS; i++) {
-    if (hasNewCommits(sandboxName, worktreeDir)) {
-      return;
-    }
-    log.warn(`No commits yet — continuing Claude (attempt ${i + 2}/${MAX_CONTINUATIONS + 1})...`);
-    await execClaude(sandboxName, worktreeDir, ["--continue", "-p", CONTINUE_PROMPT]);
+export function readPlanFile(worktreeDir: string): string | null {
+  const planPath = `${worktreeDir}/${PLAN_FILENAME}`;
+  try {
+    return fs.readFileSync(planPath, "utf-8");
+  } catch {
+    return null;
   }
+}
 
-  if (!hasNewCommits(sandboxName, worktreeDir)) {
-    log.warn("Claude did not produce any commits after all attempts.");
-  }
+export function getUncheckedItems(planContent: string): string[] {
+  const matches = planContent.match(/^- \[ \] .+$/gm);
+  return matches || [];
+}
+
+export function isPlanComplete(planContent: string): boolean {
+  const unchecked = getUncheckedItems(planContent);
+  const checked = planContent.match(/^- \[x\] .+$/gim);
+  return unchecked.length === 0 && (checked?.length ?? 0) > 0;
 }
 
-function hasNewCommits(sandboxName: string, worktreeDir: string): boolean {
+function getCommitCount(sandboxName: string, worktreeDir: string): number {
   const result = Bun.spawnSync([
     "docker", "sandbox", "exec",
     "-w", worktreeDir,
     sandboxName,
-    "git", "log", "--oneline", "HEAD", "--not", "--remotes", "-1",
+    "git", "rev-list", "HEAD", "--not", "--remotes", "--count",
+  ]);
+  if (result.exitCode !== 0) return 0;
+  return parseInt(result.stdout.toString().trim(), 10) || 0;
+}
+
+function cleanupPlanFile(sandboxName: string, worktreeDir: string): void {
+  const rmResult = Bun.spawnSync([
+    "docker", "sandbox", "exec",
+    "-w", worktreeDir,
+    sandboxName,
+    "git", "rm", "-f", PLAN_FILENAME,
+  ]);
+  if (rmResult.exitCode !== 0) return;
+
+  Bun.spawnSync([
+    "docker", "sandbox", "exec",
+    "-w", worktreeDir,
+    sandboxName,
+    "git", "commit", "-m", "chore: remove implementation plan",
   ]);
-  return result.exitCode === 0 && result.stdout.toString().trim().length > 0;
+}
+
+export async function runClaude(
+  sandboxName: string,
+  worktreeDir: string,
+  planningPrompt: string,
+  buildingPromptFn: (remainingItems: string[], planContent: string) => string,
+): Promise<void> {
+  // Phase 1 — Planning
+  log.info("Phase 1: Creating implementation plan...");
+  await execClaude(sandboxName, worktreeDir, ["-p", planningPrompt]);
+
+  const planContent = readPlanFile(worktreeDir);
+  const unchecked = planContent ? getUncheckedItems(planContent) : [];
+
+  // Fallback: no plan file or no checklist items — single-shot mode
+  if (!planContent || unchecked.length === 0) {
+    log.warn("No implementation plan created — falling back to single-shot mode.");
+    const fallbackPrompt = buildingPromptFn([], "");
+    await execClaude(sandboxName, worktreeDir, ["-p", fallbackPrompt]);
+
+    for (let i = 0; i < MAX_ITERATIONS; i++) {
+      if (getCommitCount(sandboxName, worktreeDir) > 0) return;
+      log.warn(`No commits yet — continuing Claude (attempt ${i + 2}/${MAX_ITERATIONS + 1})...`);
+      await execClaude(sandboxName, worktreeDir, [
+        "--continue", "-p",
+        "You stopped before finishing. The task is not done yet — there are no commits. Continue where you left off. Do NOT re-plan. Execute the implementation now and commit when done.",
+      ]);
+    }
+
+    if (getCommitCount(sandboxName, worktreeDir) === 0) {
+      log.warn("Claude did not produce any commits after all attempts.");
+    }
+    return;
+  }
+
+  log.ok(`Implementation plan created with ${unchecked.length} task(s).`);
+
+  // Phase 2 — Building loop
+  let stallCount = 0;
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const currentPlan = readPlanFile(worktreeDir);
+    if (!currentPlan) {
+      log.warn("Plan file disappeared — stopping build loop.");
+      break;
+    }
+
+    const remaining = getUncheckedItems(currentPlan);
+    if (remaining.length === 0) {
+      log.ok("All plan items completed.");
+      break;
+    }
+
+    const commitsBefore = getCommitCount(sandboxName, worktreeDir);
+    const uncheckedBefore = remaining.length;
+
+    log.info(`Iteration ${i + 1}/${MAX_ITERATIONS}: ${remaining[0].replace("- [ ] ", "")}`);
+    log.info(`${remaining.length} task(s) remaining.`);
+
+    await execClaude(sandboxName, worktreeDir, ["-p", buildingPromptFn(remaining, currentPlan)]);
+
+    const planAfter = readPlanFile(worktreeDir);
+    const uncheckedAfter = planAfter ? getUncheckedItems(planAfter).length : 0;
+    const commitsAfter = getCommitCount(sandboxName, worktreeDir);
+
+    if (uncheckedAfter >= uncheckedBefore && commitsAfter <= commitsBefore) {
+      stallCount++;
+      log.warn(`No progress detected (stall ${stallCount}/${MAX_STALLS}).`);
+      if (stallCount >= MAX_STALLS) {
+        log.warn("Claude appears stuck — stopping build loop.");
+        break;
+      }
+    } else {
+      stallCount = 0;
+    }
+  }
+
+  // Phase 3 — Cleanup
+  cleanupPlanFile(sandboxName, worktreeDir);
+
+  const finalPlan = readPlanFile(worktreeDir);
+  if (finalPlan) {
+    const finalRemaining = getUncheckedItems(finalPlan);
+    if (finalRemaining.length > 0) {
+      log.warn(`${finalRemaining.length} task(s) were not completed.`);
+    }
+  } else {
+    log.ok("Plan file cleaned up.");
+  }
 }
 
 async function execClaude(sandboxName: string, worktreeDir: string, claudeArgs: string[]): Promise<void> {