acdev 1.0.0

package/src/git.js

@@ -0,0 +1,867 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import simpleGit from 'simple-git';
+import { worktreesRoot } from './paths.js';
+
+const execFileAsync = promisify(execFile);
+
+/** @type {(cwd: string) => import('simple-git').SimpleGit} */
+let gitFactory = (cwd) => simpleGit(cwd);
+
+/** @param {(cwd: string) => import('simple-git').SimpleGit} fn */
+export function _setGitFactory(fn) {
+  gitFactory = fn;
+}
+
+export function _resetGitFactory() {
+  gitFactory = (cwd) => simpleGit(cwd);
+}
+
+const SLUG_MAX_LEN = 50;
+
+/**
+ * Lowercase slug from a ticket title: spaces→hyphens, strip non-alnum except
+ * hyphens, collapse repeats, truncate to ~50 chars.
+ * @param {string} title
+ * @param {number} [maxLen]
+ */
+export function slugifyTitle(title, maxLen = SLUG_MAX_LEN) {
+  const slug = String(title || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, maxLen)
+    .replace(/-$/g, '');
+  return slug || 'issue';
+}
+
+const FIX_LABELS = new Set(['bug', 'bugfix', 'defect', 'fix']);
+const FEAT_LABELS = new Set(['feature', 'enhancement', 'feat']);
+
+/**
+ * True when the title clearly refers to a bug (word "bug", [Bug], Bug:, Bug151, etc.).
+ * Whole-word / structured matches only — avoids false positives like "debug".
+ * @param {string} titleLower
+ */
+function titleLooksLikeBug(titleLower) {
+  if (/\[bug\]/.test(titleLower)) return true;
+  if (/^bug\s*:/.test(titleLower)) return true;
+  if (/\bbug\s*:/.test(titleLower)) return true;
+  if (/\bbug\s*\d/.test(titleLower)) return true; // Bug 151 / Bug151
+  if (/\bbug\b/.test(titleLower)) return true;
+  return false;
+}
+
+/**
+ * Classify issue as feat vs fix from labels, then title/body keywords.
+ *
+ * Priority:
+ * 1. Labels (`bug`/`bugfix`/`defect`/`fix` → fix; `feature`/`enhancement`/`feat` → feat)
+ * 2. Title contains "bug" / [Bug] / Bug: / Bug N → fix (wins over feat keywords)
+ * 3. Title/body keywords (bug/fix/regression/… vs feature/enhance/implement/…)
+ * 4. Mixed or unclear → `fix` (safer: bugs must not become `feat/…`)
+ *
+ * @param {{ title?: string, body?: string, labels?: Array<string | { name?: string }> }} issue
+ * @returns {'feat' | 'fix'}
+ */
+export function detectIssueType(issue) {
+  const labels = (issue?.labels ?? []).map((l) =>
+    (typeof l === 'string' ? l : l?.name || '').toLowerCase()
+  );
+
+  if (labels.some((n) => FIX_LABELS.has(n))) return 'fix';
+  if (labels.some((n) => FEAT_LABELS.has(n))) return 'feat';
+
+  const titleLower = String(issue?.title ?? '').toLowerCase();
+  const bodyLower = String(issue?.body ?? '').toLowerCase();
+  const text = `${titleLower}\n${bodyLower}`;
+
+  // Titles with "bug" must never become feat/…, even if feat keywords also appear.
+  if (titleLooksLikeBug(titleLower)) return 'fix';
+
+  const bugHit =
+    /\b(bug|fix|regression|crash|error|broken|hotfix|defect)\b/.test(text);
+  const featHit =
+    /\b(feature|enhancement|enhance|implement)\b/.test(text) ||
+    /\badd\s+support\b/.test(text) ||
+    /\bnew\s+feature\b/.test(text);
+
+  if (bugHit) return 'fix';
+  if (featHit) return 'feat';
+  return 'fix';
+}
+
+/**
+ * @param {'feat' | 'fix'} type
+ * @param {string} title
+ */
+export function buildBranchName(type, title) {
+  return `${type}/${slugifyTitle(title)}`;
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string | number} worktreeId GitHub issue number or Jira key
+ */
+function worktreePaths(repoRoot, worktreeId) {
+  const worktreeRoot = worktreesRoot(repoRoot);
+  const worktreePath = path.join(worktreeRoot, `issue-${worktreeId}`);
+  return { worktreeRoot, worktreePath };
+}
+
+/**
+ * @param {import('simple-git').SimpleGit} git
+ * @param {string} branchName
+ */
+async function branchExistsLocalOrRemote(git, branchName) {
+  try {
+    const local = await git.raw(['branch', '--list', branchName]);
+    if (local.trim()) return true;
+  } catch {
+    // fall through
+  }
+  try {
+    const remote = await git.raw(['branch', '-r', '--list', `origin/${branchName}`]);
+    if (remote.trim()) return true;
+  } catch {
+    // fall through
+  }
+  return false;
+}
+
+/**
+ * Paths under acdev's own state dirs must not fail the clean check —
+ * the tool creates `.acdev/` inside the target repo (config, state, .env).
+ * Also recognizes legacy `.codepilot/` and `.agent-mcp/` paths.
+ * @param {string} filePath
+ */
+export function isAcdevStatePath(filePath) {
+  const normalized = String(filePath || '').replace(/\\/g, '/');
+  return (
+    normalized === '.acdev' ||
+    normalized.startsWith('.acdev/') ||
+    normalized === '.acdev-worktrees' ||
+    normalized.startsWith('.acdev-worktrees/') ||
+    normalized === '.codepilot' ||
+    normalized.startsWith('.codepilot/') ||
+    normalized === '.codepilot-worktrees' ||
+    normalized.startsWith('.codepilot-worktrees/') ||
+    normalized === '.agent-mcp' ||
+    normalized.startsWith('.agent-mcp/') ||
+    normalized === '.agent-mcp-worktrees' ||
+    normalized.startsWith('.agent-mcp-worktrees/')
+  );
+}
+
+/**
+ * Collect dirty paths from a simple-git StatusResult, excluding acdev state.
+ * @param {import('simple-git').StatusResult} status
+ * @returns {string[]}
+ */
+export function relevantDirtyPaths(status) {
+  /** @type {string[]} */
+  const paths = [];
+
+  if (Array.isArray(status.files) && status.files.length > 0) {
+    for (const file of status.files) {
+      if (file?.path) paths.push(file.path);
+    }
+  } else {
+    for (const key of ['not_added', 'conflicted', 'created', 'deleted', 'modified', 'staged']) {
+      const list = status[key];
+      if (Array.isArray(list)) paths.push(...list);
+    }
+    for (const renamed of status.renamed ?? []) {
+      if (renamed?.from) paths.push(renamed.from);
+      if (renamed?.to) paths.push(renamed.to);
+    }
+  }
+
+  return [...new Set(paths)].filter((p) => !isAcdevStatePath(p));
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string} baseBranch
+ */
+export async function syncBaseBranch(repoRoot, baseBranch) {
+  const git = gitFactory(repoRoot);
+  const status = await git.status();
+  const dirtyPaths = relevantDirtyPaths(status);
+  if (dirtyPaths.length > 0) {
+    throw new Error(
+      `Working copy at ${repoRoot} is not clean. Commit or stash changes before running acdev.\n` +
+        `Dirty paths:\n${dirtyPaths.map((p) => `  ${p}`).join('\n')}`
+    );
+  }
+
+  await git.fetch('origin');
+
+  try {
+    await git.checkout(baseBranch);
+  } catch {
+    await git.checkout(['-b', baseBranch, `origin/${baseBranch}`]);
+  }
+
+  await git.pull('origin', baseBranch);
+  const log = await git.log({ maxCount: 1 });
+  const headSha = log.latest?.hash ?? (await git.revparse(['HEAD']));
+  return { branch: baseBranch, headSha };
+}
+
+/**
+ * Create an isolated worktree. Worktree path stays `issue-<id>` for uniqueness
+ * (GitHub issue number or Jira key); branch name is `feat/<slug>` or `fix/<slug>`
+ * (append `-<id>` if taken).
+ *
+ * @param {string} repoRoot
+ * @param {string | number} worktreeId
+ * @param {string} baseBranch
+ * @param {string} desiredBranchName e.g. feat/add-login
+ */
+export async function createWorktree(repoRoot, worktreeId, baseBranch, desiredBranchName) {
+  if (!desiredBranchName) {
+    throw new Error('desiredBranchName is required (feat/<slug> or fix/<slug>)');
+  }
+  if (worktreeId == null || worktreeId === '') {
+    throw new Error('worktreeId is required');
+  }
+
+  const { worktreeRoot, worktreePath } = worktreePaths(repoRoot, worktreeId);
+  const git = gitFactory(repoRoot);
+
+  fs.mkdirSync(worktreeRoot, { recursive: true });
+
+  // Clean previous worktree for this issue; also drop candidate branch names.
+  const uniquified = `${desiredBranchName}-${worktreeId}`;
+  await removeWorktree(repoRoot, worktreeId, [desiredBranchName, uniquified]);
+
+  let branchName = desiredBranchName;
+  if (await branchExistsLocalOrRemote(git, branchName)) {
+    branchName = uniquified;
+  }
+
+  const addWorktree = async () => {
+    await git.raw([
+      'worktree',
+      'add',
+      worktreePath,
+      '-b',
+      branchName,
+      `origin/${baseBranch}`,
+    ]);
+  };
+
+  try {
+    await addWorktree();
+  } catch (err) {
+    if (fs.existsSync(worktreePath)) {
+      fs.rmSync(worktreePath, { recursive: true, force: true });
+      await addWorktree();
+    } else {
+      throw err;
+    }
+  }
+
+  return { branchName, worktreePath };
+}
+
+/**
+ * True when a cleanup git error means the target is already gone (safe no-op).
+ * @param {unknown} err
+ * @param {'worktree' | 'branch'} kind
+ */
+export function isAbsentCleanupError(err, kind) {
+  const msg = String(
+    err && typeof err === 'object' && 'message' in err ? err.message : err
+  ).toLowerCase();
+  if (kind === 'branch') {
+    return /\bnot found\b|\bdoesn't exist\b|\bdoes not exist\b/.test(msg);
+  }
+  // worktree remove: path already gone / never registered
+  return (
+    /\bnot a working tree\b/.test(msg) ||
+    /\bnot found\b/.test(msg) ||
+    /\bdoesn't exist\b/.test(msg) ||
+    /\bdoes not exist\b/.test(msg) ||
+    /\bno such file\b/.test(msg)
+  );
+}
+
+/**
+ * @param {string} repoRoot
+ * @param {string | number} worktreeId
+ * @param {string | string[] | undefined} branchName
+ */
+export async function removeWorktree(repoRoot, worktreeId, branchName) {
+  const { worktreePath } = worktreePaths(repoRoot, worktreeId);
+  const git = gitFactory(repoRoot);
+
+  try {
+    await git.raw(['worktree', 'remove', '--force', worktreePath]);
+  } catch (err) {
+    if (!isAbsentCleanupError(err, 'worktree')) {
+      console.warn(`[acdev] worktree remove failed for issue-${worktreeId}:`, err.message);
+    }
+  }
+
+  const names = Array.isArray(branchName)
+    ? branchName
+    : branchName
+      ? [branchName]
+      : [];
+
+  for (const name of [...new Set(names.filter(Boolean))]) {
+    try {
+      await git.branch(['-D', name]);
+    } catch (err) {
+      if (!isAbsentCleanupError(err, 'branch')) {
+        console.warn(`[acdev] branch delete failed for ${name}:`, err.message);
+      }
+    }
+  }
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ */
+export async function getDiff(worktreePath, baseBranch) {
+  const git = gitFactory(worktreePath);
+  return git.diff([`origin/${baseBranch}...HEAD`]);
+}
+
+/**
+ * Parse `git diff --name-only` stdout into unique relative paths.
+ * @param {string} stdout
+ * @returns {string[]}
+ */
+export function parseNameOnlyOutput(stdout) {
+  const seen = new Set();
+  /** @type {string[]} */
+  const paths = [];
+  for (const line of String(stdout || '').split('\n')) {
+    const p = line.trim();
+    if (!p || seen.has(p)) continue;
+    seen.add(p);
+    paths.push(p);
+  }
+  return paths;
+}
+
+/**
+ * Extract changed file paths from a unified diff (`diff --git a/… b/…`).
+ * Prefers the `b/` (new) path; falls back to `a/` when the file was deleted.
+ * @param {string} diff
+ * @returns {string[]}
+ */
+export function parseChangedFilesFromDiff(diff) {
+  const seen = new Set();
+  /** @type {string[]} */
+  const paths = [];
+  for (const line of String(diff || '').split('\n')) {
+    if (!line.startsWith('diff --git ')) continue;
+    const m = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (!m) continue;
+    const aPath = m[1];
+    const bPath = m[2];
+    const chosen =
+      bPath && bPath !== '/dev/null' ? bPath : aPath && aPath !== '/dev/null' ? aPath : null;
+    if (!chosen || seen.has(chosen)) continue;
+    seen.add(chosen);
+    paths.push(chosen);
+  }
+  return paths;
+}
+
+/**
+ * List paths changed on HEAD vs origin/<baseBranch> (committed range).
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ * @returns {Promise<string[]>}
+ */
+export async function listChangedFiles(worktreePath, baseBranch) {
+  const git = gitFactory(worktreePath);
+  const out = await git.diff([`--name-only`, `origin/${baseBranch}...HEAD`]);
+  return parseNameOnlyOutput(out);
+}
+
+/**
+ * Normalize excludedPaths from an API body: unique non-empty strings.
+ * @param {unknown} raw
+ * @returns {{ ok: true, paths: string[] } | { ok: false, error: string }}
+ */
+export function normalizeExcludedPaths(raw) {
+  if (raw == null) return { ok: true, paths: [] };
+  if (!Array.isArray(raw)) {
+    return { ok: false, error: 'excludedPaths must be an array of strings' };
+  }
+  const seen = new Set();
+  /** @type {string[]} */
+  const paths = [];
+  for (const item of raw) {
+    if (typeof item !== 'string') {
+      return { ok: false, error: 'excludedPaths must be an array of strings' };
+    }
+    const p = item.trim();
+    if (!p || seen.has(p)) continue;
+    seen.add(p);
+    paths.push(p);
+  }
+  return { ok: true, paths };
+}
+
+/**
+ * Validate that at least one changed file remains included.
+ * Unknown excluded paths (not in changedFiles) are ignored.
+ * @param {string[]} changedFiles
+ * @param {string[]} excludedPaths
+ * @returns {{
+ *   ok: true,
+ *   excluded: string[],
+ *   included: string[],
+ * } | { ok: false, error: string }}
+ */
+export function validateFileSelection(changedFiles, excludedPaths) {
+  const changed = [...new Set((changedFiles || []).map((p) => String(p).trim()).filter(Boolean))];
+  const changedSet = new Set(changed);
+  const excluded = [...new Set((excludedPaths || []).map((p) => String(p).trim()).filter(Boolean))]
+    .filter((p) => changedSet.has(p));
+  const included = changed.filter((p) => !excluded.includes(p));
+
+  if (changed.length === 0) {
+    return { ok: false, error: 'No changed files to include in the PR' };
+  }
+  if (included.length === 0) {
+    return { ok: false, error: 'Keep at least one file included' };
+  }
+  return { ok: true, excluded, included };
+}
+
+/**
+ * Restore excluded paths to match origin/<baseBranch>, then commit.
+ * New files (absent on base) are removed from the index/worktree.
+ *
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ * @param {string[]} excludedPaths
+ * @returns {Promise<{ committed: boolean, restored: string[] }>}
+ */
+export async function applyFileExclusions(worktreePath, baseBranch, excludedPaths) {
+  const paths = [...new Set((excludedPaths || []).map((p) => String(p).trim()).filter(Boolean))];
+  if (paths.length === 0) {
+    return { committed: false, restored: [] };
+  }
+
+  const source = `origin/${baseBranch}`;
+  /** @type {string[]} */
+  const restored = [];
+
+  for (const filePath of paths) {
+    try {
+      await execFileAsync(
+        'git',
+        ['restore', `--source=${source}`, '--staged', '--worktree', '--', filePath],
+        { cwd: worktreePath }
+      );
+      restored.push(filePath);
+    } catch {
+      // New file on the branch (or restore otherwise failed): drop it.
+      try {
+        await execFileAsync('git', ['rm', '-f', '--ignore-unmatch', '--', filePath], {
+          cwd: worktreePath,
+        });
+        restored.push(filePath);
+      } catch (rmErr) {
+        const message = rmErr instanceof Error ? rmErr.message : String(rmErr);
+        throw new Error(`Failed to exclude ${filePath}: ${message}`);
+      }
+    }
+  }
+
+  const status = await execFileAsync('git', ['status', '--porcelain'], { cwd: worktreePath });
+  if (!String(status.stdout || '').trim()) {
+    return { committed: false, restored };
+  }
+
+  await execFileAsync(
+    'git',
+    ['commit', '-m', 'chore: exclude files from review selection', '--no-verify'],
+    { cwd: worktreePath }
+  );
+
+  return { committed: true, restored };
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {string} branchName
+ */
+export async function pushBranch(worktreePath, branchName) {
+  const git = gitFactory(worktreePath);
+  await git.push(['-u', 'origin', branchName]);
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {string} issueUrl
+ */
+export async function getIssueTitle(worktreePath, issueUrl) {
+  const { stdout } = await execFileAsync(
+    'gh',
+    ['issue', 'view', issueUrl, '--json', 'title'],
+    { cwd: worktreePath }
+  );
+  const data = JSON.parse(stdout);
+  return data.title;
+}
+
+/**
+ * True when a commit message line is Claude/Anthropic AI attribution.
+ * @param {string} line
+ */
+export function isAiCommitAttributionLine(line) {
+  const trimmed = String(line ?? '').trim();
+  if (!trimmed) return false;
+  if (/^co-authored-by:\s*/i.test(trimmed)) {
+    return /(claude|anthropic|noreply@anthropic\.com)/i.test(trimmed);
+  }
+  if (/^claude-generated-by:/i.test(trimmed)) return true;
+  if (/generated with\s*\[?claude code\]?/i.test(trimmed)) return true;
+  if (/generated by\s+claude/i.test(trimmed)) return true;
+  return false;
+}
+
+/**
+ * Strip AI co-author / "Generated with Claude" trailers from a commit message.
+ * @param {string} message
+ * @returns {string}
+ */
+export function stripAiCommitMessage(message) {
+  if (!message || typeof message !== 'string') return message ?? '';
+
+  const normalized = message.replace(/\r\n/g, '\n');
+  const lines = normalized.split('\n');
+  const kept = lines.filter((line) => !isAiCommitAttributionLine(line));
+
+  // Drop trailing blank lines left behind after removing trailers.
+  while (kept.length > 0 && kept[kept.length - 1].trim() === '') {
+    kept.pop();
+  }
+  // Avoid leaving a double blank before where trailers were.
+  while (kept.length > 1 && kept[kept.length - 1].trim() === '' && kept[kept.length - 2].trim() === '') {
+    kept.pop();
+  }
+
+  const result = kept.join('\n');
+  if (!result.trim()) return result;
+  return result.endsWith('\n') ? result : `${result}\n`;
+}
+
+/**
+ * @param {string} message
+ */
+export function commitMessageHasAiAttribution(message) {
+  return String(message ?? '')
+    .split(/\r?\n/)
+    .some((line) => isAiCommitAttributionLine(line));
+}
+
+/**
+ * @param {string} name
+ * @param {string} email
+ */
+export function isAiGitIdentity(name, email) {
+  const n = String(name ?? '');
+  const e = String(email ?? '').toLowerCase();
+  if (/@anthropic\.com$/i.test(e) || e === 'noreply@anthropic.com') return true;
+  if (/\bclaude\b/i.test(n) || /\banthropic\b/i.test(n)) return true;
+  return false;
+}
+
+/**
+ * Write worktree-local Claude settings that disable Co-Authored-By trailers.
+ * The Agent SDK injects those trailers by default unless attribution is cleared.
+ * @param {string} worktreePath
+ */
+export function ensureNoAiAttributionSettings(worktreePath) {
+  const dir = path.join(worktreePath, '.claude');
+  fs.mkdirSync(dir, { recursive: true });
+  const settingsPath = path.join(dir, 'settings.local.json');
+
+  /** @type {Record<string, unknown>} */
+  let existing = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch {
+      existing = {};
+    }
+  }
+
+  const merged = {
+    ...existing,
+    includeCoAuthoredBy: false,
+    attribution: {
+      ...(typeof existing.attribution === 'object' && existing.attribution
+        ? existing.attribution
+        : {}),
+      commit: '',
+      pr: '',
+    },
+  };
+  fs.writeFileSync(settingsPath, `${JSON.stringify(merged, null, 2)}\n`);
+
+  // Best-effort: keep the local settings file out of agent commits.
+  try {
+    const gitMarker = path.join(worktreePath, '.git');
+    let gitDir = path.join(worktreePath, '.git');
+    if (fs.existsSync(gitMarker) && fs.statSync(gitMarker).isFile()) {
+      const text = fs.readFileSync(gitMarker, 'utf8');
+      const m = text.match(/gitdir:\s*(.+)/i);
+      if (m) gitDir = path.resolve(worktreePath, m[1].trim());
+    }
+    const excludeFile = path.join(gitDir, 'info', 'exclude');
+    const line = '.claude/settings.local.json';
+    if (fs.existsSync(path.dirname(excludeFile))) {
+      const current = fs.existsSync(excludeFile)
+        ? fs.readFileSync(excludeFile, 'utf8')
+        : '';
+      if (!current.split(/\r?\n/).includes(line)) {
+        const prefix = current === '' || current.endsWith('\n') ? '' : '\n';
+        fs.appendFileSync(excludeFile, `${prefix}${line}\n`);
+      }
+    }
+  } catch {
+    // ignore exclude failures
+  }
+
+  return settingsPath;
+}
+
+/**
+ * Resolve git user.name / user.email from a repo (falls back to global).
+ * @param {string} cwd
+ * @returns {Promise<{ name: string, email: string } | null>}
+ */
+export async function getGitUser(cwd) {
+  try {
+    const [{ stdout: nameOut }, { stdout: emailOut }] = await Promise.all([
+      execFileAsync('git', ['config', 'user.name'], { cwd }),
+      execFileAsync('git', ['config', 'user.email'], { cwd }),
+    ]);
+    const name = nameOut.trim();
+    const email = emailOut.trim();
+    if (!name || !email) return null;
+    return { name, email };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ * @returns {Promise<Array<{ sha: string, message: string, authorName: string, authorEmail: string }>>}
+ */
+async function listBranchCommits(worktreePath, baseBranch) {
+  const range = `origin/${baseBranch}..HEAD`;
+  let stdout;
+  try {
+    ({ stdout } = await execFileAsync(
+      'git',
+      ['rev-list', '--reverse', range],
+      { cwd: worktreePath }
+    ));
+  } catch {
+    return [];
+  }
+
+  const shas = stdout
+    .trim()
+    .split('\n')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (shas.length === 0) return [];
+
+  /** @type {Array<{ sha: string, message: string, authorName: string, authorEmail: string }>} */
+  const commits = [];
+  for (const sha of shas) {
+    const { stdout: meta } = await execFileAsync(
+      'git',
+      ['log', '-1', '--format=%an%n%ae%n%B', sha],
+      { cwd: worktreePath }
+    );
+    const nl1 = meta.indexOf('\n');
+    const nl2 = meta.indexOf('\n', nl1 + 1);
+    const authorName = nl1 === -1 ? '' : meta.slice(0, nl1);
+    const authorEmail = nl2 === -1 ? '' : meta.slice(nl1 + 1, nl2);
+    const message = nl2 === -1 ? '' : meta.slice(nl2 + 1);
+    commits.push({ sha, message, authorName, authorEmail });
+  }
+  return commits;
+}
+
+/**
+ * Rewrite branch-only commits to strip AI attribution trailers and fix AI authors.
+ * Runs before push (awaiting_review). No-ops when there are no commits or nothing to fix.
+ *
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ * @param {string} [authorSourceCwd] repo used to read user.name / user.email
+ * @returns {Promise<{ rewritten: number, commits: number }>}
+ */
+export async function sanitizeBranchCommits(worktreePath, baseBranch, authorSourceCwd) {
+  const commits = await listBranchCommits(worktreePath, baseBranch);
+  if (commits.length === 0) {
+    return { rewritten: 0, commits: 0 };
+  }
+
+  const gitUser = await getGitUser(authorSourceCwd || worktreePath);
+  const toFix = commits.filter((c) => {
+    const stripped = stripAiCommitMessage(c.message);
+    const msgNeeds =
+      commitMessageHasAiAttribution(c.message) ||
+      stripped.replace(/\n+$/, '') !== c.message.replace(/\r\n/g, '\n').replace(/\n+$/, '');
+    const authorNeeds = Boolean(gitUser && isAiGitIdentity(c.authorName, c.authorEmail));
+    return msgNeeds || authorNeeds;
+  });
+
+  if (toFix.length === 0) {
+    return { rewritten: 0, commits: commits.length };
+  }
+
+  if (commits.length === 1) {
+    await amendHeadCommit(worktreePath, commits[0], gitUser);
+    return { rewritten: 1, commits: 1 };
+  }
+
+  await rewriteBranchCommitsWithFilter(worktreePath, baseBranch, gitUser);
+  return { rewritten: toFix.length, commits: commits.length };
+}
+
+/**
+ * @param {string} worktreePath
+ * @param {{ message: string, authorName: string, authorEmail: string }} commit
+ * @param {{ name: string, email: string } | null} gitUser
+ */
+async function amendHeadCommit(worktreePath, commit, gitUser) {
+  const cleaned = stripAiCommitMessage(commit.message).replace(/\n$/, '');
+  const forceAuthor = Boolean(gitUser && isAiGitIdentity(commit.authorName, commit.authorEmail));
+
+  /** @type {NodeJS.ProcessEnv} */
+  const env = { ...process.env };
+  const args = ['commit', '--amend', '-m', cleaned, '--no-verify'];
+
+  if (gitUser) {
+    env.GIT_COMMITTER_NAME = gitUser.name;
+    env.GIT_COMMITTER_EMAIL = gitUser.email;
+    if (forceAuthor) {
+      args.push('--author', `${gitUser.name} <${gitUser.email}>`);
+      env.GIT_AUTHOR_NAME = gitUser.name;
+      env.GIT_AUTHOR_EMAIL = gitUser.email;
+    }
+  }
+
+  await execFileAsync('git', args, { cwd: worktreePath, env });
+}
+
+/**
+ * Rewrite commits in origin/base..HEAD: strip AI trailers; fix AI author identities.
+ * @param {string} worktreePath
+ * @param {string} baseBranch
+ * @param {{ name: string, email: string } | null} gitUser
+ */
+async function rewriteBranchCommitsWithFilter(worktreePath, baseBranch, gitUser) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'acdev-rebase-'));
+  const msgFilterPath = path.join(tmpDir, 'msg-filter.mjs');
+  const envFilterPath = path.join(tmpDir, 'env-filter.sh');
+
+  fs.writeFileSync(
+    msgFilterPath,
+    `import fs from 'node:fs';
+const message = fs.readFileSync(0, 'utf8');
+const lines = message.replace(/\\r\\n/g, '\\n').split('\\n');
+const kept = lines.filter((line) => {
+  const t = line.trim();
+  if (!t) return true;
+  if (/^co-authored-by:\\s*/i.test(t)) {
+    return !/(claude|anthropic|noreply@anthropic\\.com)/i.test(t);
+  }
+  if (/^claude-generated-by:/i.test(t)) return false;
+  if (/generated with\\s*\\[?claude code\\]?/i.test(t)) return false;
+  if (/generated by\\s+claude/i.test(t)) return false;
+  return true;
+});
+while (kept.length > 0 && kept[kept.length - 1].trim() === '') kept.pop();
+let result = kept.join('\\n');
+if (result.trim() && !result.endsWith('\\n')) result += '\\n';
+process.stdout.write(result);
+`
+  );
+
+  const name = gitUser?.name?.replace(/'/g, `'\\''`) ?? '';
+  const email = gitUser?.email?.replace(/'/g, `'\\''`) ?? '';
+  fs.writeFileSync(
+    envFilterPath,
+    `#!/bin/sh
+is_ai=0
+case "$GIT_AUTHOR_EMAIL" in
+  *anthropic.com) is_ai=1 ;;
+esac
+case "$GIT_AUTHOR_NAME" in
+  *[Cc]laude*|*[Aa]nthropic*) is_ai=1 ;;
+esac
+if [ "$is_ai" = "1" ] && [ -n '${name}' ] && [ -n '${email}' ]; then
+  export GIT_AUTHOR_NAME='${name}'
+  export GIT_AUTHOR_EMAIL='${email}'
+  export GIT_COMMITTER_NAME='${name}'
+  export GIT_COMMITTER_EMAIL='${email}'
+fi
+`,
+    { mode: 0o755 }
+  );
+
+  const quotedMsg = JSON.stringify(msgFilterPath);
+  const quotedEnv = JSON.stringify(envFilterPath);
+
+  try {
+    await execFileAsync(
+      'git',
+      [
+        'filter-branch',
+        '-f',
+        '--msg-filter',
+        `${process.execPath} ${quotedMsg}`,
+        '--env-filter',
+        `. ${quotedEnv}`,
+        `origin/${baseBranch}..HEAD`,
+      ],
+      {
+        cwd: worktreePath,
+        env: { ...process.env, FILTER_BRANCH_SQUELCH_WARNING: '1' },
+      }
+    );
+  } catch (err) {
+    const detail = err.stderr?.toString?.() || err.message || String(err);
+    throw new Error(`Failed to strip AI attribution from commits: ${detail}`);
+  } finally {
+    try {
+      const gitDir = (
+        await execFileAsync('git', ['rev-parse', '--git-dir'], { cwd: worktreePath })
+      ).stdout.trim();
+      const originalRefs = path.resolve(worktreePath, gitDir, 'refs', 'original');
+      if (fs.existsSync(originalRefs)) {
+        fs.rmSync(originalRefs, { recursive: true, force: true });
+      }
+    } catch {
+      // Best-effort cleanup of filter-branch backup refs.
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+