@bobbyg603/mog 1.5.2 → 1.6.0

package/README.md

@@ -74,6 +74,33 @@ mog 123 --include .env --include serviceAccountKey.json
 mog list
 mog list --verbose
 mog owner/repo list --verbose
+
+# Check version
+mog --version
+mog -v
+```
+
+### Git identity
+
+`mog` automatically configures the git identity inside the sandbox so commits are attributed correctly. Identity is resolved via a 3-tier priority chain:
+
+1. **Per-repo mog config** (`~/.mog/repos/<owner>/<repo>/config.json`)
+2. **Host git config** (auto-detected at runtime from your local `git config`)
+3. **Global mog config** (`~/.mog/config.json`)
+
+Most users need zero configuration — `mog` reads your host git identity automatically. Use `mog config` to override when needed:
+
+```bash
+# View current per-repo config (auto-detected from git remote)
+mog config
+
+# Set per-repo git identity
+mog config user.name "Your Name"
+mog config user.email "you@example.com"
+
+# Set global fallback identity
+mog config --global user.name "Your Name"
+mog config --global user.email "you@example.com"
 ```
 
 ### Re-mogging
@@ -122,12 +149,32 @@ mog 123 --fresh
 
 ## Configuration
 
+### Environment variables
+
 | Environment Variable | Default | Description |
 |---|---|---|
 | `MOG_REPOS_DIR` | `~/mog-repos` | Where repos are cloned and worktrees created (also the sandbox workspace) |
 | `MOG_MAX_ITERATIONS` | `30` | Max build loop iterations per issue |
 | `MOG_MAX_CONTINUATIONS` | — | Legacy alias for `MOG_MAX_ITERATIONS` |
 
+### Config files
+
+`mog config` manages git identity settings stored in `~/.mog/`:
+
+```
+~/.mog/
+  config.json                          ← global config
+  repos/
+    owner/repo/config.json             ← per-repo config
+```
+
+| Config Key | Description |
+|---|---|
+| `user.name` | Git author name for commits inside the sandbox |
+| `user.email` | Git author email for commits inside the sandbox |
+
+See [Git identity](#git-identity) for details on how these are resolved.
+
 ## Worktree management
 
 `mog` uses bare clones and git worktrees so you can run multiple issues concurrently without conflicts:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbyg603/mog",
-  "version": "1.5.2",
+  "version": "1.6.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/config.test.ts

@@ -0,0 +1,147 @@
+import { describe, test, expect, beforeEach, afterAll } from "bun:test";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { loadConfig, saveConfig, loadRepoConfig, saveRepoConfig, getGitIdentity } from "./config";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mog-config-test-"));
+const originalHome = process.env.HOME;
+
+beforeEach(() => {
+  process.env.HOME = tmpDir;
+  const mogDir = path.join(tmpDir, ".mog");
+  if (fs.existsSync(mogDir)) {
+    fs.rmSync(mogDir, { recursive: true });
+  }
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("loadConfig", () => {
+  test("returns empty object when no config file exists", () => {
+    expect(loadConfig()).toEqual({});
+  });
+
+  test("returns parsed config from file", () => {
+    const mogDir = path.join(tmpDir, ".mog");
+    fs.mkdirSync(mogDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(mogDir, "config.json"),
+      JSON.stringify({ "user.name": "Alice", "user.email": "alice@example.com" })
+    );
+
+    expect(loadConfig()).toEqual({
+      "user.name": "Alice",
+      "user.email": "alice@example.com",
+    });
+  });
+
+  test("returns empty object for invalid JSON", () => {
+    const mogDir = path.join(tmpDir, ".mog");
+    fs.mkdirSync(mogDir, { recursive: true });
+    fs.writeFileSync(path.join(mogDir, "config.json"), "not json");
+
+    expect(loadConfig()).toEqual({});
+  });
+});
+
+describe("saveConfig", () => {
+  test("creates .mog directory and writes config", () => {
+    saveConfig({ "user.name": "Bob", "user.email": "bob@example.com" });
+
+    const configPath = path.join(tmpDir, ".mog", "config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+
+    const content = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(content).toEqual({ "user.name": "Bob", "user.email": "bob@example.com" });
+  });
+
+  test("overwrites existing config", () => {
+    saveConfig({ "user.name": "First" });
+    saveConfig({ "user.name": "Second", "user.email": "second@example.com" });
+
+    const configPath = path.join(tmpDir, ".mog", "config.json");
+    const content = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(content).toEqual({ "user.name": "Second", "user.email": "second@example.com" });
+  });
+
+  test("saves empty config", () => {
+    saveConfig({});
+
+    const configPath = path.join(tmpDir, ".mog", "config.json");
+    const content = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(content).toEqual({});
+  });
+});
+
+describe("loadRepoConfig", () => {
+  test("returns empty object when no repo config file exists", () => {
+    expect(loadRepoConfig("owner/repo")).toEqual({});
+  });
+
+  test("returns parsed repo config from file", () => {
+    saveRepoConfig("owner/repo", { "user.name": "Alice", "user.email": "alice@work.com" });
+    expect(loadRepoConfig("owner/repo")).toEqual({
+      "user.name": "Alice",
+      "user.email": "alice@work.com",
+    });
+  });
+
+  test("keeps repo configs separate", () => {
+    saveRepoConfig("owner/repo-a", { "user.name": "Alice", "user.email": "alice@work.com" });
+    saveRepoConfig("owner/repo-b", { "user.name": "Bob", "user.email": "bob@personal.com" });
+
+    expect(loadRepoConfig("owner/repo-a")).toEqual({ "user.name": "Alice", "user.email": "alice@work.com" });
+    expect(loadRepoConfig("owner/repo-b")).toEqual({ "user.name": "Bob", "user.email": "bob@personal.com" });
+  });
+});
+
+describe("getGitIdentity", () => {
+  test("falls back to global config when no repo specified", () => {
+    saveConfig({ "user.name": "Global", "user.email": "global@example.com" });
+    // Note: this test also picks up host git config (tier 2), which runs before global.
+    // Since we can't easily mock host git, we just verify it returns something non-null.
+    const identity = getGitIdentity();
+    expect(identity).not.toBeNull();
+  });
+
+  test("per-repo config takes priority over global config", () => {
+    saveConfig({ "user.name": "Global", "user.email": "global@example.com" });
+    saveRepoConfig("owner/repo", { "user.name": "RepoUser", "user.email": "repo@work.com" });
+
+    expect(getGitIdentity("owner/repo")).toEqual({
+      name: "RepoUser",
+      email: "repo@work.com",
+    });
+  });
+
+  test("falls back through chain when per-repo config is incomplete", () => {
+    saveRepoConfig("owner/repo", { "user.name": "RepoUser" }); // missing email
+    saveConfig({ "user.name": "Global", "user.email": "global@example.com" });
+
+    // Should skip per-repo (incomplete), pick up host git or global
+    const identity = getGitIdentity("owner/repo");
+    expect(identity).not.toBeNull();
+    // Should NOT be the incomplete repo config
+    expect(identity!.email).not.toBe("");
+  });
+
+  test("returns null when no config exists anywhere and host git is empty", () => {
+    // With a fake HOME, host git config may still return the real system config.
+    // This test just verifies it doesn't crash with no mog configs at all.
+    const identity = getGitIdentity("nonexistent/repo");
+    // Can't assert null since host git may be configured, but it shouldn't throw
+    expect(identity === null || (identity.name && identity.email)).toBeTruthy();
+  });
+
+  test("returns null for global config with empty strings", () => {
+    saveConfig({ "user.name": "", "user.email": "" });
+    // With empty mog config and potentially no host git, may return null
+    const identity = getGitIdentity();
+    // If host git is configured it'll return that, otherwise null — both are valid
+    expect(identity === null || (identity.name && identity.email)).toBeTruthy();
+  });
+});

package/src/config.ts

@@ -0,0 +1,92 @@
+import fs from "fs";
+import path from "path";
+
+export interface MogConfig {
+  "user.name"?: string;
+  "user.email"?: string;
+}
+
+export interface GitIdentity {
+  name: string;
+  email: string;
+}
+
+function getConfigPath(): string {
+  return path.join(process.env.HOME || "~", ".mog", "config.json");
+}
+
+function getRepoConfigPath(repo: string): string {
+  return path.join(process.env.HOME || "~", ".mog", "repos", repo, "config.json");
+}
+
+export function loadConfig(): MogConfig {
+  const configPath = getConfigPath();
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw) as MogConfig;
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config: MogConfig): void {
+  const configPath = getConfigPath();
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function loadRepoConfig(repo: string): MogConfig {
+  const configPath = getRepoConfigPath(repo);
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw) as MogConfig;
+  } catch {
+    return {};
+  }
+}
+
+export function saveRepoConfig(repo: string, config: MogConfig): void {
+  const configPath = getRepoConfigPath(repo);
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function detectHostGitIdentity(): GitIdentity | null {
+  const nameResult = Bun.spawnSync(["git", "config", "user.name"]);
+  const emailResult = Bun.spawnSync(["git", "config", "user.email"]);
+
+  const name = nameResult.exitCode === 0 ? nameResult.stdout.toString().trim() : "";
+  const email = emailResult.exitCode === 0 ? emailResult.stdout.toString().trim() : "";
+
+  if (name && email) {
+    return { name, email };
+  }
+
+  return null;
+}
+
+function identityFromConfig(config: MogConfig): GitIdentity | null {
+  const name = config["user.name"];
+  const email = config["user.email"];
+  if (name && email) {
+    return { name, email };
+  }
+  return null;
+}
+
+export function getGitIdentity(repo?: string): GitIdentity | null {
+  // 1. Per-repo mog config (explicit override)
+  if (repo) {
+    const repoIdentity = identityFromConfig(loadRepoConfig(repo));
+    if (repoIdentity) return repoIdentity;
+  }
+
+  // 2. Host git config (auto-detected from cwd)
+  const hostIdentity = detectHostGitIdentity();
+  if (hostIdentity) return hostIdentity;
+
+  // 3. Global mog config (fallback)
+  return identityFromConfig(loadConfig());
+}

package/src/github.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect } from "bun:test";
+import { cleanIssueTitle, getConventionalPrefix } from "./github";
+import type { Issue } from "./github";
+
+function makeIssue(labels: string): Issue {
+  return { title: "", body: "", labels, comments: "" };
+}
+
+describe("cleanIssueTitle", () => {
+  test("strips conventional commit prefix", () => {
+    expect(cleanIssueTitle("fix: BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("feat: Add new feature")).toBe("Add new feature");
+    expect(cleanIssueTitle("chore: Update deps")).toBe("Update deps");
+    expect(cleanIssueTitle("refactor: Clean up code")).toBe("Clean up code");
+  });
+
+  test("strips trailing issue references", () => {
+    expect(cleanIssueTitle("BlueSky Integration [#154]")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("Some feature [#42]")).toBe("Some feature");
+  });
+
+  test("strips both prefix and issue reference", () => {
+    expect(cleanIssueTitle("fix: BlueSky Integration [#154]")).toBe("BlueSky Integration");
+  });
+
+  test("strips multiple issue references", () => {
+    expect(cleanIssueTitle("fix: Something [#1] [#2]")).toBe("Something");
+    expect(cleanIssueTitle("BlueSky [#154] Integration [#184]")).toBe("BlueSky Integration");
+  });
+
+  test("leaves clean titles unchanged", () => {
+    expect(cleanIssueTitle("BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("Add support for webhooks")).toBe("Add support for webhooks");
+  });
+
+  test("is case-insensitive for prefix", () => {
+    expect(cleanIssueTitle("Fix: BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("FIX: BlueSky Integration")).toBe("BlueSky Integration");
+  });
+});
+
+describe("getConventionalPrefix", () => {
+  test("returns feat for enhancement label", () => {
+    expect(getConventionalPrefix(makeIssue("enhancement"))).toBe("feat");
+  });
+
+  test("returns feat for feature label", () => {
+    expect(getConventionalPrefix(makeIssue("feature"))).toBe("feat");
+  });
+
+  test("returns fix for bug label", () => {
+    expect(getConventionalPrefix(makeIssue("bug"))).toBe("fix");
+  });
+
+  test("returns fix for no labels", () => {
+    expect(getConventionalPrefix(makeIssue("none"))).toBe("fix");
+  });
+
+  test("does not false-positive on substring matches", () => {
+    expect(getConventionalPrefix(makeIssue("no-enhancement"))).toBe("fix");
+    expect(getConventionalPrefix(makeIssue("feature-request"))).toBe("fix");
+  });
+
+  test("handles multiple labels", () => {
+    expect(getConventionalPrefix(makeIssue("bug, enhancement"))).toBe("feat");
+    expect(getConventionalPrefix(makeIssue("priority, bug"))).toBe("fix");
+  });
+});

package/src/github.ts

@@ -1,3 +1,4 @@
+import { getGitIdentity } from "./config";
 import { log } from "./log";
 
 export interface Issue {
@@ -127,6 +128,37 @@ export function fetchPRFeedback(repo: string, branchName: string): PRFeedback |
   return { prNumber, prUrl, reviews };
 }
 
+export function closePR(repo: string, prNumber: number): void {
+  const result = Bun.spawnSync([
+    "gh", "pr", "close", String(prNumber),
+    "--repo", repo,
+    "--delete-branch",
+  ]);
+  if (result.exitCode !== 0) {
+    log.warn(`Failed to close PR #${prNumber}.`);
+  }
+}
+
+export function cleanIssueTitle(title: string): string {
+  return title
+    .replace(/^(feat|fix|chore|docs|refactor|test|ci|build|perf|style):\s*/i, "")
+    .replace(/\s*\[#\d+\]/g, "")
+    .trim();
+}
+
+export function getConventionalPrefix(issue: Issue): string {
+  const labels = issue.labels.split(", ").map(l => l.trim());
+  return labels.includes("enhancement") || labels.includes("feature") ? "feat" : "fix";
+}
+
+function gitWithIdentity(repo: string, ...args: string[]): string[] {
+  const identity = getGitIdentity(repo);
+  if (identity) {
+    return ["git", `-c`, `user.name=${identity.name}`, `-c`, `user.email=${identity.email}`, ...args];
+  }
+  return ["git", ...args];
+}
+
 export function pushAndCreatePR(
   repo: string,
   worktreeDir: string,
@@ -151,6 +183,8 @@ export function pushAndCreatePR(
     return;
   }
 
+  const prefix = getConventionalPrefix(issue);
+
   // Stage any unstaged changes Claude might have left
   if (hasUncommitted) {
     log.info("Staging uncommitted changes...");
@@ -158,32 +192,33 @@ export function pushAndCreatePR(
     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 });
+    const commitResult = Bun.spawnSync(gitWithIdentity(repo, "commit", "-m", `${prefix}: address issue #${issueNum} - ${cleanIssueTitle(issue.title)}`), { cwd: worktreeDir });
     if (commitResult.exitCode !== 0) {
       log.warn("Commit failed — changes may already be committed.");
     }
   }
 
-  // Squash all commits into one
-  const commitCount = Bun.spawnSync(["git", "rev-list", "--count", `${defaultBranch}..HEAD`], { cwd: worktreeDir });
+  // Squash all commits into one (use origin ref — local branch may be stale)
+  const mergeBase = `origin/${defaultBranch}`;
+  const commitCount = Bun.spawnSync(["git", "rev-list", "--count", `${mergeBase}..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 });
+    const squash = Bun.spawnSync(["git", "reset", "--soft", mergeBase], { cwd: worktreeDir });
     if (squash.exitCode === 0) {
-      const msg = `${prefix}: ${issue.title.toLowerCase()} (#${issueNum})`;
-      Bun.spawnSync(["git", "commit", "-m", msg], { cwd: worktreeDir });
+      const msg = `${prefix}: ${cleanIssueTitle(issue.title).toLowerCase()} (#${issueNum})`;
+      Bun.spawnSync(gitWithIdentity(repo, "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)
+  // Push — force-with-lease if the remote branch already exists
   log.info(`Pushing branch '${branchName}' to origin...`);
-  const pushArgs = existingPR
+  const remoteRef = Bun.spawnSync(["git", "ls-remote", "--heads", "origin", branchName], { cwd: worktreeDir });
+  const remoteBranchExists = remoteRef.stdout.toString().trim().length > 0;
+  const pushArgs = remoteBranchExists
     ? ["git", "push", "--force-with-lease", "-u", "origin", branchName]
     : ["git", "push", "-u", "origin", branchName];
   const push = Bun.spawnSync(pushArgs, { cwd: worktreeDir });
@@ -192,8 +227,22 @@ export function pushAndCreatePR(
   }
   log.ok("Branch pushed.");
 
+  const prTitle = `${prefix}: ${cleanIssueTitle(issue.title)} [#${issueNum}]`;
+  const prBody = buildPRBody(issueNum, summary);
+
   if (existingPR) {
-    // Update existing PR
+    // Update existing PR title and description
+    const edit = Bun.spawnSync([
+      "gh", "pr", "edit", String(existingPR.prNumber),
+      "--repo", repo,
+      "--title", prTitle,
+      "--body", prBody,
+    ], { cwd: worktreeDir });
+
+    if (edit.exitCode !== 0) {
+      log.warn("Failed to update PR title/description.");
+    }
+
     log.ok("Existing PR updated!");
     console.log(`\x1b[0;32m${existingPR.prUrl}\x1b[0m`);
     console.log();
@@ -206,26 +255,6 @@ export function pushAndCreatePR(
   // Create PR
   log.info("Opening pull request...");
 
-  const summarySection = summary
-    ? `### What was done\n\n${summary}\n\n`
-    : "";
-
-  const prBody = `## Summary
-
-Closes #${issueNum}
-
-${summarySection}This PR was generated by [mog](https://github.com/bobbyg603/mog) using Claude Code in a Docker sandbox.
-
-### Issue: ${issue.title}
-
-${issue.body}
-
----
-*Please review the changes carefully before merging.*`;
-
-  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",
     "--repo", repo,
@@ -248,3 +277,19 @@ ${issue.body}
   log.info(`Worktree: ${worktreeDir}`);
   log.info(`To clean up the worktree later: git worktree remove ${worktreeDir}`);
 }
+
+function buildPRBody(issueNum: string, summary?: string): string {
+  const summarySection = summary
+    ? `### What was done\n\n${summary}\n\n`
+    : "";
+
+  return `## Summary
+
+Closes #${issueNum}
+
+${summarySection}---
+
+This PR was generated by [mog](https://github.com/bobbyg603/mog) using Claude Code in a Docker sandbox.
+
+*Please review the changes carefully before merging.*`;
+}

package/src/index.ts

@@ -2,10 +2,11 @@
 
 import fs from "fs";
 import path from "path";
-import { fetchIssue, listIssues, fetchPRFeedback } from "./github";
+import { fetchIssue, listIssues, fetchPRFeedback, closePR, cleanIssueTitle, pushAndCreatePR } from "./github";
 import { detectRepo, ensureRepo, createWorktree } from "./worktree";
-import { runClaude } from "./sandbox";
-import { pushAndCreatePR } from "./github";
+import { runClaude, applySandboxGitConfig } from "./sandbox";
+import { loadConfig, saveConfig, loadRepoConfig, saveRepoConfig } from "./config";
+import type { MogConfig } from "./config";
 import type { PRFeedback } from "./github";
 import { log } from "./log";
 
@@ -60,9 +61,38 @@ async function init() {
   log.ok("mog is ready. Run: mog <issue_number> (from a git repo) or mog <owner/repo> <issue_number>");
 }
 
+function printUsage(): void {
+  console.log("Usage:");
+  console.log("  mog init                      — one-time setup (create sandbox & login)");
+  console.log("  mog <issue_num>               — auto-detect repo from git remote");
+  console.log("  mog <owner/repo> <issue_num>  — fetch issue, run Claude, open PR");
+  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("  --version, -v                 — print the current version");
+  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");
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
+  // Handle --version / -v before anything else (no dependencies required)
+  if (args.includes("--version") || args.includes("-v")) {
+    const pkg = await Bun.file(path.join(import.meta.dir, "..", "package.json")).json();
+    console.log(pkg.version);
+    return;
+  }
+
   // Validate dependencies
   for (const cmd of ["gh", "git", "docker"]) {
     const which = Bun.spawnSync(["which", cmd]);
@@ -87,6 +117,65 @@ async function main() {
     return;
   }
 
+  // mog config [--global] [key] [value]
+  if (args[0] === "config") {
+    const configArgs = args.slice(1);
+    const isGlobal = configArgs.includes("--global");
+    const filtered = configArgs.filter(a => a !== "--global");
+    const key = filtered[0];
+    const value = filtered[1];
+    const validKeys: (keyof MogConfig)[] = ["user.name", "user.email"];
+
+    // Determine which config to use: --global or per-repo (auto-detected)
+    let repo: string | null = null;
+    if (!isGlobal) {
+      repo = detectRepo();
+    }
+
+    const load = () => repo ? loadRepoConfig(repo) : loadConfig();
+    const save = (c: MogConfig) => repo ? saveRepoConfig(repo, c) : saveConfig(c);
+    const scope = repo ? `repo (${repo})` : "global";
+
+    if (!key) {
+      // Show all config values
+      const config = load();
+      if (Object.keys(config).length === 0) {
+        log.info(`No ${scope} config values set.`);
+      } else {
+        log.info(`${scope} config:`);
+        for (const [k, v] of Object.entries(config)) {
+          console.log(`${k}=${v}`);
+        }
+      }
+      return;
+    }
+
+    if (!validKeys.includes(key as keyof MogConfig)) {
+      log.die(`Unknown config key: '${key}'. Valid keys: ${validKeys.join(", ")}`);
+    }
+
+    const configKey = key as keyof MogConfig;
+
+    if (value === undefined) {
+      // Read a single value
+      const config = load();
+      const val = config[configKey];
+      if (val !== undefined) {
+        console.log(val);
+      } else {
+        log.die(`Config key '${key}' is not set (${scope}).`);
+      }
+      return;
+    }
+
+    // Set a value
+    const config = load();
+    config[configKey] = value;
+    save(config);
+    log.ok(`${key}=${value} (${scope})`);
+    return;
+  }
+
   // mog list [--verbose]  or  mog <owner/repo> list [--verbose]
   if (args[0] === "list" || args[1] === "list") {
     let repo: string;
@@ -107,24 +196,7 @@ async function main() {
   }
 
   if (args.length < 1) {
-    console.log("Usage:");
-    console.log("  mog init                      — one-time setup (create sandbox & login)");
-    console.log("  mog <issue_num>               — auto-detect repo from git remote");
-    console.log("  mog <owner/repo> <issue_num>  — fetch issue, run Claude, open PR");
-    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");
+    printUsage();
     return;
   }
 
@@ -166,24 +238,7 @@ async function main() {
       log.die(`Invalid issue number: '${issueNum}'. Must be a positive integer.`);
     }
   } else {
-    console.log("Usage:");
-    console.log("  mog init                      — one-time setup (create sandbox & login)");
-    console.log("  mog <issue_num>               — auto-detect repo from git remote");
-    console.log("  mog <owner/repo> <issue_num>  — fetch issue, run Claude, open PR");
-    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");
+    printUsage();
     return;
   }
 
@@ -217,19 +272,21 @@ async function main() {
   log.info(`Default branch: ${defaultBranch}`);
 
   const { worktreeDir, branchName, reused } = createWorktree(
-    reposDir, owner, repoName, defaultBranch, issueNum, issue.title
+    reposDir, owner, repoName, defaultBranch, issueNum, cleanIssueTitle(issue.title), fresh
   );
 
-  // Check for existing PR (unless --fresh)
+  // Check for existing PR
   let existingPR: PRFeedback | undefined;
-  let isRetry = reused;
-  if (!fresh) {
-    const pr = fetchPRFeedback(repo, branchName);
-    if (pr) {
-      existingPR = pr;
-      isRetry = true;
-      log.ok(`Found existing PR #${pr.prNumber} — will include review feedback and update it.`);
-    }
+  let isRetry = fresh ? false : reused;
+  const pr = fetchPRFeedback(repo, branchName);
+  if (pr && fresh) {
+    log.info(`--fresh: closing existing PR #${pr.prNumber} and deleting remote branch...`);
+    closePR(repo, pr.prNumber);
+    log.ok(`PR #${pr.prNumber} closed. A new PR will be created.`);
+  } else if (pr) {
+    existingPR = pr;
+    isRetry = true;
+    log.ok(`Found existing PR #${pr.prNumber} — will include review feedback and update it.`);
   }
 
   // Copy included files into worktree
@@ -243,11 +300,15 @@ async function main() {
   }
 
   // Build prompts
-  const prFeedback = existingPR?.reviews || "";
+  const prFeedback = fresh ? "" : (existingPR?.reviews || "");
   const planningPrompt = buildPlanningPrompt(repo, issueNum, issue, prFeedback, isRetry);
   const buildingPromptFn = (remaining: string[], plan: string) =>
     buildBuildingPrompt(repo, issueNum, issue, remaining, plan);
-  const reviewPrompt = buildReviewPrompt(repo, issueNum, issue);
+  const reviewPrompt = buildReviewPrompt(repo, issueNum, issue, defaultBranch);
+  const summaryPrompt = buildSummaryPrompt(repo, issueNum, issue, defaultBranch);
+
+  // Apply git identity inside sandbox before running Claude
+  applySandboxGitConfig(SANDBOX_NAME, repo);
 
   // Run Claude in sandbox
   log.info("Launching Claude Code in sandbox...");
@@ -255,7 +316,7 @@ async function main() {
   log.info(`Worktree: ${worktreeDir}`);
   console.log();
 
-  const summary = await runClaude(SANDBOX_NAME, worktreeDir, planningPrompt, buildingPromptFn, reviewPrompt);
+  const summary = await runClaude(SANDBOX_NAME, worktreeDir, defaultBranch, planningPrompt, buildingPromptFn, reviewPrompt, summaryPrompt);
 
   // Remove included files so they don't end up in the PR
   for (const filePath of copiedFiles) {
@@ -272,6 +333,35 @@ async function main() {
   pushAndCreatePR(repo, worktreeDir, branchName, defaultBranch, issueNum, issue, summary, existingPR);
 }
 
+function printUsage(): void {
+  console.log("Usage:");
+  console.log("  mog init                      — one-time setup (create sandbox & login)");
+  console.log("  mog config [key] [value]      — get/set per-repo config (auto-detected)");
+  console.log("  mog config --global [key] [value] — get/set global config");
+  console.log("  mog <issue_num>               — auto-detect repo from git remote");
+  console.log("  mog <owner/repo> <issue_num>  — fetch issue, run Claude, open PR");
+  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("Config keys: user.name, user.email");
+  console.log("  Git identity is auto-detected from your repo's git config.");
+  console.log("  Use 'mog config' to override per-repo, or --global for all repos.");
+  console.log();
+  console.log("Example:");
+  console.log("  mog init");
+  console.log("  mog config user.name \"Your Name\"");
+  console.log("  mog config --global user.email \"you@example.com\"");
+  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");
+}
+
 function getReposDir(): string {
   return process.env.MOG_REPOS_DIR || `${process.env.HOME}/mog-repos`;
 }
@@ -439,10 +529,46 @@ Rules:
 5. Do NOT work on any other tasks after committing.`;
 }
 
+function buildSummaryPrompt(
+  repo: string,
+  issueNum: string,
+  issue: { title: string; body: string; labels: string; comments: string },
+  defaultBranch: string,
+): string {
+  return `You are summarizing the changes made for GitHub issue #${issueNum} in the repository ${repo}.
+
+## Issue: ${issue.title}
+
+### Description
+${issue.body}
+
+## Instructions
+
+Run \`git diff ${defaultBranch}...HEAD\` to see all changes made on this branch.
+
+Write a concise summary of **all changes** made to resolve the issue and save it to a file called \`SUMMARY.md\` in the root of the repository. Do NOT commit this file.
+
+CRITICAL FORMATTING RULES — the file contents will be inserted directly into a PR body as-is:
+1. Do NOT make any code changes or commits.
+2. The file must start IMMEDIATELY with the first bullet point. No intro text like "Here's what was done" or "Let me summarize". No lead-in sentences whatsoever.
+3. Use a flat list of markdown bullet points (\`- \`). No headings, no sub-sections, no numbered lists.
+4. Each bullet should describe a concrete change: what was added, modified, or fixed and where.
+5. Keep it short — aim for 3-8 bullets. A reviewer should be able to scan it in 10 seconds.
+6. Do NOT list things that were reviewed but not changed. Only describe what actually changed.
+7. Do NOT repeat the issue title or description — the PR already includes those.
+8. End with the last bullet point. No closing remarks, no sign-off, no "Let me know" or "Done." after the bullets.
+
+Example of correct SUMMARY.md contents:
+- Added \`FooService\` class in \`src/services/foo.ts\` with retry logic and error handling
+- Updated \`src/routes/api.ts\` to wire up the new \`/foo\` endpoint
+- Added unit tests for \`FooService\` in \`src/services/__tests__/foo.test.ts\``;
+}
+
 function buildReviewPrompt(
   repo: string,
   issueNum: string,
   issue: { title: string; body: string; labels: string; comments: string },
+  defaultBranch: string,
 ): string {
   return `You are reviewing changes made for GitHub issue #${issueNum} in the repository ${repo}.
 
@@ -452,7 +578,7 @@ ${formatIssueContext(issueNum, issue)}
 
 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.
+Run \`git diff ${defaultBranch}...HEAD\` 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.

package/src/sandbox.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect } from "bun:test";
+import { readPlanFile, getUncheckedItems, isPlanComplete } from "./sandbox";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("getUncheckedItems", () => {
+  test("returns unchecked items from plan content", () => {
+    const plan = `# Plan
+- [ ] First task
+- [x] Second task (done)
+- [ ] Third task`;
+    expect(getUncheckedItems(plan)).toEqual([
+      "- [ ] First task",
+      "- [ ] Third task",
+    ]);
+  });
+
+  test("returns empty array when all items are checked", () => {
+    const plan = `# Plan
+- [x] First task
+- [x] Second task`;
+    expect(getUncheckedItems(plan)).toEqual([]);
+  });
+
+  test("returns empty array for content with no checklist items", () => {
+    expect(getUncheckedItems("Just some text")).toEqual([]);
+  });
+
+  test("returns empty array for empty string", () => {
+    expect(getUncheckedItems("")).toEqual([]);
+  });
+});
+
+describe("isPlanComplete", () => {
+  test("returns true when all items are checked", () => {
+    const plan = `# Plan
+- [x] First task
+- [x] Second task`;
+    expect(isPlanComplete(plan)).toBe(true);
+  });
+
+  test("returns false when unchecked items remain", () => {
+    const plan = `# Plan
+- [x] First task
+- [ ] Second task`;
+    expect(isPlanComplete(plan)).toBe(false);
+  });
+
+  test("returns false when there are no checklist items at all", () => {
+    expect(isPlanComplete("Just some text")).toBe(false);
+  });
+
+  test("returns false for empty string", () => {
+    expect(isPlanComplete("")).toBe(false);
+  });
+});
+
+describe("readPlanFile", () => {
+  test("returns file content when plan file exists", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mog-test-"));
+    const planContent = "# Plan\n- [ ] Task one\n";
+    fs.writeFileSync(path.join(tmpDir, "IMPLEMENTATION_PLAN.md"), planContent);
+
+    expect(readPlanFile(tmpDir)).toBe(planContent);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  test("returns null when plan file does not exist", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mog-test-"));
+
+    expect(readPlanFile(tmpDir)).toBeNull();
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});

package/src/sandbox.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import { log } from "./log";
+import { getGitIdentity } from "./config";
 
 interface StreamEvent {
   type: string;
@@ -22,6 +23,26 @@ const MAX_ITERATIONS = parseInt(
 );
 const MAX_STALLS = 2;
 const PLAN_FILENAME = "IMPLEMENTATION_PLAN.md";
+const SUMMARY_FILENAME = "SUMMARY.md";
+
+export function applySandboxGitConfig(sandboxName: string, repo?: string): void {
+  const identity = getGitIdentity(repo);
+  if (!identity) return;
+
+  Bun.spawnSync([
+    "docker", "sandbox", "exec",
+    sandboxName,
+    "git", "config", "--global", "user.name", identity.name,
+  ]);
+
+  Bun.spawnSync([
+    "docker", "sandbox", "exec",
+    sandboxName,
+    "git", "config", "--global", "user.email", identity.email,
+  ]);
+
+  log.ok(`Sandbox git identity: ${identity.name} <${identity.email}>`);
+}
 
 export function readPlanFile(worktreeDir: string): string | null {
   const planPath = `${worktreeDir}/${PLAN_FILENAME}`;
@@ -43,14 +64,24 @@ export function isPlanComplete(planContent: string): boolean {
   return unchecked.length === 0 && (checked?.length ?? 0) > 0;
 }
 
-function getCommitCount(sandboxName: string, worktreeDir: string): number {
+function getCommitCount(sandboxName: string, worktreeDir: string, defaultBranch: string): number {
   const result = Bun.spawnSync([
     "docker", "sandbox", "exec",
     "-w", worktreeDir,
     sandboxName,
-    "git", "rev-list", "HEAD", "--not", "--remotes", "--count",
+    "git", "rev-list", "--count", `origin/${defaultBranch}..HEAD`,
   ]);
-  if (result.exitCode !== 0) return 0;
+  if (result.exitCode !== 0) {
+    // Fallback: count commits not on any remote (works even if origin ref is missing)
+    const fallback = Bun.spawnSync([
+      "docker", "sandbox", "exec",
+      "-w", worktreeDir,
+      sandboxName,
+      "git", "rev-list", "HEAD", "--not", "--remotes", "--count",
+    ]);
+    if (fallback.exitCode !== 0) return 0;
+    return parseInt(fallback.stdout.toString().trim(), 10) || 0;
+  }
   return parseInt(result.stdout.toString().trim(), 10) || 0;
 }
 
@@ -71,17 +102,54 @@ function cleanupPlanFile(sandboxName: string, worktreeDir: string): void {
   ]);
 }
 
+function readSummaryFile(worktreeDir: string): string | null {
+  const summaryPath = `${worktreeDir}/${SUMMARY_FILENAME}`;
+  try {
+    const content = fs.readFileSync(summaryPath, "utf-8").trim();
+    // Clean up the file so it doesn't end up in commits
+    fs.unlinkSync(summaryPath);
+    return content || null;
+  } catch {
+    return null;
+  }
+}
+
+async function runSummaryPhase(
+  sandboxName: string,
+  worktreeDir: string,
+  defaultBranch: string,
+  summaryPrompt?: string,
+): Promise<string> {
+  if (!summaryPrompt || getCommitCount(sandboxName, worktreeDir, defaultBranch) <= 0) {
+    return "";
+  }
+
+  log.info("Summarizing changes...");
+  await execClaude(sandboxName, worktreeDir, ["-p", summaryPrompt]);
+
+  const summary = readSummaryFile(worktreeDir);
+  if (summary) {
+    log.ok("Summary generated.");
+    return summary;
+  }
+
+  log.warn("Claude did not write SUMMARY.md — PR will not have a summary section.");
+  return "";
+}
+
 export async function runClaude(
   sandboxName: string,
   worktreeDir: string,
+  defaultBranch: string,
   planningPrompt: string,
   buildingPromptFn: (remainingItems: string[], planContent: string) => string,
   reviewPrompt?: string,
+  summaryPrompt?: string,
 ): Promise<string> {
   let lastResult = "";
 
-  // Phase 1 — Planning
-  log.info("Phase 1: Creating implementation plan...");
+  // Planning
+  log.info("Planning implementation...");
   await execClaude(sandboxName, worktreeDir, ["-p", planningPrompt]);
 
   const planContent = readPlanFile(worktreeDir);
@@ -95,7 +163,7 @@ export async function runClaude(
     if (fallbackResult) lastResult = fallbackResult;
 
     for (let i = 0; i < MAX_ITERATIONS; i++) {
-      if (getCommitCount(sandboxName, worktreeDir) > 0) return lastResult;
+      if (getCommitCount(sandboxName, worktreeDir, defaultBranch) > 0) break;
       log.warn(`No commits yet — continuing Claude (attempt ${i + 2}/${MAX_ITERATIONS + 1})...`);
       const contResult = await execClaude(sandboxName, worktreeDir, [
         "--continue", "-p",
@@ -104,15 +172,17 @@ export async function runClaude(
       if (contResult) lastResult = contResult;
     }
 
-    if (getCommitCount(sandboxName, worktreeDir) === 0) {
+    if (getCommitCount(sandboxName, worktreeDir, defaultBranch) === 0) {
       log.warn("Claude did not produce any commits after all attempts.");
     }
-    return lastResult;
+
+    const summary = await runSummaryPhase(sandboxName, worktreeDir, defaultBranch, summaryPrompt);
+    return summary || lastResult;
   }
 
   log.ok(`Implementation plan created with ${unchecked.length} task(s).`);
 
-  // Phase 2 — Building loop
+  // Building loop
   let stallCount = 0;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
@@ -128,7 +198,7 @@ export async function runClaude(
       break;
     }
 
-    const commitsBefore = getCommitCount(sandboxName, worktreeDir);
+    const commitsBefore = getCommitCount(sandboxName, worktreeDir, defaultBranch);
     const uncheckedBefore = remaining.length;
 
     log.info(`Iteration ${i + 1}/${MAX_ITERATIONS}: ${remaining[0]!.replace("- [ ] ", "")}`);
@@ -139,7 +209,7 @@ export async function runClaude(
 
     const planAfter = readPlanFile(worktreeDir);
     const uncheckedAfter = planAfter ? getUncheckedItems(planAfter).length : 0;
-    const commitsAfter = getCommitCount(sandboxName, worktreeDir);
+    const commitsAfter = getCommitCount(sandboxName, worktreeDir, defaultBranch);
 
     if (uncheckedAfter >= uncheckedBefore && commitsAfter <= commitsBefore) {
       stallCount++;
@@ -153,14 +223,14 @@ export async function runClaude(
     }
   }
 
-  // Phase 3 — Review
+  // Review
   if (reviewPrompt) {
-    log.info("Phase 3: Reviewing changes for quality and completeness...");
+    log.info("Reviewing changes for quality and completeness...");
     const reviewResult = await execClaude(sandboxName, worktreeDir, ["-p", reviewPrompt]);
     if (reviewResult) lastResult = reviewResult;
   }
 
-  // Phase 4 — Cleanup
+  // Cleanup
   cleanupPlanFile(sandboxName, worktreeDir);
 
   const finalPlan = readPlanFile(worktreeDir);
@@ -173,7 +243,9 @@ export async function runClaude(
     log.ok("Plan file cleaned up.");
   }
 
-  return lastResult;
+  // Summary
+  const summary = await runSummaryPhase(sandboxName, worktreeDir, defaultBranch, summaryPrompt);
+  return summary || lastResult;
 }
 
 async function execClaude(sandboxName: string, worktreeDir: string, claudeArgs: string[]): Promise<string> {

package/src/version.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect } from "bun:test";
+import path from "path";
+
+const entrypoint = path.join(import.meta.dir, "index.ts");
+const bunPath = Bun.which("bun") ?? process.execPath;
+const packageJson = require("../package.json");
+
+describe("--version flag", () => {
+  test("--version prints the version from package.json", async () => {
+    const proc = Bun.spawn([bunPath, "run", entrypoint, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+    expect(proc.exitCode).toBe(0);
+    expect(stdout.trim()).toBe(packageJson.version);
+  });
+
+  test("-v prints the version from package.json", async () => {
+    const proc = Bun.spawn([bunPath, "run", entrypoint, "-v"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const stdout = await new Response(proc.stdout).text();
+    await proc.exited;
+    expect(proc.exitCode).toBe(0);
+    expect(stdout.trim()).toBe(packageJson.version);
+  });
+});

package/src/worktree.ts

@@ -72,7 +72,8 @@ export function createWorktree(
   repoName: string,
   defaultBranch: string,
   issueNum: string,
-  issueTitle: string
+  issueTitle: string,
+  fresh?: boolean,
 ): { worktreeDir: string; branchName: string; reused: boolean } {
   const safeTitle = issueTitle
     .toLowerCase()
@@ -85,6 +86,12 @@ export function createWorktree(
   const repoDir = `${reposDir}/${owner}/${repoName}`;
   const worktreeDir = `${reposDir}/${owner}/${repoName}-worktrees/${branchName}`;
 
+  if (fs.existsSync(worktreeDir) && fresh) {
+    log.info(`--fresh: removing existing worktree at ${worktreeDir}...`);
+    Bun.spawnSync(["git", "worktree", "remove", "--force", worktreeDir], { cwd: repoDir });
+    Bun.spawnSync(["git", "branch", "-D", branchName], { cwd: repoDir });
+  }
+
   if (fs.existsSync(worktreeDir)) {
     log.warn(`Worktree already exists at ${worktreeDir}, reusing.`);
     return { worktreeDir, branchName, reused: true };