@bobbyg603/mog 1.5.3 → 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.3",
+  "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.ts

@@ -1,3 +1,4 @@
+import { getGitIdentity } from "./config";
 import { log } from "./log";
 
 export interface Issue {
@@ -150,6 +151,14 @@ export function getConventionalPrefix(issue: Issue): string {
   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,
@@ -183,7 +192,7 @@ export function pushAndCreatePR(
     if (addResult.exitCode !== 0) {
       log.die("Failed to stage changes.");
     }
-    const commitResult = Bun.spawnSync(["git", "commit", "-m", `${prefix}: address issue #${issueNum} - ${cleanIssueTitle(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.");
     }
@@ -198,7 +207,7 @@ export function pushAndCreatePR(
     const squash = Bun.spawnSync(["git", "reset", "--soft", mergeBase], { cwd: worktreeDir });
     if (squash.exitCode === 0) {
       const msg = `${prefix}: ${cleanIssueTitle(issue.title).toLowerCase()} (#${issueNum})`;
-      Bun.spawnSync(["git", "commit", "-m", msg], { cwd: worktreeDir });
+      Bun.spawnSync(gitWithIdentity(repo, "commit", "-m", msg), { cwd: worktreeDir });
       log.ok("Commits squashed.");
     } else {
       log.warn("Failed to squash — pushing individual commits instead.");

package/src/index.ts

@@ -4,7 +4,9 @@ import fs from "fs";
 import path from "path";
 import { fetchIssue, listIssues, fetchPRFeedback, closePR, cleanIssueTitle, pushAndCreatePR } from "./github";
 import { detectRepo, ensureRepo, createWorktree } from "./worktree";
-import { runClaude } from "./sandbox";
+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";
 
@@ -59,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]);
@@ -86,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;
@@ -106,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;
   }
 
@@ -165,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;
   }
 
@@ -251,6 +307,9 @@ async function main() {
   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...");
   log.info(`Branch: ${branchName}`);
@@ -274,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`;
 }

package/src/sandbox.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import { log } from "./log";
+import { getGitIdentity } from "./config";
 
 interface StreamEvent {
   type: string;
@@ -24,6 +25,25 @@ 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}`;
   try {

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);
+  });
+});