@bobbyg603/mog 0.2.0 → 1.0.0

package/README.md

@@ -91,6 +91,7 @@ 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 |
 
 ## Worktree management
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbyg603/mog",
-  "version": "0.2.0",
+  "version": "1.0.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",
@@ -22,6 +22,9 @@
     "docker",
     "sandbox"
   ],
+  "scripts": {
+    "dev:reset": "docker sandbox rm mog && docker rmi mog-template:latest 2>/dev/null; echo 'Sandbox removed. Run mog init to recreate.'"
+  },
   "license": "MIT",
   "devDependencies": {
     "@types/bun": "latest"

package/src/github.ts

@@ -6,7 +6,7 @@ export interface Issue {
   labels: string;
 }
 
-export async function fetchIssue(repo: string, issueNum: string): Promise<Issue> {
+export function fetchIssue(repo: string, issueNum: string): Issue {
   log.info(`Fetching issue #${issueNum} from ${repo}...`);
 
   const proc = Bun.spawnSync([
@@ -28,14 +28,14 @@ export async function fetchIssue(repo: string, issueNum: string): Promise<Issue>
   };
 }
 
-export async function pushAndCreatePR(
+export function pushAndCreatePR(
   repo: string,
   worktreeDir: string,
   branchName: string,
   defaultBranch: string,
   issueNum: string,
   issue: Issue
-) {
+): void {
   // Check for unpushed commits or uncommitted changes
   const unpushed = Bun.spawnSync(["git", "log", `origin/${defaultBranch}..HEAD`, "--oneline"], { cwd: worktreeDir });
   const diffCheck = Bun.spawnSync(["git", "diff", "--quiet"], { cwd: worktreeDir });
@@ -53,8 +53,15 @@ export async function pushAndCreatePR(
   // Stage any unstaged changes Claude might have left
   if (hasUncommitted) {
     log.info("Staging uncommitted changes...");
-    Bun.spawnSync(["git", "add", "-A"], { cwd: worktreeDir });
-    Bun.spawnSync(["git", "commit", "-m", `fix: address issue #${issueNum} - ${issue.title}`], { cwd: worktreeDir });
+    const addResult = Bun.spawnSync(["git", "add", "-A"], { cwd: worktreeDir });
+    if (addResult.exitCode !== 0) {
+      log.die("Failed to stage changes.");
+    }
+    const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
+    const commitResult = Bun.spawnSync(["git", "commit", "-m", `${prefix}: address issue #${issueNum} - ${issue.title}`], { cwd: worktreeDir });
+    if (commitResult.exitCode !== 0) {
+      log.warn("Commit failed — changes may already be committed.");
+    }
   }
 
   // Push
@@ -81,7 +88,8 @@ ${issue.body}
 ---
 *Please review the changes carefully before merging.*`;
 
-  const prTitle = `fix: ${issue.title} [#${issueNum}]`;
+  const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
+  const prTitle = `${prefix}: ${issue.title} [#${issueNum}]`;
 
   const pr = Bun.spawnSync([
     "gh", "pr", "create",

package/src/index.ts

@@ -1,9 +1,8 @@
 #!/usr/bin/env bun
 
-import { spawnSync } from "child_process";
 import { fetchIssue } from "./github";
 import { ensureRepo, createWorktree } from "./worktree";
-import { ensureSandbox, runClaude } from "./sandbox";
+import { runClaude } from "./sandbox";
 import { pushAndCreatePR } from "./github";
 import { log } from "./log";
 
@@ -14,7 +13,7 @@ async function init() {
   log.info("Initializing mog sandbox...");
 
   const reposDir = getReposDir();
-  const exists = await sandboxExists(SANDBOX_NAME);
+  const exists = sandboxExists(SANDBOX_NAME);
 
   if (exists) {
     log.warn(`Sandbox '${SANDBOX_NAME}' already exists.`);
@@ -22,10 +21,10 @@ async function init() {
   } else {
     log.info(`Creating persistent sandbox '${SANDBOX_NAME}'...`);
     log.info(`Workspace: ${reposDir}`);
-    const createResult = spawnSync("docker", ["sandbox", "create", "--name", SANDBOX_NAME, "claude", reposDir], {
-      stdio: "inherit",
+    const createResult = Bun.spawnSync(["docker", "sandbox", "create", "--name", SANDBOX_NAME, "claude", reposDir], {
+      stdio: ["inherit", "inherit", "inherit"],
     });
-    const createExit = createResult.status;
+    const createExit = createResult.exitCode;
     if (createExit !== 0) {
       log.die("Failed to create sandbox.");
     }
@@ -36,20 +35,20 @@ async function init() {
     console.log();
   }
 
-  const runResult = spawnSync("docker", ["sandbox", "run", SANDBOX_NAME], {
-    stdio: "inherit",
+  const runResult = Bun.spawnSync(["docker", "sandbox", "run", SANDBOX_NAME], {
+    stdio: ["inherit", "inherit", "inherit"],
   });
-  const exitCode = runResult.status;
+  const exitCode = runResult.exitCode;
   if (exitCode !== 0) {
     log.die("Sandbox failed to run. Try 'docker sandbox ls' to check its status.");
   }
 
   // Save sandbox as template so it can be restored after Docker restarts
   log.info("Saving sandbox snapshot (preserves auth across Docker restarts)...");
-  const saveResult = spawnSync("docker", ["sandbox", "save", SANDBOX_NAME, TEMPLATE_TAG], {
-    stdio: "inherit",
+  const saveResult = Bun.spawnSync(["docker", "sandbox", "save", SANDBOX_NAME, TEMPLATE_TAG], {
+    stdio: ["inherit", "inherit", "inherit"],
   });
-  if (saveResult.status !== 0) {
+  if (saveResult.exitCode !== 0) {
     log.warn("Failed to save sandbox snapshot. Auth may not persist across Docker restarts.");
   } else {
     log.ok("Snapshot saved.");
@@ -69,10 +68,12 @@ async function main() {
     }
   }
 
+  const reposDir = getReposDir();
+
   // Check docker sandbox is available (may fail if sandbox state is stale after Docker restart)
   const sandboxCheck = Bun.spawnSync(["docker", "sandbox", "ls"]);
   if (sandboxCheck.exitCode !== 0) {
-    const recovered = tryRecoverSandbox(getReposDir());
+    const recovered = tryRecoverSandbox(reposDir);
     if (!recovered) {
       log.die("Docker sandbox not available. Make sure Docker Desktop is running and up to date.");
     }
@@ -96,6 +97,11 @@ async function main() {
 
   const repo = args[0];
   const issueNum = args[1];
+
+  if (!/^\d+$/.test(issueNum)) {
+    log.die(`Invalid issue number: '${issueNum}'. Must be a positive integer.`);
+  }
+
   const [owner, repoName] = repo.split("/");
 
   if (!owner || !repoName) {
@@ -103,12 +109,11 @@ async function main() {
   }
 
   // Verify sandbox exists, try to restore from template if missing
-  if (!(await sandboxExists(SANDBOX_NAME))) {
+  if (!sandboxExists(SANDBOX_NAME)) {
     if (!templateExists()) {
       log.die(`Sandbox '${SANDBOX_NAME}' not found. Run 'mog init' first.`);
     }
     log.info("Sandbox missing — restoring from saved snapshot...");
-    const reposDir = getReposDir();
     const restored = restoreSandboxFromTemplate(SANDBOX_NAME, reposDir);
     if (!restored) {
       log.die("Failed to restore sandbox from snapshot. Run 'mog init' to recreate.");
@@ -117,15 +122,14 @@ async function main() {
   }
 
   // Fetch issue
-  const issue = await fetchIssue(repo, issueNum);
+  const issue = fetchIssue(repo, issueNum);
   log.ok(`Issue: ${issue.title}`);
 
   // Ensure repo & worktree
-  const reposDir = getReposDir();
-  const { defaultBranch } = await ensureRepo(repo, owner, repoName, reposDir);
+  const { defaultBranch } = ensureRepo(repo, owner, repoName, reposDir);
   log.info(`Default branch: ${defaultBranch}`);
 
-  const { worktreeDir, branchName } = await createWorktree(
+  const { worktreeDir, branchName } = createWorktree(
     reposDir, owner, repoName, defaultBranch, issueNum, issue.title
   );
 
@@ -141,17 +145,16 @@ async function main() {
   await runClaude(SANDBOX_NAME, worktreeDir, prompt);
 
   // Push and create PR
-  await pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue);
+  pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue);
 }
 
 function getReposDir(): string {
   return process.env.MOG_REPOS_DIR || `${process.env.HOME}/mog-repos`;
 }
 
-async function sandboxExists(name: string): Promise<boolean> {
+function sandboxExists(name: string): boolean {
   const result = Bun.spawnSync(["docker", "sandbox", "ls"]);
-  const output = result.stdout.toString();
-  return output.includes(name);
+  return result.stdout.toString().split("\n").some(line => line.split(/\s+/)[0] === name);
 }
 
 function templateExists(): boolean {
@@ -160,17 +163,17 @@ function templateExists(): boolean {
 }
 
 function restoreSandboxFromTemplate(name: string, reposDir: string): boolean {
-  const create = spawnSync("docker", ["sandbox", "create", "--template", TEMPLATE_TAG, "--name", name, "claude", reposDir], {
-    stdio: "inherit",
+  const create = Bun.spawnSync(["docker", "sandbox", "create", "--template", TEMPLATE_TAG, "--name", name, "claude", reposDir], {
+    stdio: ["inherit", "inherit", "inherit"],
   });
-  return create.status === 0;
+  return create.exitCode === 0;
 }
 
 function tryRecoverSandbox(reposDir: string): boolean {
   log.warn("Docker sandbox state is stale — attempting recovery...");
 
   // Clean up stale sandbox
-  spawnSync("docker", ["sandbox", "rm", SANDBOX_NAME], { stdio: "ignore" });
+  Bun.spawnSync(["docker", "sandbox", "rm", SANDBOX_NAME], { stdio: ["ignore", "ignore", "ignore"] });
 
   // Check if docker sandbox ls works now
   const check = Bun.spawnSync(["docker", "sandbox", "ls"]);
@@ -194,14 +197,6 @@ function tryRecoverSandbox(reposDir: string): boolean {
   return true;
 }
 
-async function run(cmd: string[]): Promise<string> {
-  const proc = Bun.spawnSync(cmd);
-  if (proc.exitCode !== 0) {
-    throw new Error(`Command failed: ${cmd.join(" ")}\n${proc.stderr.toString()}`);
-  }
-  return proc.stdout.toString().trim();
-}
-
 function buildPrompt(repo: string, issueNum: string, issue: { title: string; body: string; labels: string }): string {
   return `You are working on GitHub issue #${issueNum} for the repository ${repo}.
 

package/src/sandbox.ts

@@ -15,39 +15,46 @@ interface StreamEvent {
   is_error?: boolean;
 }
 
-export async function ensureSandbox(name: string, reposDir: string, templateTag?: string): Promise<void> {
-  const ls = Bun.spawnSync(["docker", "sandbox", "ls"]);
-  if (ls.stdout.toString().includes(name)) {
-    return;
-  }
+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.`;
+
+export async function runClaude(sandboxName: string, worktreeDir: string, prompt: string): Promise<void> {
+  // Initial run
+  await execClaude(sandboxName, worktreeDir, ["-p", prompt]);
 
-  // Try to restore from template if available
-  const createArgs = ["sandbox", "create"];
-  if (templateTag) {
-    const inspect = Bun.spawnSync(["docker", "image", "inspect", templateTag]);
-    if (inspect.exitCode === 0) {
-      log.info(`Restoring sandbox '${name}' from saved snapshot...`);
-      createArgs.push("--template", templateTag);
+  // 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]);
   }
-  createArgs.push("--name", name, "claude", reposDir);
 
-  log.info(`Creating persistent sandbox '${name}'...`);
-  const create = Bun.spawnSync(["docker", ...createArgs]);
-  if (create.exitCode !== 0) {
-    log.die(`Failed to create sandbox: ${create.stderr.toString()}`);
+  if (!hasNewCommits(sandboxName, worktreeDir)) {
+    log.warn("Claude did not produce any commits after all attempts.");
   }
-  log.ok("Sandbox created.");
 }
 
-export async function runClaude(sandboxName: string, worktreeDir: string, prompt: string): Promise<void> {
+function hasNewCommits(sandboxName: string, worktreeDir: string): boolean {
+  const result = Bun.spawnSync([
+    "docker", "sandbox", "exec",
+    "-w", worktreeDir,
+    sandboxName,
+    "git", "log", "--oneline", "HEAD", "--not", "--remotes", "-1",
+  ]);
+  return result.exitCode === 0 && result.stdout.toString().trim().length > 0;
+}
+
+async function execClaude(sandboxName: string, worktreeDir: string, claudeArgs: string[]): Promise<void> {
   const proc = Bun.spawn([
     "docker", "sandbox", "exec",
     "-w", worktreeDir,
     sandboxName,
     "claude", "--dangerously-skip-permissions",
     "--verbose", "--output-format", "stream-json",
-    "-p", prompt,
+    ...claudeArgs,
   ], {
     stdout: "pipe",
     stderr: "pipe",

package/src/worktree.ts

@@ -1,13 +1,13 @@
+import fs from "fs";
 import { log } from "./log";
 
-export async function ensureRepo(
+export function ensureRepo(
   repo: string,
   owner: string,
   repoName: string,
   reposDir: string
-): Promise<{ defaultBranch: string }> {
+): { defaultBranch: string } {
   const repoDir = `${reposDir}/${owner}/${repoName}`;
-  const fs = await import("fs");
 
   if (!fs.existsSync(repoDir)) {
     log.info(`Cloning ${repo} into ${repoDir}...`);
@@ -37,14 +37,14 @@ export async function ensureRepo(
   return { defaultBranch: branchProc.stdout.toString().trim() };
 }
 
-export async function createWorktree(
+export function createWorktree(
   reposDir: string,
   owner: string,
   repoName: string,
   defaultBranch: string,
   issueNum: string,
   issueTitle: string
-): Promise<{ worktreeDir: string; branchName: string }> {
+): { worktreeDir: string; branchName: string } {
   const safeTitle = issueTitle
     .toLowerCase()
     .replace(/[^a-z0-9]/g, "-")
@@ -56,8 +56,6 @@ export async function createWorktree(
   const repoDir = `${reposDir}/${owner}/${repoName}`;
   const worktreeDir = `${reposDir}/${owner}/${repoName}-worktrees/${branchName}`;
 
-  const fs = await import("fs");
-
   if (fs.existsSync(worktreeDir)) {
     log.warn(`Worktree already exists at ${worktreeDir}, reusing.`);
     return { worktreeDir, branchName };