sela-core 0.1.0-alpha.1

package/dist/services/PRAutomationService.js

@@ -0,0 +1,760 @@
+"use strict";
+// src/services/PRAutomationService.ts
+//
+// Git-flow automation layer. Runs ONCE per session at SelaEngine.commitUpdates().
+// Responsibilities:
+//   1. Detect the active branch (CI env vars first, git CLI fallback).
+//   2. Resolve the EFFECTIVE strategy via trust-aware downgrade.
+//   3. Execute the strategy: directCommit | pr | draftPR | readOnly.
+//   4. Handle PROTECTED events per onBugDetected policy.
+//
+// Hard requirements:
+//   - GitHub-only in v1 (uses `gh` CLI).
+//   - Never throws into the caller. Failures degrade to warnings + readOnly.
+//   - Detached HEAD or missing `gh` → skip git ops, emit clear log.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectBranch = detectBranch;
+exports.decideEffectiveStrategy = decideEffectiveStrategy;
+exports.fmtPct = fmtPct;
+exports.execute = execute;
+exports.handleBugDetected = handleBugDetected;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const WorkspaceSnapshotService_1 = require("./WorkspaceSnapshotService");
+const IsolatedDiff_1 = require("../utils/IsolatedDiff");
+const logger_1 = require("../utils/logger");
+// ═══════════════════════════════════════════════════════════════════
+// SHELL HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function sh(cmd, cwd) {
+    try {
+        const stdout = (0, child_process_1.execSync)(cmd, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return { ok: true, stdout: stdout.toString(), stderr: "" };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            stdout: err?.stdout?.toString() ?? "",
+            stderr: err?.stderr?.toString() ?? err?.message ?? "unknown error",
+        };
+    }
+}
+function ghAvailable(cwd) {
+    return sh("gh --version", cwd).ok;
+}
+function gitAvailable(cwd) {
+    return sh("git --version", cwd).ok;
+}
+function isDetachedHead(cwd) {
+    return !sh("git symbolic-ref HEAD", cwd).ok;
+}
+const SELA_BRANCH_PREFIX = "sela/heal-";
+function isSelaHealBranch(branch) {
+    return !!branch && branch.startsWith(SELA_BRANCH_PREFIX);
+}
+/**
+ * Resolve the repo's default integration branch.
+ *   1. origin/HEAD symbolic-ref (set by `git clone`).
+ *   2. First existing local ref among: main, master, develop, dev.
+ * Returns null if none found - caller must handle that.
+ */
+function findDefaultBranch(cwd) {
+    const headRef = sh("git symbolic-ref refs/remotes/origin/HEAD", cwd);
+    if (headRef.ok) {
+        const m = headRef.stdout.trim().match(/refs\/remotes\/origin\/(.+)$/);
+        if (m)
+            return m[1];
+    }
+    for (const candidate of ["main", "master", "develop", "dev"]) {
+        if (sh(`git rev-parse --verify --quiet ${candidate}`, cwd).ok) {
+            return candidate;
+        }
+    }
+    return null;
+}
+// ═══════════════════════════════════════════════════════════════════
+// TEMPLATING
+// ═══════════════════════════════════════════════════════════════════
+function render(template, vars) {
+    return template.replace(/\$\{(\w+)\}/g, (_m, k) => k in vars ? String(vars[k]) : `\${${k}}`);
+}
+// ═══════════════════════════════════════════════════════════════════
+// BRANCH DETECTION
+// ═══════════════════════════════════════════════════════════════════
+function detectBranch(cwd = process.cwd()) {
+    // GitHub Actions exposes both REF_NAME (push) and HEAD_REF (PR).
+    const ghHeadRef = process.env.GITHUB_HEAD_REF; // PR source branch
+    const ghRefName = process.env.GITHUB_REF_NAME; // current branch on push, or "<n>/merge" on PR
+    const ghEventName = process.env.GITHUB_EVENT_NAME;
+    const ghRef = process.env.GITHUB_REF; // "refs/pull/123/merge"
+    // Prefer HEAD_REF on PRs - REF_NAME is the synthetic merge ref.
+    if (ghHeadRef && ghHeadRef.length > 0 && !isSelaHealBranch(ghHeadRef)) {
+        const prNumber = (() => {
+            const m = ghRef?.match(/refs\/pull\/(\d+)\//);
+            return m ? Number(m[1]) : null;
+        })();
+        return { branch: ghHeadRef, isPR: true, prNumber, source: "env" };
+    }
+    if (ghRefName &&
+        ghRefName.length > 0 &&
+        !ghRefName.endsWith("/merge") &&
+        !isSelaHealBranch(ghRefName)) {
+        return {
+            branch: ghRefName,
+            isPR: ghEventName === "pull_request",
+            prNumber: null,
+            source: "env",
+        };
+    }
+    // GitLab CI fallback
+    const gitlabRef = process.env.CI_COMMIT_REF_NAME;
+    if (gitlabRef && gitlabRef.length > 0 && !isSelaHealBranch(gitlabRef)) {
+        return { branch: gitlabRef, isPR: false, prNumber: null, source: "env" };
+    }
+    // Generic Jenkins / local fallback
+    const jenkinsBranch = process.env.GIT_BRANCH;
+    if (jenkinsBranch && jenkinsBranch.length > 0) {
+        const cleaned = jenkinsBranch.replace(/^origin\//, "");
+        if (!isSelaHealBranch(cleaned)) {
+            return { branch: cleaned, isPR: false, prNumber: null, source: "env" };
+        }
+    }
+    // Local: git CLI
+    if (!gitAvailable(cwd)) {
+        return { branch: null, isPR: false, prNumber: null, source: "none" };
+    }
+    const r = sh("git rev-parse --abbrev-ref HEAD", cwd);
+    if (!r.ok)
+        return { branch: null, isPR: false, prNumber: null, source: "none" };
+    const localBranch = r.stdout.trim();
+    if (!localBranch || localBranch === "HEAD") {
+        return { branch: null, isPR: false, prNumber: null, source: "none" };
+    }
+    // ── Sela self-branch guard ─────────────────────────────────────────
+    // If we're sitting on a previously-created `sela/heal-*` branch (typical
+    // local-rerun scenario), do NOT use it as the PR base. Fall back to the
+    // repo's default integration branch (main / master / develop) so the new
+    // PR targets a real branch, not another sela patch branch.
+    if (isSelaHealBranch(localBranch)) {
+        const fallback = findDefaultBranch(cwd);
+        if (fallback) {
+            logger_1.logger.warn(`PR: HEAD is on '${localBranch}' (sela patch branch) - ` +
+                `using '${fallback}' as PR base instead.`);
+            return { branch: fallback, isPR: false, prNumber: null, source: "git" };
+        }
+        logger_1.logger.warn(`PR: HEAD is on '${localBranch}' and no default branch found - ` +
+            `skipping PR automation to avoid self-targeting.`);
+        return { branch: null, isPR: false, prNumber: null, source: "none" };
+    }
+    return { branch: localBranch, isPR: false, prNumber: null, source: "git" };
+}
+// ═══════════════════════════════════════════════════════════════════
+// STRATEGY DECISION
+// ═══════════════════════════════════════════════════════════════════
+function decideEffectiveStrategy(cfg, branch, heals) {
+    // Compute MIN across only the heals that reported a finite numeric
+    // confidence. When *no* heal carried one, the result is `undefined` -
+    // surfaced as "n/a" in reports rather than synthesised as 100% (which
+    // would silently mask the absence of evidence) or 0% (which would
+    // incorrectly force a downgrade for every clean run on Sonnet).
+    const aiVals = heals
+        .map((h) => h.aiConfidence)
+        .filter((v) => typeof v === "number" && Number.isFinite(v));
+    const audVals = heals
+        .map((h) => h.auditor?.confidence)
+        .filter((v) => typeof v === "number" && Number.isFinite(v));
+    const minAi = aiVals.length > 0 ? Math.min(...aiVals) : undefined;
+    const minAud = audVals.length > 0 ? Math.min(...audVals) : undefined;
+    const baseDecision = {
+        effective: cfg.strategy,
+        configured: cfg.strategy,
+        downgradeReason: null,
+        minAiConfidence: minAi,
+        minAuditorConfidence: minAud,
+    };
+    if (cfg.strategy !== "directCommit")
+        return baseDecision;
+    // Rule 1: protected branch → forced downgrade
+    if (branch && cfg.protectedBranches.includes(branch)) {
+        return {
+            ...baseDecision,
+            effective: cfg.reviewThresholds.downgradeTo,
+            downgradeReason: "PROTECTED_BRANCH",
+        };
+    }
+    // Rule 2: low AI confidence - only triggers when the measured min is
+    // actually below the threshold. Missing confidence is "unknown", not
+    // "zero", so we do NOT downgrade purely on absence.
+    if (cfg.reviewThresholds.minConfidenceForDirectCommit > 0 &&
+        typeof minAi === "number" &&
+        minAi < cfg.reviewThresholds.minConfidenceForDirectCommit) {
+        return {
+            ...baseDecision,
+            effective: cfg.reviewThresholds.downgradeTo,
+            downgradeReason: "LOW_CONFIDENCE",
+        };
+    }
+    // Rule 3: low auditor score - same "absence ≠ zero" rule as Rule 2.
+    if (cfg.reviewThresholds.minAuditorScoreForDirectCommit > 0 &&
+        typeof minAud === "number" &&
+        minAud < cfg.reviewThresholds.minAuditorScoreForDirectCommit) {
+        return {
+            ...baseDecision,
+            effective: cfg.reviewThresholds.downgradeTo,
+            downgradeReason: "LOW_AUDITOR",
+        };
+    }
+    return baseDecision;
+}
+// ═══════════════════════════════════════════════════════════════════
+// PR BODY RENDERING
+// ═══════════════════════════════════════════════════════════════════
+function fmtPct(v) {
+    return typeof v === "number" && Number.isFinite(v) ? `${v}%` : "n/a";
+}
+/**
+ * Strip the file-level preamble from a unified diff so the GitHub Markdown
+ * renderer doesn't show `--- a/file` / `+++ b/file` as red/green lines (which
+ * read as fake deletions/additions in a ```diff fence). Keeps the `@@` hunk
+ * header and every -/+/space content row intact, so the rendered block is
+ * still syntactically a valid unified diff that GitHub highlights correctly.
+ */
+function stripDiffPreamble(raw) {
+    return raw
+        .split(/\r?\n/)
+        .filter((ln) => {
+        if (ln.startsWith("diff "))
+            return false;
+        if (ln.startsWith("index "))
+            return false;
+        if (ln.startsWith("--- "))
+            return false;
+        if (ln.startsWith("+++ "))
+            return false;
+        if (ln.startsWith("new file mode"))
+            return false;
+        if (ln.startsWith("deleted file mode"))
+            return false;
+        if (ln.startsWith("similarity "))
+            return false;
+        if (ln.startsWith("rename "))
+            return false;
+        if (ln.startsWith("Binary files"))
+            return false;
+        return true;
+    })
+        .join("\n")
+        .replace(/\n+$/, "");
+}
+function buildDefaultBody(heals, branchInfo, reportLink, decision) {
+    const lines = [];
+    lines.push(`# 🤖 Sela Insights - Automation Suite Healed!`);
+    lines.push("");
+    lines.push(`Sela kept your pipeline running by healing ${heals.length} broken locator(s).`);
+    lines.push("");
+    lines.push(`## 📊 Executive Summary`);
+    lines.push(`* **Heals:** ${heals.length}`);
+    lines.push(`* **Min AI Confidence:** ${fmtPct(decision.minAiConfidence)}`);
+    lines.push(`* **Min Auditor Confidence:** ${fmtPct(decision.minAuditorConfidence)}`);
+    lines.push(`* **Branch:** \`${branchInfo.branch ?? "unknown"}\``);
+    if (decision.downgradeReason) {
+        lines.push(`* **⚠️ Strategy Downgrade:** \`${decision.configured}\` → \`${decision.effective}\` (${decision.downgradeReason})`);
+    }
+    lines.push("");
+    lines.push(`## 💻 Per-Heal Diff`);
+    for (const h of heals) {
+        const lineRef = h.newLineNumber ?? h.sourceLine;
+        lines.push(`### \`${h.sourceFile}:${lineRef}\` - ${h.testTitle ?? "(no test title)"}`);
+        lines.push("");
+        lines.push("```diff");
+        if (h.gitUnifiedDiff && h.gitUnifiedDiff.trim().length > 0) {
+            // Emit the real git diff verbatim. This natively handles cross-file
+            // healing, multi-line edits, and template-literal changes - none of
+            // which the legacy single-line -/+ pair could represent.
+            lines.push(stripDiffPreamble(h.gitUnifiedDiff));
+        }
+        else {
+            // Fallback when git was unavailable / the file was untracked.
+            lines.push(`- ${(h.oldCodeLine ?? "").trim()}`);
+            lines.push(`+ ${(h.newCodeLine ?? "").trim()}`);
+        }
+        lines.push("```");
+        if (h.aiExplanation) {
+            lines.push(`> 🧠 ${h.aiExplanation}`);
+        }
+        lines.push(`> AI Confidence: **${fmtPct(h.aiConfidence)}** · Auditor: **${fmtPct(h.auditor?.confidence)}**`);
+        lines.push("");
+    }
+    lines.push(`## 🔍 Visual Evidence`);
+    lines.push(`[📄 View Full Interactive Healing Report](${reportLink})`);
+    lines.push("");
+    lines.push(`---`);
+    lines.push(`Generated automatically by \`sela-core\`.`);
+    return lines.join("\n");
+}
+/**
+ * Clean-Room execution lifecycle.
+ *
+ * The legacy flow committed the developer's whole dirty working tree onto
+ * the PR branch - polluting reviewers with `test.only`, commented debug
+ * blocks, etc. This refactor isolates Sela's specific AST changes onto an
+ * ephemeral branch, leaves the developer's local workspace byte-identical
+ * to its pre-Sela state, and is wrapped in a try/finally that restores
+ * the workspace even on mid-flight crashes.
+ */
+async function execute(cfg, decision, heals, branchInfo, ctx, 
+/** Injectable for tests - defaults to the module singleton. */
+workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
+    const result = {
+        effective: decision.effective,
+        prUrl: null,
+        branchPushed: null,
+        errors: [],
+    };
+    if (decision.effective === "readOnly") {
+        logger_1.logger.info(`PR: readOnly - no git operations performed.`);
+        if (ctx.reportHtmlPath) {
+            logger_1.logger.info(`PR: Report artifact: ${ctx.reportHtmlPath}`);
+        }
+        return result;
+    }
+    if (heals.length === 0) {
+        logger_1.logger.info(`PR: No HEALED events - skipping git operations.`);
+        return result;
+    }
+    if (!gitAvailable(ctx.cwd)) {
+        result.errors.push("git CLI not available");
+        logger_1.logger.warn(`PR: git CLI not available - skipping.`);
+        return result;
+    }
+    if (isDetachedHead(ctx.cwd)) {
+        result.errors.push("detached HEAD");
+        logger_1.logger.warn(`PR: Detached HEAD - skipping git operations.`);
+        return result;
+    }
+    const mutatedSnaps = workspace.getMutatedSnapshots();
+    if (mutatedSnaps.length === 0) {
+        result.errors.push("no mutated files tracked");
+        logger_1.logger.warn(`PR: WorkspaceSnapshotService reports no mutated files - skipping.`);
+        return result;
+    }
+    // Render title / body up front - needed by all branches below.
+    const first = heals[0];
+    const titleVars = {
+        testName: first.testTitle ?? "automation",
+        fileName: path.basename(first.sourceFile),
+        count: heals.length,
+    };
+    const title = render(cfg.titleTemplate, titleVars);
+    const reportLink = ctx.reportHtmlPath
+        ? path.relative(ctx.cwd, ctx.reportHtmlPath)
+        : cfg.reportArtifactPath;
+    const body = cfg.bodyTemplate
+        ? render(cfg.bodyTemplate, {
+            ...titleVars,
+            summary: `${heals.length} heal(s)`,
+            reportLink,
+            reasoning: heals.map((h) => h.aiExplanation).join("\n\n"),
+        })
+        : buildDefaultBody(heals, branchInfo, reportLink, decision);
+    if (decision.effective === "directCommit") {
+        return runCleanRoom({
+            mode: "directCommit",
+            cfg,
+            ctx,
+            mutatedSnaps,
+            title,
+            body,
+            branchInfo,
+            decision,
+            result,
+        });
+    }
+    if (decision.effective === "pr" || decision.effective === "draftPR") {
+        if (!ghAvailable(ctx.cwd)) {
+            result.errors.push("gh CLI not available");
+            logger_1.logger.warn(`PR: gh CLI not installed - cannot open PR. Run \`gh auth login\` after install.`);
+            return result;
+        }
+        return runCleanRoom({
+            mode: decision.effective,
+            cfg,
+            ctx,
+            mutatedSnaps,
+            title,
+            body,
+            branchInfo,
+            decision,
+            result,
+        });
+    }
+    return result;
+}
+async function runCleanRoom(args) {
+    const { mode, cfg, ctx, mutatedSnaps, title, body, branchInfo, decision, result, } = args;
+    const id = String(Date.now());
+    const stashLabel = `sela:clean-room-${id}`;
+    const originalBranch = currentBranch(ctx.cwd);
+    const targetBranch = mode === "directCommit"
+        ? originalBranch
+        : render(cfg.branchNameTemplate, { id, timestamp: id });
+    // Lifecycle state - used by the finally{} restoration block.
+    let didRestoreOriginal = false;
+    let didStash = false;
+    let didSwitchToTarget = false;
+    let didCommit = false;
+    try {
+        // 1. State Checkpoint - rewind developer's mutated files to pre-Sela
+        //    state on disk. Other dirty files (unrelated to Sela) stay where
+        //    they are; the subsequent stash will sweep them up.
+        workspaceRestoreOriginal(mutatedSnaps);
+        didRestoreOriginal = true;
+        // 2. Branch Isolation - stash everything (tracked + untracked) so the
+        //    worktree mirrors HEAD when we switch / branch off.
+        const stash = sh(`git stash push -u -m ${shellQuote(stashLabel)}`, ctx.cwd);
+        if (stash.ok) {
+            didStash = !/No local changes to save/i.test(stash.stdout);
+        }
+        else {
+            // Stash failures are non-fatal when the worktree was already clean.
+            logger_1.logger.debug(`PR: stash skipped: ${stash.stderr}`);
+        }
+        if (mode !== "directCommit") {
+            const checkout = sh(`git checkout -b ${targetBranch}`, ctx.cwd);
+            if (!checkout.ok) {
+                throw new Error(`git checkout -b ${targetBranch}: ${checkout.stderr}`);
+            }
+            didSwitchToTarget = true;
+        }
+        // 3. Targeted Hunk Patching - apply ONLY Sela's blocks to each file's
+        //    clean HEAD content. Refuses to write if dirty edits collide with
+        //    Sela's mutation site (block not found / not unique).
+        for (const snap of mutatedSnaps) {
+            const applied = applyMutationToClean(snap);
+            if (!applied.ok) {
+                throw new Error(`cannot apply Sela mutation to clean base of ${snap.relativePath}: ${applied.reason}`);
+            }
+            fs.writeFileSync(snap.absolutePath, applied.result, "utf8");
+        }
+        // 4. Stage, commit, push.
+        for (const snap of mutatedSnaps) {
+            const add = sh(`git add ${shellQuote(snap.relativePath)}`, ctx.cwd);
+            if (!add.ok)
+                result.errors.push(`git add ${snap.relativePath}: ${add.stderr}`);
+        }
+        configureGitIdentityForCI(ctx.cwd);
+        const commit = sh(`git commit -m ${shellQuote(title)}`, ctx.cwd);
+        if (!commit.ok) {
+            throw new Error(`git commit: ${commit.stderr}`);
+        }
+        didCommit = true;
+        logger_1.logger.success(`PR: Clean commit on '${targetBranch ?? "(unknown)"}': ${title}`);
+        const pushCmd = mode === "directCommit"
+            ? `git push`
+            : `git push -u origin ${shellQuote(targetBranch)}`;
+        const push = sh(pushCmd, ctx.cwd);
+        if (!push.ok) {
+            throw new Error(`git push: ${push.stderr}`);
+        }
+        if (mode !== "directCommit") {
+            result.branchPushed = targetBranch;
+        }
+        // 5. (PR modes only) open the PR.
+        if (mode === "pr" || mode === "draftPR") {
+            const prUrl = openPullRequest({
+                cfg,
+                ctx,
+                mode,
+                title,
+                body,
+                branchInfo,
+                id,
+                result,
+            });
+            if (prUrl)
+                result.prUrl = prUrl;
+        }
+    }
+    catch (err) {
+        result.errors.push(err?.message ?? String(err));
+        logger_1.logger.warn(`PR: Clean-room flow failed: ${err?.message ?? err}`);
+    }
+    finally {
+        // 6. Workspace Restoration - ALWAYS attempt, even on mid-flight crash.
+        //    Order matters:
+        //      a) Switch back to the developer's original branch (if we left it).
+        //      b) Pop the stash to restore the dirty pre-Sela working tree.
+        //      c) Defensively re-write contentBefore for tracked files in case
+        //         the stash was lost.
+        try {
+            if (didSwitchToTarget && originalBranch) {
+                const back = sh(`git checkout ${shellQuote(originalBranch)}`, ctx.cwd);
+                if (!back.ok) {
+                    logger_1.logger.warn(`PR: Could not switch back to '${originalBranch}': ${back.stderr}`);
+                }
+            }
+            if (didStash) {
+                const pop = sh(`git stash pop`, ctx.cwd);
+                if (!pop.ok) {
+                    logger_1.logger.warn(`PR: git stash pop failed: ${pop.stderr}`);
+                }
+            }
+            if (didRestoreOriginal) {
+                // Belt-and-braces - every tracked snapshot back to its dirty
+                // pre-Sela state. No-op if stash pop already did the job.
+                workspaceRestoreOriginal(mutatedSnaps);
+            }
+        }
+        catch (restoreErr) {
+            logger_1.logger.warn(`PR: Workspace restoration error: ${restoreErr?.message ?? restoreErr}`);
+        }
+    }
+    if (!didCommit && result.errors.length === 0) {
+        result.errors.push("clean-room flow did not produce a commit");
+    }
+    return result;
+}
+function openPullRequest(args) {
+    const { cfg, ctx, mode, title, body, branchInfo, id, result } = args;
+    const bodyFile = path.join(ctx.cwd, `.sela-pr-body-${id}.md`);
+    try {
+        fs.writeFileSync(bodyFile, body, "utf8");
+    }
+    catch (err) {
+        result.errors.push(`pr body write: ${err?.message ?? err}`);
+        return null;
+    }
+    const labelFlag = cfg.labels.length > 0
+        ? cfg.labels.map((l) => `--label ${shellQuote(l)}`).join(" ")
+        : "";
+    const draftFlag = mode === "draftPR" ? "--draft" : "";
+    const baseFlag = branchInfo.branch
+        ? `--base ${shellQuote(branchInfo.branch)}`
+        : "";
+    const prCmd = `gh pr create ${draftFlag} ${baseFlag} ` +
+        `--title ${shellQuote(title)} ` +
+        `--body-file ${shellQuote(bodyFile)} ` +
+        `${labelFlag}`;
+    const pr = sh(prCmd, ctx.cwd);
+    try {
+        fs.unlinkSync(bodyFile);
+    }
+    catch {
+        /* ignore */
+    }
+    if (!pr.ok) {
+        result.errors.push(`gh pr create: ${pr.stderr}`);
+        logger_1.logger.warn(`PR: gh pr create failed: ${pr.stderr}`);
+        return null;
+    }
+    const url = pr.stdout.trim();
+    logger_1.logger.success(`${mode === "draftPR" ? "Draft PR" : "PR"} opened: ${url}`);
+    return url;
+}
+// ═══════════════════════════════════════════════════════════════════
+// CLEAN-ROOM HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function currentBranch(cwd) {
+    const r = sh("git rev-parse --abbrev-ref HEAD", cwd);
+    if (!r.ok)
+        return null;
+    const b = r.stdout.trim();
+    return b && b !== "HEAD" ? b : null;
+}
+function workspaceRestoreOriginal(snaps) {
+    for (const snap of snaps) {
+        try {
+            if (snap.createdBySela) {
+                if (fs.existsSync(snap.absolutePath))
+                    fs.unlinkSync(snap.absolutePath);
+                continue;
+            }
+            fs.writeFileSync(snap.absolutePath, snap.contentBefore, "utf8");
+        }
+        catch (err) {
+            logger_1.logger.warn(`PR: Could not restore ${snap.relativePath}: ${err?.message ?? err}`);
+        }
+    }
+}
+function applyMutationToClean(snap) {
+    const after = snap.contentAfter ?? "";
+    // File didn't exist on HEAD (created by Sela or untracked). Write the
+    // post-mutation content directly - there's no clean base to merge into.
+    if (snap.headContent === null) {
+        return { ok: true, result: after };
+    }
+    // No dirty edits - `headContent === contentBefore`, so the mutation
+    // applies cleanly as a 1:1 string equivalence.
+    if (snap.headContent === snap.contentBefore) {
+        return { ok: true, result: after };
+    }
+    // Dirty edits present - extract Sela's specific change blocks and
+    // re-apply them against the clean HEAD content via unique substring
+    // replacement. Fails loudly when the dirty edits overlap Sela's site.
+    const blocks = (0, IsolatedDiff_1.extractChangeBlocks)(snap.contentBefore, after);
+    if (blocks.length === 0) {
+        return { ok: true, result: snap.headContent };
+    }
+    return (0, IsolatedDiff_1.applyChangeBlocks)(snap.headContent, blocks);
+}
+/**
+ * CI adapters (GitHub Actions, GitLab, Jenkins) often run with no global
+ * git identity. `git commit` then fails with `Please tell me who you are`,
+ * tanking the whole heal pipeline. Plant a sela bot identity for THIS
+ * commit only when no `user.email` / `user.name` is configured - never
+ * overwrite an existing identity.
+ */
+function configureGitIdentityForCI(cwd) {
+    const isCI = process.env.CI === "true" ||
+        process.env.CI === "1" ||
+        !!process.env.GITHUB_ACTIONS ||
+        !!process.env.GITLAB_CI ||
+        !!process.env.JENKINS_URL;
+    if (!isCI)
+        return;
+    const email = sh("git config user.email", cwd);
+    if (!email.ok || email.stdout.trim().length === 0) {
+        sh(`git config user.email "sela-bot@anthropic.local"`, cwd);
+    }
+    const name = sh("git config user.name", cwd);
+    if (!name.ok || name.stdout.trim().length === 0) {
+        sh(`git config user.name "Sela Bot"`, cwd);
+    }
+}
+// ═══════════════════════════════════════════════════════════════════
+// BUG-DETECTED HANDLING
+// ═══════════════════════════════════════════════════════════════════
+async function handleBugDetected(action, events, branchInfo, ctx) {
+    if (events.length === 0)
+        return;
+    logger_1.logger.warn(`Protection: ${events.length} potential regression(s) detected - auto-fix blocked.`);
+    for (const e of events) {
+        logger_1.logger.warn(`  • ${e.sourceFile}:${e.sourceLine} - ${e.reason} (auditor: ${e.auditor?.verdict ?? "n/a"})`);
+    }
+    if (action === "failCI") {
+        logger_1.logger.warn(`Protection: onBugDetected='failCI' - setting process.exitCode = 1`);
+        process.exitCode = 1;
+        return;
+    }
+    if (action === "createIssue") {
+        if (!ghAvailable(ctx.cwd)) {
+            logger_1.logger.warn(`Protection: gh CLI unavailable - cannot create issue.`);
+            return;
+        }
+        for (const e of events) {
+            const id = String(Date.now());
+            const title = `[Sela Alert] Potential Bug Detected: ${e.testTitle ?? path.basename(e.sourceFile)}`;
+            const body = [
+                `## 🛑 Sela detected a potential regression`,
+                ``,
+                `* **File:** \`${e.sourceFile}:${e.sourceLine}\``,
+                `* **Test:** ${e.testTitle ?? "(unknown)"}`,
+                `* **Reason:** ${e.reason}`,
+                `* **Safety Level:** ${e.safetyLevel}`,
+                `* **Auditor:** ${e.auditor?.verdict ?? "n/a"} (${e.auditor?.confidence ?? "n/a"}%)`,
+                ``,
+                `### Old selector`,
+                `\`${e.oldSelector}\``,
+                ``,
+                `### AI candidate (BLOCKED)`,
+                `\`${e.candidateNewSelector ?? "(none)"}\``,
+                ``,
+                `### AI explanation`,
+                `> ${e.aiExplanation || "(none)"}`,
+            ].join("\n");
+            const bodyFile = path.join(ctx.cwd, `.sela-issue-body-${id}.md`);
+            fs.writeFileSync(bodyFile, body, "utf8");
+            const cmd = `gh issue create --title ${shellQuote(title)} ` +
+                `--body-file ${shellQuote(bodyFile)} ` +
+                `--label sela-bug-detected`;
+            const r = sh(cmd, ctx.cwd);
+            try {
+                fs.unlinkSync(bodyFile);
+            }
+            catch {
+                /* ignore */
+            }
+            if (!r.ok) {
+                logger_1.logger.warn(`Protection: gh issue create failed: ${r.stderr}`);
+            }
+            else {
+                logger_1.logger.success(`Protection: Issue created: ${r.stdout.trim()}`);
+            }
+        }
+        return;
+    }
+    if (action === "labelOnly") {
+        if (!ghAvailable(ctx.cwd)) {
+            logger_1.logger.warn(`Protection: gh CLI unavailable - cannot label PR.`);
+            return;
+        }
+        if (!branchInfo.isPR || !branchInfo.prNumber) {
+            logger_1.logger.warn(`Protection: Not running on a PR - labelOnly skipped.`);
+            return;
+        }
+        const labelCmd = `gh pr edit ${branchInfo.prNumber} --add-label sela-bug-detected`;
+        const labelRes = sh(labelCmd, ctx.cwd);
+        if (!labelRes.ok) {
+            logger_1.logger.warn(`Protection: gh pr edit failed: ${labelRes.stderr}`);
+            return;
+        }
+        const comment = `⚠️ Sela detected ${events.length} potential regression(s). Review before merging.`;
+        const commentRes = sh(`gh pr comment ${branchInfo.prNumber} --body ${shellQuote(comment)}`, ctx.cwd);
+        if (!commentRes.ok) {
+            logger_1.logger.warn(`Protection: gh pr comment failed: ${commentRes.stderr}`);
+        }
+        else {
+            logger_1.logger.success(`Protection: PR #${branchInfo.prNumber} labeled + commented.`);
+        }
+    }
+}
+// ═══════════════════════════════════════════════════════════════════
+// SHELL QUOTING - cross-platform (POSIX single-quote escape;
+// on Windows execSync uses cmd.exe which handles double-quotes natively).
+// ═══════════════════════════════════════════════════════════════════
+function shellQuote(s) {
+    if (process.platform === "win32") {
+        // cmd.exe: escape inner double-quotes by doubling them.
+        return `"${s.replace(/"/g, '""')}"`;
+    }
+    // POSIX: wrap in single quotes; close-and-reopen for embedded single quotes.
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}