sela-core 1.0.3 → 1.0.5

package/dist/services/PRAutomationService.d.ts

@@ -0,0 +1,30 @@
+import type { ResolvedPRAutomation, PRStrategy, BugAction } from "../config/SelaConfig";
+import type { HealedEvent, ProtectedEvent } from "./HealReportService";
+export interface BranchInfo {
+    branch: string | null;
+    isPR: boolean;
+    prNumber: number | null;
+    source: "env" | "git" | "none";
+}
+export interface StrategyDecision {
+    effective: PRStrategy;
+    configured: PRStrategy;
+    downgradeReason: "PROTECTED_BRANCH" | "LOW_CONFIDENCE" | "LOW_AUDITOR" | null;
+    minAiConfidence: number;
+    minAuditorConfidence: number;
+}
+export interface ExecuteContext {
+    cwd: string;
+    reportHtmlPath: string | null;
+}
+export declare function detectBranch(cwd?: string): BranchInfo;
+export declare function decideEffectiveStrategy(cfg: ResolvedPRAutomation, branch: string | null, heals: HealedEvent[]): StrategyDecision;
+export interface ExecutionResult {
+    effective: PRStrategy;
+    prUrl: string | null;
+    branchPushed: string | null;
+    errors: string[];
+}
+export declare function execute(cfg: ResolvedPRAutomation, decision: StrategyDecision, heals: HealedEvent[], branchInfo: BranchInfo, ctx: ExecuteContext): Promise<ExecutionResult>;
+export declare function handleBugDetected(action: BugAction, events: ProtectedEvent[], branchInfo: BranchInfo, ctx: ExecuteContext): Promise<void>;
+//# sourceMappingURL=PRAutomationService.d.ts.map

package/dist/services/PRAutomationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PRAutomationService.d.ts","sourceRoot":"","sources":["../../src/services/PRAutomationService.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,SAAS,EACV,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACf,MAAM,qBAAqB,CAAC;AAM7B,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,aAAa,GAAG,IAAI,CAAC;IAC9E,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AA2ED,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,UAAU,CA8EpE;AAMD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,WAAW,EAAE,GACnB,gBAAgB,CAuDlB;AA6DD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAsB,OAAO,CAC3B,GAAG,EAAE,oBAAoB,EACzB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,WAAW,EAAE,EACpB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,eAAe,CAAC,CA4J1B;AAMD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,cAAc,EAAE,EACxB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC,CA0Ff"}

package/dist/services/PRAutomationService.js

