@bobbyg603/mog 0.1.0

package/README.md

@@ -0,0 +1,146 @@
+<img width="300" alt="claude moggin" src="https://github.com/user-attachments/assets/089db43c-7381-4e62-87bc-af2e7cd0129f" />
+
+
+# mog — Sandboxed Claude Issue Mogging
+
+One command to go from GitHub issue to pull request, powered by Claude Code running in a Docker sandbox.
+
+```
+mog workingdevshero/automate-it 123
+```
+
+That's it. `mog` will:
+
+1. Fetch the issue title, description, and labels via `gh` CLI
+2. Create a git worktree on a clean branch (`123-fix-broken-login`)
+3. Run Claude Code inside a persistent Docker sandbox (microVM) with `--dangerously-skip-permissions`
+4. Push the branch and open a PR that `Closes #123`
+
+## Prerequisites
+
+- **macOS or Windows** (Docker sandbox microVMs require Docker Desktop)
+- **Docker Desktop** — running and up to date (must support `docker sandbox`)
+- **Bun** — install from [bun.sh](https://bun.sh)
+- **GitHub CLI** (`gh`) — authenticated via `gh auth login`
+- **Git** with push access to your target repos
+
+## Install
+
+```bash
+bun install -g @bobbyg603/mog
+```
+
+## Quick start
+
+```bash
+# 1. One-time setup: create sandbox & authenticate
+mog init
+# This launches Claude Code — use /login to authenticate with your Max subscription
+# Once logged in, type /exit to return
+
+# 2. Start mogging issues
+mog workingdevshero/automate-it 123
+```
+
+## How authentication works
+
+`mog init` creates a **persistent** Docker sandbox named `mog`. When it launches, you authenticate once using `/login` inside the Claude Code session. Your auth persists in the sandbox across all future `mog` runs — you never need to login again.
+
+If your session ever expires, just run `mog init` again to re-authenticate.
+
+## Usage
+
+```bash
+# One-time setup
+mog init
+
+# Basic usage
+mog owner/repo issue_number
+
+# Examples
+mog workingdevshero/automate-it 123
+mog sparx-tech/hub-firmware 45
+```
+
+## How it works
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  Host machine                                            │
+│                                                          │
+│  1. gh issue view #123 → fetch title, body, labels       │
+│  2. git worktree add → clean branch from default branch  │
+│                                                          │
+│  ┌────────────────────────────────────────────────────┐  │
+│  │  Docker sandbox "mog" (persistent microVM)         │  │
+│  │                                                    │  │
+│  │  • ~/mog-repos mounted as workspace                │  │
+│  │  • Auth persists across runs (login once)          │  │
+│  │  • Isolated from host (own Docker daemon)          │  │
+│  │  • claude --dangerously-skip-permissions -p "..."  │  │
+│  │  • Reads code, implements fix, commits             │  │
+│  └────────────────────────────────────────────────────┘  │
+│                                                          │
+│  3. git push origin branch                               │
+│  4. gh pr create --body "Closes #123"                    │
+└──────────────────────────────────────────────────────────┘
+```
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---|---|---|
+| `MOG_REPOS_DIR` | `~/mog-repos` | Where repos are cloned and worktrees created (also the sandbox workspace) |
+
+## Worktree management
+
+`mog` uses bare clones and git worktrees so you can run multiple issues concurrently without conflicts:
+
+```
+~/mog-repos/
+  owner/
+    repo/                    ← bare clone (or full clone)
+    repo-worktrees/
+      123-fix-broken-login/  ← worktree for issue #123
+      456-add-dark-mode/     ← worktree for issue #456
+```
+
+Clean up when done:
+
+```bash
+cd ~/mog-repos/owner/repo
+git worktree remove ../repo-worktrees/123-fix-broken-login
+```
+
+## Security notes
+
+- Claude Code runs inside a **microVM** via Docker sandbox — it has its own Docker daemon and cannot access your host system, terminal, or files outside `~/mog-repos`.
+- `--dangerously-skip-permissions` is safe here because the sandbox provides the isolation boundary.
+- `gh` credentials stay on your host — the sandbox has **no access** to your GitHub token. Pushing and PR creation happen on the host after Claude finishes.
+- The sandbox has network access (required for the Anthropic API).
+
+## Troubleshooting
+
+**"Docker sandbox not available"** — Make sure Docker Desktop is running and up to date.
+
+**"Sandbox 'mog' not found"** — Run `mog init` first to create the sandbox and authenticate.
+
+**"Failed to fetch issue"** — Check `gh auth status` and verify the repo/issue exist.
+
+**"No changes detected"** — Claude may have struggled with the issue. Check the worktree manually, or re-run with a more detailed issue description.
+
+**"Failed to push"** — Ensure `gh` is authenticated with push access. Try `gh auth login` and select HTTPS.
+
+## Managing the sandbox
+
+```bash
+# List sandboxes
+docker sandbox ls
+
+# Stop the sandbox (preserves auth)
+docker sandbox stop mog
+
+# Remove and recreate (you'll need to /login again)
+docker sandbox rm mog
+mog init
+```

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@bobbyg603/mog",
+  "version": "0.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",
+  "bin": {
+    "mog": "src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/workingdevshero/mog.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "github",
+    "automation",
+    "docker",
+    "sandbox"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/src/github.ts

@@ -0,0 +1,107 @@
+import { log } from "./log";
+
+export interface Issue {
+  title: string;
+  body: string;
+  labels: string;
+}
+
+export async function fetchIssue(repo: string, issueNum: string): Promise<Issue> {
+  log.info(`Fetching issue #${issueNum} from ${repo}...`);
+
+  const proc = Bun.spawnSync([
+    "gh", "issue", "view", issueNum,
+    "--repo", repo,
+    "--json", "title,body,labels",
+  ]);
+
+  if (proc.exitCode !== 0) {
+    log.die(`Failed to fetch issue #${issueNum}. Check repo name and issue number.`);
+  }
+
+  const json = JSON.parse(proc.stdout.toString());
+
+  return {
+    title: json.title,
+    body: json.body || "No description provided.",
+    labels: json.labels?.map((l: { name: string }) => l.name).join(", ") || "none",
+  };
+}
+
+export async function pushAndCreatePR(
+  repo: string,
+  worktreeDir: string,
+  branchName: string,
+  defaultBranch: string,
+  issueNum: string,
+  issue: Issue
+) {
+  // 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 });
+  const cachedCheck = Bun.spawnSync(["git", "diff", "--cached", "--quiet"], { cwd: worktreeDir });
+
+  const hasUnpushed = unpushed.stdout.toString().trim().length > 0;
+  const hasUncommitted = diffCheck.exitCode !== 0 || cachedCheck.exitCode !== 0;
+
+  if (!hasUnpushed && !hasUncommitted) {
+    log.warn("No changes detected. Claude may not have made any modifications.");
+    log.warn(`Worktree: ${worktreeDir}`);
+    return;
+  }
+
+  // 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 });
+  }
+
+  // Push
+  log.info(`Pushing branch '${branchName}' to origin...`);
+  const push = Bun.spawnSync(["git", "push", "-u", "origin", branchName], { cwd: worktreeDir });
+  if (push.exitCode !== 0) {
+    log.die("Failed to push. Check your git credentials.");
+  }
+  log.ok("Branch pushed.");
+
+  // Create PR
+  log.info("Opening pull request...");
+
+  const prBody = `## Summary
+
+Closes #${issueNum}
+
+This PR was generated by [mog](https://github.com/workingdevshero/mog) using Claude Code in a Docker sandbox.
+
+### Issue: ${issue.title}
+
+${issue.body}
+
+---
+*Please review the changes carefully before merging.*`;
+
+  const prTitle = `fix: ${issue.title} [#${issueNum}]`;
+
+  const pr = Bun.spawnSync([
+    "gh", "pr", "create",
+    "--repo", repo,
+    "--base", defaultBranch,
+    "--head", branchName,
+    "--title", prTitle,
+    "--body", prBody,
+  ], { cwd: worktreeDir });
+
+  if (pr.exitCode !== 0) {
+    log.die("Failed to create PR. You may need to push first or the PR may already exist.");
+  }
+
+  const prUrl = pr.stdout.toString().trim();
+  log.ok("Pull request created!");
+  console.log(`\x1b[0;32m${prUrl}\x1b[0m`);
+
+  console.log();
+  log.ok(`All done! Issue #${issueNum} → Branch '${branchName}' → PR opened.`);
+  log.info(`Worktree: ${worktreeDir}`);
+  log.info(`To clean up the worktree later: git worktree remove ${worktreeDir}`);
+}

