@bobbyg603/mog 0.1.3 → 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.1.3",
+  "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,19 +1,19 @@
 #!/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";
 
 const SANDBOX_NAME = "mog";
+const TEMPLATE_TAG = "mog-template:latest";
 
 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.`);
@@ -21,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.");
     }
@@ -35,14 +35,25 @@ 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 = Bun.spawnSync(["docker", "sandbox", "save", SANDBOX_NAME, TEMPLATE_TAG], {
+    stdio: ["inherit", "inherit", "inherit"],
+  });
+  if (saveResult.exitCode !== 0) {
+    log.warn("Failed to save sandbox snapshot. Auth may not persist across Docker restarts.");
+  } else {
+    log.ok("Snapshot saved.");
+  }
+
   log.ok("mog is ready. Run: mog <owner/repo> <issue_number>");
 }
 
@@ -57,10 +68,15 @@ async function main() {
     }
   }
 
-  // Check docker sandbox is available
+  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) {
-    log.die("Docker sandbox not available. Make sure Docker Desktop is running and up to date.");
+    const recovered = tryRecoverSandbox(reposDir);
+    if (!recovered) {
+      log.die("Docker sandbox not available. Make sure Docker Desktop is running and up to date.");
+    }
   }
 
   if (args[0] === "init") {
@@ -81,27 +97,39 @@ 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) {
     log.die("Invalid repo format. Use: owner/repo");
   }
 
-  // Verify sandbox exists
-  if (!(await sandboxExists(SANDBOX_NAME))) {
-    log.die(`Sandbox '${SANDBOX_NAME}' not found. Run 'mog init' first.`);
+  // Verify sandbox exists, try to restore from template if missing
+  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 restored = restoreSandboxFromTemplate(SANDBOX_NAME, reposDir);
+    if (!restored) {
+      log.die("Failed to restore sandbox from snapshot. Run 'mog init' to recreate.");
+    }
+    log.ok("Sandbox restored from snapshot (auth preserved).");
   }
 
   // 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
   );
 
@@ -117,25 +145,56 @@ 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 {
+  const result = Bun.spawnSync(["docker", "image", "inspect", TEMPLATE_TAG]);
+  return result.exitCode === 0;
+}
+
+function restoreSandboxFromTemplate(name: string, reposDir: string): boolean {
+  const create = Bun.spawnSync(["docker", "sandbox", "create", "--template", TEMPLATE_TAG, "--name", name, "claude", reposDir], {
+    stdio: ["inherit", "inherit", "inherit"],
+  });
+  return create.exitCode === 0;
 }
 
-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()}`);
+function tryRecoverSandbox(reposDir: string): boolean {
+  log.warn("Docker sandbox state is stale — attempting recovery...");
+
+  // Clean up stale sandbox
+  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"]);
+  if (check.exitCode !== 0) {
+    // docker sandbox itself is broken, not just stale state
+    return false;
+  }
+
+  // If we have a saved template, restore from it
+  if (templateExists()) {
+    log.info("Restoring sandbox from saved snapshot...");
+    const restored = restoreSandboxFromTemplate(SANDBOX_NAME, reposDir);
+    if (restored) {
+      log.ok("Sandbox restored from snapshot (auth preserved).");
+      return true;
+    }
   }
-  return proc.stdout.toString().trim();
+
+  // Recovered docker sandbox command but no template — user needs to mog init
+  log.warn("No saved snapshot found. Run 'mog init' to set up the sandbox.");
+  return true;
 }
 
 function buildPrompt(repo: string, issueNum: string, issue: { title: string; body: string; labels: string }): string {

package/src/sandbox.ts

@@ -15,28 +15,46 @@ interface StreamEvent {
   is_error?: boolean;
 }
 
-export async function ensureSandbox(name: string, reposDir: 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]);
+
+  // 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]);
   }
 
-  log.info(`Creating persistent sandbox '${name}'...`);
-  const create = Bun.spawnSync(["docker", "sandbox", "create", "--name", name, "claude", reposDir]);
-  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 };