@@ -0,0 +1,509 @@
+"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.execute = execute;
+exports.handleBugDetected = handleBugDetected;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// ═══════════════════════════════════════════════════════════════════
+// 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) {
+            console.warn(`[Sela PR] ⚠️  HEAD is on '${localBranch}' (sela patch branch) — ` +
+                `using '${fallback}' as PR base instead.`);
+            return { branch: fallback, isPR: false, prNumber: null, source: "git" };
+        }
+        console.warn(`[Sela 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) {
+    const minAi = heals.length === 0
+        ? 100
+        : Math.min(...heals.map((h) => h.aiConfidence ?? 100));
+    const minAud = heals.length === 0
+        ? 100
+        : Math.min(...heals.map((h) => h.auditor?.confidence ?? 100));
+    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
+    if (cfg.reviewThresholds.minConfidenceForDirectCommit > 0 &&
+        minAi < cfg.reviewThresholds.minConfidenceForDirectCommit) {
+        return {
+            ...baseDecision,
+            effective: cfg.reviewThresholds.downgradeTo,
+            downgradeReason: "LOW_CONFIDENCE",
+        };
+    }
+    // Rule 3: low auditor score
+    if (cfg.reviewThresholds.minAuditorScoreForDirectCommit > 0 &&
+        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";
+}
+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");
+        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");
+}
+async function execute(cfg, decision, heals, branchInfo, ctx) {
+    const result = {
+        effective: decision.effective,
+        prUrl: null,
+        branchPushed: null,
+        errors: [],
+    };
+    if (decision.effective === "readOnly") {
+        console.log(`[Sela PR] 🛡️  readOnly — no git operations performed.`);
+        if (ctx.reportHtmlPath) {
+            console.log(`[Sela PR]    Report artifact: ${ctx.reportHtmlPath}`);
+        }
+        return result;
+    }
+    if (heals.length === 0) {
+        console.log(`[Sela PR] No HEALED events — skipping git operations.`);
+        return result;
+    }
+    if (!gitAvailable(ctx.cwd)) {
+        result.errors.push("git CLI not available");
+        console.warn(`[Sela PR] ⚠️  git CLI not available — skipping.`);
+        return result;
+    }
+    if (isDetachedHead(ctx.cwd)) {
+        result.errors.push("detached HEAD");
+        console.warn(`[Sela PR] ⚠️  Detached HEAD — skipping git operations.`);
+        return result;
+    }
+    // ── Stage all healed files (relative paths from event records) ────
+    const filesToStage = Array.from(new Set(heals.map((h) => h.sourceFile).filter((f) => f && f.length > 0)));
+    if (filesToStage.length === 0) {
+        result.errors.push("no files to stage");
+        console.warn(`[Sela PR] ⚠️  No file paths in HEALED events — skipping.`);
+        return result;
+    }
+    // Render title — use first heal as representative
+    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);
+    // ── directCommit ────────────────────────────────────────────────
+    if (decision.effective === "directCommit") {
+        for (const f of filesToStage) {
+            const add = sh(`git add "${f}"`, ctx.cwd);
+            if (!add.ok)
+                result.errors.push(`git add ${f}: ${add.stderr}`);
+        }
+        const commit = sh(`git commit -m ${shellQuote(title)}`, ctx.cwd);
+        if (!commit.ok) {
+            result.errors.push(`git commit: ${commit.stderr}`);
+            console.warn(`[Sela PR] ⚠️  git commit failed: ${commit.stderr}`);
+            return result;
+        }
+        console.log(`[Sela PR] ✅ Direct commit on '${branchInfo.branch}': ${title}`);
+        const push = sh(`git push`, ctx.cwd);
+        if (!push.ok) {
+            result.errors.push(`git push: ${push.stderr}`);
+            console.warn(`[Sela PR] ⚠️  git push failed: ${push.stderr}`);
+            return result;
+        }
+        console.log(`[Sela PR] 🚀 Pushed to '${branchInfo.branch}'`);
+        return result;
+    }
+    // ── pr / draftPR ────────────────────────────────────────────────
+    if (decision.effective === "pr" || decision.effective === "draftPR") {
+        if (!ghAvailable(ctx.cwd)) {
+            result.errors.push("gh CLI not available");
+            console.warn(`[Sela PR] ⚠️  gh CLI not installed — cannot open PR. Run \`gh auth login\` after install.`);
+            return result;
+        }
+        const id = String(Date.now());
+        const branchName = render(cfg.branchNameTemplate, { id, timestamp: id });
+        const checkout = sh(`git checkout -b ${branchName}`, ctx.cwd);
+        if (!checkout.ok) {
+            result.errors.push(`git checkout: ${checkout.stderr}`);
+            console.warn(`[Sela PR] ⚠️  Could not create branch '${branchName}': ${checkout.stderr}`);
+            return result;
+        }
+        for (const f of filesToStage) {
+            const add = sh(`git add "${f}"`, ctx.cwd);
+            if (!add.ok)
+                result.errors.push(`git add ${f}: ${add.stderr}`);
+        }
+        const commit = sh(`git commit -m ${shellQuote(title)}`, ctx.cwd);
+        if (!commit.ok) {
+            result.errors.push(`git commit: ${commit.stderr}`);
+            console.warn(`[Sela PR] ⚠️  git commit failed: ${commit.stderr}`);
+            return result;
+        }
+        const push = sh(`git push -u origin ${branchName}`, ctx.cwd);
+        if (!push.ok) {
+            result.errors.push(`git push: ${push.stderr}`);
+            console.warn(`[Sela PR] ⚠️  git push failed: ${push.stderr}`);
+            return result;
+        }
+        result.branchPushed = branchName;
+        // Write body to a temp file to avoid shell-escaping headaches
+        const bodyFile = path.join(ctx.cwd, `.sela-pr-body-${id}.md`);
+        fs.writeFileSync(bodyFile, body, "utf8");
+        const labelFlag = cfg.labels.length > 0
+            ? cfg.labels.map((l) => `--label ${shellQuote(l)}`).join(" ")
+            : "";
+        const draftFlag = decision.effective === "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}`);
+            console.warn(`[Sela PR] ⚠️  gh pr create failed: ${pr.stderr}`);
+            return result;
+        }
+        result.prUrl = pr.stdout.trim();
+        console.log(`[Sela PR] ✅ ${decision.effective === "draftPR" ? "Draft PR" : "PR"} opened: ${result.prUrl}`);
+        return result;
+    }
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════════
+// BUG-DETECTED HANDLING
+// ═══════════════════════════════════════════════════════════════════
+async function handleBugDetected(action, events, branchInfo, ctx) {
+    if (events.length === 0)
+        return;
+    console.warn(`\n[Sela Protection] ⚠️  ${events.length} potential regression(s) detected — auto-fix blocked.`);
+    for (const e of events) {
+        console.warn(`  • ${e.sourceFile}:${e.sourceLine} — ${e.reason} (auditor: ${e.auditor?.verdict ?? "n/a"})`);
+    }
+    if (action === "failCI") {
+        console.warn(`[Sela Protection] 🔴 onBugDetected='failCI' — setting process.exitCode = 1`);
+        process.exitCode = 1;
+        return;
+    }
+    if (action === "createIssue") {
+        if (!ghAvailable(ctx.cwd)) {
+            console.warn(`[Sela 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) {
+                console.warn(`[Sela Protection] ⚠️  gh issue create failed: ${r.stderr}`);
+            }
+            else {
+                console.log(`[Sela Protection] 📝 Issue created: ${r.stdout.trim()}`);
+            }
+        }
+        return;
+    }
+    if (action === "labelOnly") {
+        if (!ghAvailable(ctx.cwd)) {
+            console.warn(`[Sela Protection] ⚠️  gh CLI unavailable — cannot label PR.`);
+            return;
+        }
+        if (!branchInfo.isPR || !branchInfo.prNumber) {
+            console.warn(`[Sela 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) {
+            console.warn(`[Sela 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) {
+            console.warn(`[Sela Protection] ⚠️  gh pr comment failed: ${commentRes.stderr}`);
+        }
+        else {
+            console.log(`[Sela 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, "'\\''")}'`;
+}

package/dist/services/SnapshotService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SnapshotService.d.ts","sourceRoot":"","sources":["../../src/services/SnapshotService.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EACL,eAAe,EACf,iBAAiB,EAElB,MAAM,UAAU,CAAC;AAElB,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAS;;IASlB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAwBpD,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAoRpC,OAAO,CAAC,WAAW;CAsBpB"}
+{"version":3,"file":"SnapshotService.d.ts","sourceRoot":"","sources":["../../src/services/SnapshotService.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAkB,MAAM,UAAU,CAAC;AAE9E,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAS;;IASlB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAsBpD,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAoRpC,OAAO,CAAC,WAAW;CAsBpB"}

package/dist/services/SnapshotService.js

@@ -50,10 +50,10 @@ class SnapshotService {
         const filePath = path.join(this.baseDir, `${key}.json`);
         try {
             fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
-            console.log(`[Fixwright] 📸 Snapshot saved: ${key}.json`);
+            console.log(`[Sela] 📸 Snapshot saved: ${key}.json`);
         }
         catch (err) {
-            console.error(`[Fixwright] ❌ Failed to save snapshot:`, err);
+            console.error(`[Sela] ❌ Failed to save snapshot:`, err);
         }
     }
     async load(key) {
@@ -163,8 +163,8 @@ class SnapshotService {
                 }
                 else if (cs.pointerEvents === "none") {
                     // Child exception: ghost only if no immediate child re-enables pointer events
-                    const hasInteractableChild = Array.from(el.children).some((child) => window.getComputedStyle(child).pointerEvents !==
-                        "none");
+                    const hasInteractableChild = Array.from(el.children).some((child) => window.getComputedStyle(child)
+                        .pointerEvents !== "none");
                     if (!hasInteractableChild) {
                         isGhost = true;
                         ghostReason = "G4_POINTER_EVENTS_NONE";
@@ -237,8 +237,7 @@ class SnapshotService {
                     let sib = el.previousElementSibling;
                     while (sib) {
                         const sibCs = window.getComputedStyle(sib);
-                        if (sibCs.display !== "none" &&
-                            sibCs.visibility !== "hidden") {
+                        if (sibCs.display !== "none" && sibCs.visibility !== "hidden") {
                             const t = (sib.textContent || "").trim();
                             if (t && t.length < 80) {
                                 closestLabel = t;
@@ -314,7 +313,7 @@ class SnapshotService {
             };
         }
         catch (err) {
-            console.debug(`[Fixwright] 🧬 captureElement skipped for "${selector}": ${err.message}`);
+            console.debug(`[Sela] 🧬 captureElement skipped for "${selector}": ${err.message}`);
             return null;
         }
     }
@@ -326,7 +325,7 @@ class SnapshotService {
     // the engine decides when to flush.
     // ─────────────────────────────────────────────────────────────
     migrateToV2(v1) {
-        console.log(`[Fixwright] 🔄 Migrating v1 snapshot to v2 schema (key: "${v1.tagName}/${v1.id ?? "no-id"}")`);
+        console.log(`[Sela] 🔄 Migrating v1 snapshot to v2 schema (key: "${v1.tagName}/${v1.id ?? "no-id"}")`);
         return {
             ...v1,
             schemaVersion: 2,

package/dist/services/SourceUpdater.js

@@ -471,7 +471,7 @@ class SourceUpdater {
             if (!contentChange)
                 return;
             console.log(`[SourceUpdater] 🔍 Checking for assertion mismatches...`);
-            console.warn(`\n[Fixwright-Advice] 💡 To fix the assertion at line ${caller.line}, ` +
+            console.warn(`\n[Sela] 💡 To fix the assertion at line ${caller.line}, ` +
                 `change to: .toHaveText("${contentChange.newText}")\n`);
         };
         // ── Strategy 0: Layered Frame Healing ──────────────────────

package/dist/storage/SnapshotManager.js

@@ -15,7 +15,7 @@ class SnapshotManager {
             await promises_1.default.writeFile(filePath, JSON.stringify(data, null, 2));
         }
         catch (error) {
-            console.error(`[Fixwright] Failed to save snapshot: ${error}`);
+            console.error(`[Sela] Failed to save snapshot: ${error}`);
         }
     }
     static async load(filePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sela-core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI self-healing Playwright wrapper — drop-in replacement for @playwright/test",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -55,7 +55,7 @@
     "ts-morph": "^27.0.2"
   },
   "devDependencies": {
-    "@playwright/test": "^1.58.2",
+    "@playwright/test": "^1.60.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^25.6.2",
     "jest": "^30.3.0",