package/src/index.ts

@@ -0,0 +1,158 @@
+#!/usr/bin/env bun
+
+import { fetchIssue } from "./github";
+import { ensureRepo, createWorktree } from "./worktree";
+import { ensureSandbox, runClaude } from "./sandbox";
+import { pushAndCreatePR } from "./github";
+import { log } from "./log";
+
+const SANDBOX_NAME = "mog";
+
+async function init() {
+  log.info("Initializing mog sandbox...");
+
+  const reposDir = getReposDir();
+  const exists = await sandboxExists(SANDBOX_NAME);
+
+  if (exists) {
+    log.warn(`Sandbox '${SANDBOX_NAME}' already exists.`);
+    log.info("Launching sandbox so you can authenticate with /login...");
+  } else {
+    log.info(`Creating persistent sandbox '${SANDBOX_NAME}'...`);
+    log.info(`Workspace: ${reposDir}`);
+    await run(["docker", "sandbox", "create", "--name", SANDBOX_NAME, "claude", reposDir]);
+    log.ok("Sandbox created.");
+    console.log();
+    log.info("Launching sandbox — authenticate with /login to use your Max subscription.");
+    log.info("Once logged in, type /exit or Ctrl+C to return.");
+    console.log();
+  }
+
+  const proc = Bun.spawn(["docker", "sandbox", "run", SANDBOX_NAME], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  await proc.exited;
+
+  log.ok("mog is ready. Run: mog <owner/repo> <issue_number>");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Validate dependencies
+  for (const cmd of ["gh", "git", "docker"]) {
+    const which = Bun.spawnSync(["which", cmd]);
+    if (which.exitCode !== 0) {
+      log.die(`Required command not found: ${cmd}`);
+    }
+  }
+
+  // Check docker sandbox is available
+  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.");
+  }
+
+  if (args[0] === "init") {
+    await init();
+    return;
+  }
+
+  if (args.length < 2) {
+    console.log("Usage:");
+    console.log("  mog init                      — one-time setup (create sandbox & login)");
+    console.log("  mog <owner/repo> <issue_num>  — fetch issue, run Claude, open PR");
+    console.log();
+    console.log("Example:");
+    console.log("  mog init");
+    console.log("  mog workingdevshero/automate-it 123");
+    return;
+  }
+
+  const repo = args[0];
+  const issueNum = args[1];
+  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.`);
+  }
+
+  // Fetch issue
+  const issue = await fetchIssue(repo, issueNum);
+  log.ok(`Issue: ${issue.title}`);
+
+  // Ensure repo & worktree
+  const reposDir = getReposDir();
+  const { defaultBranch } = await ensureRepo(repo, owner, repoName, reposDir);
+  log.info(`Default branch: ${defaultBranch}`);
+
+  const { worktreeDir, branchName } = await createWorktree(
+    reposDir, owner, repoName, defaultBranch, issueNum, issue.title
+  );
+
+  // Build prompt
+  const prompt = buildPrompt(repo, issueNum, issue);
+
+  // Run Claude in sandbox
+  log.info("Launching Claude Code in sandbox...");
+  log.info(`Branch: ${branchName}`);
+  log.info(`Worktree: ${worktreeDir}`);
+  console.log();
+
+  await runClaude(SANDBOX_NAME, worktreeDir, prompt);
+
+  // Push and create PR
+  await 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> {
+  const result = Bun.spawnSync(["docker", "sandbox", "ls"]);
+  const output = result.stdout.toString();
+  return output.includes(name);
+}
+
+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}.
+
+## 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.
+3. Write clean, well-documented code that follows the existing project conventions.
+4. Add or update tests if applicable.
+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}.
+
+When you are done, make a single commit (or a small, logical set of commits) with
+a message like: "fix: <short description> (#${issueNum})"`;
+}
+
+main().catch((err) => {
+  log.die(err.message);
+});

package/src/log.ts

@@ -0,0 +1,18 @@
+const RED = "\x1b[0;31m";
+const GREEN = "\x1b[0;32m";
+const YELLOW = "\x1b[1;33m";
+const CYAN = "\x1b[0;36m";
+const NC = "\x1b[0m";
+
+export const log = {
+  info: (msg: string) => console.log(`${CYAN}[mog]${NC} ${msg}`),
+  ok: (msg: string) => console.log(`${GREEN}[mog]${NC} ${msg}`),
+  warn: (msg: string) => console.log(`${YELLOW}[mog]${NC} ${msg}`),
+  err: (msg: string) => console.error(`${RED}[mog]${NC} ${msg}`),
+  die: (msg: string) => {
+    log.err(msg);
+    process.exit(1);
+  },
+  tool: (name: string, detail: string) => console.log(`${CYAN}[${name}]${NC} ${detail}`),
+  done: (msg: string) => console.log(`\n${GREEN}[done]${NC} ${msg}`),
+};

package/src/sandbox.ts

@@ -0,0 +1,131 @@
+import { log } from "./log";
+
+interface StreamEvent {
+  type: string;
+  subtype?: string;
+  message?: {
+    content?: Array<{
+      type: string;
+      text?: string;
+      name?: string;
+      input?: Record<string, unknown>;
+    }>;
+  };
+  result?: string;
+  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;
+  }
+
+  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()}`);
+  }
+  log.ok("Sandbox created.");
+}
+
+export async function runClaude(sandboxName: string, worktreeDir: string, prompt: string): Promise<void> {
+  const proc = Bun.spawn([
+    "docker", "sandbox", "exec",
+    "-w", worktreeDir,
+    sandboxName,
+    "claude", "--dangerously-skip-permissions",
+    "--verbose", "--output-format", "stream-json",
+    "-p", prompt,
+  ], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  // Stream and parse JSON lines from stdout
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+
+    // Process complete lines
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const event: StreamEvent = JSON.parse(line);
+        printEvent(event);
+      } catch {
+        // Skip malformed JSON lines
+      }
+    }
+  }
+
+  // Process any remaining buffer
+  if (buffer.trim()) {
+    try {
+      const event: StreamEvent = JSON.parse(buffer);
+      printEvent(event);
+    } catch {
+      // Skip
+    }
+  }
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    if (stderr.trim()) {
+      log.warn(stderr.trim());
+    }
+    log.warn(`Claude Code exited with code ${exitCode}.`);
+  }
+}
+
+function printEvent(event: StreamEvent): void {
+  if (event.type === "assistant" && event.message?.content) {
+    for (const block of event.message.content) {
+      if (block.type === "text" && block.text) {
+        console.log(block.text);
+      } else if (block.type === "tool_use" && block.name) {
+        const detail = getToolDetail(block.name, block.input);
+        log.tool(block.name, detail);
+      }
+    }
+  } else if (event.type === "result") {
+    if (event.is_error) {
+      log.err(event.result || "Unknown error");
+    } else if (event.result) {
+      log.done(event.result.slice(0, 200));
+    }
+  }
+}
+
+function getToolDetail(name: string, input?: Record<string, unknown>): string {
+  if (!input) return "";
+
+  switch (name) {
+    case "Read":
+      return String(input.file_path || "");
+    case "Edit":
+      return String(input.file_path || "");
+    case "Write":
+      return String(input.file_path || "");
+    case "Bash":
+      return String(input.description || input.command || "");
+    case "Glob":
+      return String(input.pattern || "");
+    case "Grep":
+      return String(input.pattern || "");
+    default:
+      return JSON.stringify(input).slice(0, 120);
+  }
+}

package/src/worktree.ts

@@ -0,0 +1,91 @@
+import { log } from "./log";
+
+export async function ensureRepo(
+  repo: string,
+  owner: string,
+  repoName: string,
+  reposDir: string
+): Promise<{ defaultBranch: string }> {
+  const repoDir = `${reposDir}/${owner}/${repoName}`;
+  const fs = await import("fs");
+
+  if (!fs.existsSync(repoDir)) {
+    log.info(`Cloning ${repo} into ${repoDir}...`);
+    fs.mkdirSync(`${reposDir}/${owner}`, { recursive: true });
+
+    const clone = Bun.spawnSync(["gh", "repo", "clone", repo, repoDir], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+
+    if (clone.exitCode !== 0) {
+      log.die(`Failed to clone ${repo}.`);
+    }
+  }
+
+  // Get default branch
+  const branchProc = Bun.spawnSync([
+    "gh", "repo", "view", repo,
+    "--json", "defaultBranchRef",
+    "--jq", ".defaultBranchRef.name",
+  ]);
+
+  if (branchProc.exitCode !== 0) {
+    log.die("Failed to determine default branch.");
+  }
+
+  return { defaultBranch: branchProc.stdout.toString().trim() };
+}
+
+export async function createWorktree(
+  reposDir: string,
+  owner: string,
+  repoName: string,
+  defaultBranch: string,
+  issueNum: string,
+  issueTitle: string
+): Promise<{ worktreeDir: string; branchName: string }> {
+  const safeTitle = issueTitle
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50);
+
+  const branchName = `${issueNum}-${safeTitle}`;
+  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 };
+  }
+
+  log.info(`Creating worktree for branch '${branchName}'...`);
+
+  // Fetch latest
+  Bun.spawnSync(["git", "fetch", "origin", defaultBranch], { cwd: repoDir });
+
+  // Try creating branch + worktree
+  const result = Bun.spawnSync(
+    ["git", "worktree", "add", "-b", branchName, worktreeDir, `origin/${defaultBranch}`],
+    { cwd: repoDir }
+  );
+
+  if (result.exitCode !== 0) {
+    // Try using existing branch
+    const fallback = Bun.spawnSync(
+      ["git", "worktree", "add", worktreeDir, branchName],
+      { cwd: repoDir }
+    );
+
+    if (fallback.exitCode !== 0) {
+      log.die(`Failed to create worktree. Branch '${branchName}' may already exist.`);
+    }
+  }
+
+  log.ok(`Worktree created at ${worktreeDir}`);
+  return { worktreeDir, branchName };
+}