sela-core 1.0.3 → 1.0.5

package/dist/engine/SelaEngine.js

@@ -0,0 +1,726 @@
+"use strict";
+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.SelaEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LLMService_1 = require("../services/LLMService");
+const SnapshotService_1 = require("../services/SnapshotService");
+const DOMUtils_1 = require("../utils/DOMUtils");
+const SourceUpdater_1 = require("../services/SourceUpdater");
+const SafetyGuard_1 = require("../services/SafetyGuard");
+const ConfigLoader_1 = require("../config/ConfigLoader");
+const HealReportService_1 = require("../services/HealReportService");
+const PRAutomationService_1 = require("../services/PRAutomationService");
+class SelaEngine {
+    llmService;
+    snapshotService;
+    safetyGuard;
+    config;
+    dnaBuffer = new Map();
+    healMetaBuffer = new Map();
+    testTitleBuffer = new Map();
+    constructor() {
+        this.config = ConfigLoader_1.ConfigLoader.getInstance();
+        this.llmService = new LLMService_1.LLMService();
+        this.snapshotService = new SnapshotService_1.SnapshotService();
+        this.safetyGuard = new SafetyGuard_1.SafetyGuard(this.config.thresholds);
+    }
+    // ─────────────────────────────────────────────────────────────
+    // healArgument — repairs a wrong action argument (e.g. selectOption)
+    // ─────────────────────────────────────────────────────────────
+    async healArgument(page, selector, action, oldArgument, stableId, filePath, line) {
+        console.log(`[Sela] 🔧 HEALING ARGUMENT for action '${action}': "${oldArgument}"`);
+        try {
+            const { dom } = await DOMUtils_1.DOMUtils.getNeighborhoodDom(page, selector);
+            const neighborhoodDom = dom;
+            const targetIntent = action === "selectOption"
+                ? `ARGUMENT_HEALING: The selectOption argument "${oldArgument}" does not exist.
+Look at the <select> element in the DOM and find all <option> elements inside it.
+Return in 'new_selector' ONLY the TEXT CONTENT of the closest matching <option>.
+For example: if the options are "Male" and "Female" and the old argument was "Man", return "Male".
+CRITICAL: Do NOT return a CSS selector like "#my-select". Return plain text only, exactly as it appears in the option.`
+                : `Fix the broken argument "${oldArgument}" for action "${action}". Return the correct value.`;
+            const aiFix = await this.llmService.getFix({
+                targetIntent,
+                failedSelector: `${selector}::${action}("${oldArgument}")`,
+                previousState: {},
+                currentDom: neighborhoodDom,
+            });
+            if (aiFix?.status === "FIXED" && aiFix.new_selector) {
+                const newArgument = aiFix.new_selector;
+                console.log(`[Sela] 🔧 New argument: "${newArgument}"`);
+                SourceUpdater_1.SourceUpdater.updateArgument({ filePath, line }, action, oldArgument, newArgument);
+                return newArgument;
+            }
+        }
+        catch (error) {
+            console.error(`[Sela] ❌ Argument healing error:`, error.message);
+        }
+        return null;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // heal — repairs a broken selector
+    // ─────────────────────────────────────────────────────────────
+    async heal(page, fullSelector, elementSelectorOnly, stableId, filePath, line, healMode = "action") {
+        console.log(`\n[Sela] 🛠️  HEALING START for: ${stableId}`);
+        // Resolve file path for report purposes (project-relative when possible).
+        const reportFile = this._toReportFile(filePath);
+        const testTitle = this.testTitleBuffer.get(stableId);
+        // Snapshot for report event context (loaded once below, used at all exit paths).
+        let lastKnownStateForReport = null;
+        let aiFixForReport = null;
+        try {
+            // load() now always returns ElementSnapshotV2 (v1 snapshots are
+            // migrated transparently; v2 fields default to safe values).
+            const lastKnownState = await this.snapshotService.load(stableId);
+            lastKnownStateForReport = lastKnownState;
+            // ── Extract v2 DNA context ────────────────────────────────
+            const dnaAncestry = lastKnownState?.ancestry ?? [];
+            const dnaAnchors = lastKnownState?.anchors;
+            console.log(`[Sela] 🔍 Step 2: Extracting neighborhood DOM...`);
+            const { dom: neighborhoodDom, successfulPath } = await DOMUtils_1.DOMUtils.getNeighborhoodDom(page, fullSelector);
+            if (!neighborhoodDom || neighborhoodDom.length === 0) {
+                throw new Error("Failed to extract any DOM context for AI");
+            }
+            console.log(`[Sela] 🔍 Step 2: DOM Extracted (${neighborhoodDom.length} chars) ✅`);
+            const contextHint = successfulPath.length > 0
+                ? `\n\n[CONTEXT HINT]: The provided DOM is extracted from INSIDE this frame path: "${successfulPath.join(" >> ")}". ` +
+                    `If you find the element, your suggested selector should be relative to THIS context.`
+                : "";
+            const oldText = lastKnownState?.text ?? null;
+            const dnaRole = lastKnownState?.role ?? undefined;
+            const intentDescription = lastKnownState
+                ? `The element that was a ${lastKnownState.tagName} with text "${lastKnownState.text}"`
+                : `Element identified by ${stableId}`;
+            const contentChangeInstructions = `
+
+[CONTENT CHANGE DETECTION]:
+If the element's VISIBLE TEXT has changed compared to its previous value${oldText ? ` ("${oldText}")` : ""}, you MUST include a "contentChange" field.
+NOTE: This change will NOT be applied automatically to the source code to prevent masking potential bugs.
+It will only be presented as a suggested fix in the terminal.
+{
+  "contentChange": {
+    "oldText": "<the previous visible text>",
+    "newText": "<the new visible text as it appears in the current DOM>"
+  }
+}
+This is required so that any expect(...).toHaveText("${oldText ?? "..."}") assertions in the test file can be automatically updated to match the new text.
+If the text has NOT changed, omit the "contentChange" field entirely.`;
+            // ── Semantic anchor context hint for the LLM ─────────────────────
+            // When DNA v2 anchor data exists, tell the AI which label and row
+            // key the element was associated with so it can use semantic landmarks
+            // to disambiguate identical controls (e.g. multiple "Edit" buttons).
+            const anchorContextHint = (() => {
+                const anchors = lastKnownState?.anchors;
+                if (!anchors)
+                    return "";
+                const lines = [];
+                if (anchors.closestLabel) {
+                    lines.push(`- Label: "${anchors.closestLabel}" — the UI label or heading associated with this element.`);
+                }
+                if (anchors.rowAnchor) {
+                    lines.push(`- Row key: "${anchors.rowAnchor}" — unique cell text identifying the table row this element belonged to.`);
+                }
+                if (lines.length === 0)
+                    return "";
+                return ("\n\n[ELEMENT SEMANTIC CONTEXT]:\n" +
+                    "The DNA snapshot recorded these semantic landmarks for the element you must find:\n" +
+                    lines.join("\n") +
+                    "\n" +
+                    "Prioritize selectors that preserve these relationships (e.g. filter by row key, then target by label).");
+            })();
+            console.log(`[Sela] 🔍 Step 3: Requesting AI fix from LLM...`);
+            const aiFix = await this.llmService.getFix({
+                targetIntent: intentDescription,
+                failedSelector: fullSelector,
+                previousState: lastKnownState || {},
+                currentDom: neighborhoodDom +
+                    contextHint +
+                    anchorContextHint +
+                    contentChangeInstructions,
+            });
+            aiFixForReport = aiFix;
+            if (aiFix && aiFix.status === "FIXED") {
+                console.log(`[Sela] 🔍 Step 3: AI responded ✅`);
+                // ── Build new selector ────────────────────────────────────
+                const aiSegments = aiFix.segments || [];
+                const newSegmentsFromAI = aiSegments.filter((aiSeg) => !successfulPath.includes(aiSeg.selector));
+                const newFullSelector = [
+                    ...successfulPath,
+                    ...newSegmentsFromAI.map((s) => s.selector),
+                ].join(" >> ");
+                const rawElementSelector = newSegmentsFromAI.map((s) => s.selector).join(" >> ") ||
+                    newFullSelector;
+                const framePrefix = successfulPath.join(" >> ");
+                const elementOnlySelector = framePrefix && rawElementSelector.startsWith(framePrefix + " >> ")
+                    ? rawElementSelector.slice(framePrefix.length + 4)
+                    : rawElementSelector;
+                // ── Step 3.5: Fetch live text (lightweight zero-trust probe) ─
+                const liveText = await this.fetchLiveText(page, elementOnlySelector, successfulPath);
+                const dnaBaselineText = oldText ?? undefined;
+                if (liveText !== null) {
+                    console.log(`[Sela] 🔍 Step 3.5: Live text fetched: "${liveText}"` +
+                        (dnaBaselineText ? ` (DNA baseline: "${dnaBaselineText}")` : ""));
+                }
+                else {
+                    console.log(`[Sela] 🔍 Step 3.5: Live text fetch skipped (element not yet rendered or non-text)`);
+                }
+                // ── Step 3.6: Atomic v2 capture of the candidate element ──
+                // Single page.evaluate() call — collects visibility, ancestry,
+                // and anchors of the healed element for SafetyGuard use.
+                // Returns null on any failure; never blocks the heal.
+                const liveSnapshot = await this.snapshotService.captureElement(page, elementOnlySelector, successfulPath);
+                const liveVisibility = liveSnapshot?.visibility;
+                const liveAncestry = liveSnapshot?.ancestry;
+                const liveAnchors = liveSnapshot?.anchors;
+                if (liveSnapshot) {
+                    const ghostFlag = liveVisibility?.isGhost
+                        ? ` 👻 GHOST(${liveVisibility.ghostReason})`
+                        : "";
+                    const occFlag = liveVisibility?.isOccluded ? " 🫥 OCCLUDED" : "";
+                    console.log(`[Sela] 🔍 Step 3.6: Live v2 capture complete` +
+                        `${ghostFlag}${occFlag} — ancestry depth: ${liveAncestry?.length ?? 0}`);
+                }
+                else {
+                    console.log(`[Sela] 🔍 Step 3.6: Live v2 capture skipped`);
+                }
+                // ── Safety: delegate all go/no-go decisions to SafetyGuard ─
+                const branch = ConfigLoader_1.ConfigLoader.getBranch() ?? undefined;
+                const safetyDecision = await this.safetyGuard.evaluate({ mode: healMode, branch }, {
+                    confidence: aiFix.confidence,
+                    contentChange: aiFix.contentChange,
+                    explanation: aiFix.explanation,
+                    liveText: liveText ?? undefined,
+                    dnaBaselineText,
+                    dnaRole,
+                    // v2 structural context
+                    liveVisibility,
+                    liveAncestry,
+                    liveAnchors,
+                    dnaAncestry,
+                    dnaAnchors,
+                });
+                console.log(`[SafetyGuard] ${safetyDecision.canProceed ? "✅" : "❌"} [${safetyDecision.level}] ${safetyDecision.reason}`);
+                if (!safetyDecision.canProceed) {
+                    if (safetyDecision.level === "BLOCKED" &&
+                        safetyDecision.meta?.auditorVerdict === "SUSPICIOUS") {
+                        const strictness = this.config.thresholds.auditorStrictness;
+                        const conf = safetyDecision.meta.auditorConfidence ?? "?";
+                        const suggestion = strictness === "strict" ? "Balanced" : "Loose";
+                        console.warn(`[Sela] ⚠️  Auditor status: SUSPICIOUS (Confidence: ${conf}%)`);
+                        console.warn(`[Sela] 🚫 Policy: '${strictness}' (Branch: ${branch ?? "unknown"}). Auto-fix blocked.`);
+                        console.warn(`[Sela] 💡 To allow this, change 'auditorStrictness' to '${suggestion}' in sela.config.ts.`);
+                    }
+                    // ── Report: PROTECTED (or BLOCKED non-INCONSISTENT) ─────────
+                    // The auto-fix was blocked. If the auditor verdict is INCONSISTENT
+                    // this is a "Security Win" — a masked regression was caught.
+                    const protectedEvent = {
+                        kind: "PROTECTED",
+                        stableId,
+                        sourceFile: reportFile,
+                        sourceLine: line,
+                        testTitle,
+                        timestamp: new Date().toISOString(),
+                        framePath: successfulPath,
+                        inIframe: successfulPath.length > 0,
+                        inShadowDom: liveSnapshot?.isInShadowDom ?? false,
+                        oldSelector: elementSelectorOnly,
+                        candidateNewSelector: newFullSelector,
+                        reason: safetyDecision.reason,
+                        safetyLevel: safetyDecision.level,
+                        auditor: this._auditorBlockFromDecision(safetyDecision.meta),
+                        aiConfidence: typeof aiFix.confidence === "number" ? aiFix.confidence : 0,
+                        aiExplanation: aiFix.explanation ?? "",
+                        dnaBefore: (0, HealReportService_1.summariseSnapshot)(lastKnownState),
+                        dnaAfter: (0, HealReportService_1.summariseSnapshot)(liveSnapshot ?? null),
+                        contentChange: aiFix.contentChange,
+                    };
+                    HealReportService_1.sharedHealReport.record(protectedEvent);
+                    throw new Error(`[SafetyGuard] ${safetyDecision.level}: ${safetyDecision.reason}`);
+                }
+                // ── Heal-completion score summary ─────────────────────────────────
+                // Emits a single consolidated line showing AI confidence plus the
+                // auditor's structural adjustments (ancestry drift / anchor bonus).
+                const breakdown = safetyDecision.meta?.auditScoreBreakdown;
+                if (breakdown && (breakdown.penalty !== 0 || breakdown.bonus !== 0)) {
+                    const parts = [];
+                    if (breakdown.penalty !== 0)
+                        parts.push(`${breakdown.penalty} ancestry drift`);
+                    if (breakdown.bonus !== 0)
+                        parts.push(`+${breakdown.bonus} anchor match`);
+                    console.log(`[Sela] 📊 Score — AI: ${aiFix.confidence}% | ` +
+                        `Auditor: ${breakdown.adjustedConfidence}% ` +
+                        `(raw ${breakdown.rawConfidence}%, ${parts.join(", ")})`);
+                }
+                console.log(`[Sela] 🚀 Rebuilt Full Runtime Selector (Clean): ${newFullSelector}`);
+                // Snapshot the ENTIRE source file BEFORE the AST mutation.
+                // We don't know which line will actually be mutated until update()
+                // returns (JumpToDef may land on the const-decl line, not the failure
+                // line) — so we keep the pre-image around and slice into it after.
+                const preMutationLines = this._safeReadAllLines(filePath);
+                const updateResult = SourceUpdater_1.SourceUpdater.update({ filePath, line }, elementSelectorOnly, newFullSelector, neighborhoodDom, undefined, fullSelector, aiFix.segments, aiFix.contentChange, aiFix.chainSegments, aiFix.originalChainHint, this.config.updateStrategy, this.config.autoCommit);
+                // Resolve the line that was actually mutated. Order of precedence:
+                //   1. updateResult.lineUpdated  (the strategy's literal write location)
+                //   2. updateResult.definitionSite.line  (semantic JumpToDef target,
+                //      used when the mutation crossed into a const/variable declaration)
+                //   3. line  (the original failure line — last-resort fallback)
+                // For cross-file definitionSite.file, we still read the new line from
+                // the SAME file that was mutated.
+                const defSite = updateResult.definitionSite;
+                const sameFileDef = defSite && defSite.file
+                    ? path.resolve(defSite.file) ===
+                        (SourceUpdater_1.SourceUpdater.resolveFilePath(filePath) ?? "")
+                    : true;
+                const writtenLine = updateResult.lineUpdated ??
+                    (sameFileDef ? defSite?.line : undefined) ??
+                    line;
+                const mutatedFilePath = !sameFileDef && defSite ? defSite.file : filePath;
+                // Old line: PRE-mutation content at the line that ended up being mutated.
+                // If the mutation was cross-file, read the pre-image of THAT file by
+                // recovering it from disk minus our own change (we don't track that —
+                // fall back to current pre-image if same file, else empty string).
+                const oldCodeLine = sameFileDef && preMutationLines.length > 0
+                    ? (preMutationLines[writtenLine - 1] ?? "")
+                    : this._safeReadLine(mutatedFilePath, writtenLine);
+                // New line: POST-mutation content at the same line in the mutated file.
+                const newCodeLine = this._safeReadLine(mutatedFilePath, writtenLine);
+                const canonicalSelector = updateResult.healedLocatorString ?? newFullSelector;
+                console.log(`[Sela] ✅ Canonical selector (disk == runtime): "${canonicalSelector}"`);
+                // Buffer CLI-ready metadata — merged into DNA at commitUpdates() time.
+                // Sanitize filePath: strip any residual "at " stack-trace prefix + whitespace,
+                // then resolve to an absolute path before converting to project-relative form.
+                const match = filePath.match(/at\s+(.*)/i);
+                // 2. אם מצאנו התאמה ניקח אותה, אחרת ניקח את המחרוזת המקורית.
+                // בנוסף, ננקה רווחים וסוגריים (לפעמים נתיבים ב-Stack trace מוקפים בסוגריים).
+                const cleanFilePath = (match ? match[1] : filePath)
+                    .replace(/^\(|\)$/g, "") // מסיר סוגריים אם קיימים ( )
+                    .trim();
+                // 3. הפיכה לנתיב אבסולוטי ואז ליחסי (כמו שעשית, שזה מעולה)
+                const absFilePath = cleanFilePath && path.isAbsolute(cleanFilePath)
+                    ? cleanFilePath
+                    : cleanFilePath
+                        ? path.resolve(process.cwd(), cleanFilePath)
+                        : "";
+                const relativeSourceFile = absFilePath
+                    ? path.relative(process.cwd(), absFilePath)
+                    : "";
+                this.healMetaBuffer.set(stableId, {
+                    selector: canonicalSelector,
+                    sourceFile: relativeSourceFile,
+                    sourceLine: line,
+                    originalSelector: elementSelectorOnly,
+                    healedSelector: canonicalSelector,
+                    lastHealed: new Date().toISOString(),
+                    status: "healed",
+                    definitionSite: updateResult.definitionSite,
+                    blastRadius: updateResult.blastRadius,
+                });
+                // ── Report: HEALED event ───────────────────────────────────────
+                const healedEvent = {
+                    kind: "HEALED",
+                    stableId,
+                    sourceFile: relativeSourceFile || reportFile,
+                    sourceLine: line,
+                    testTitle,
+                    timestamp: new Date().toISOString(),
+                    framePath: successfulPath,
+                    inIframe: successfulPath.length > 0,
+                    inShadowDom: liveSnapshot?.isInShadowDom ?? false,
+                    oldSelector: elementSelectorOnly,
+                    newSelector: canonicalSelector,
+                    oldCodeLine,
+                    newCodeLine,
+                    newLineNumber: writtenLine,
+                    aiConfidence: typeof aiFix.confidence === "number" ? aiFix.confidence : 0,
+                    aiExplanation: aiFix.explanation ?? "",
+                    aiAlternatives: this._buildAlternatives(aiFix.chainSegments, aiFix.segments),
+                    reasoningSteps: this._buildReasoningSteps({
+                        aiFix,
+                        dnaText: lastKnownState?.text ?? null,
+                        dnaTag: lastKnownState?.tagName ?? null,
+                        safetyLevel: safetyDecision.level,
+                        strategy: updateResult.reason || "ast-update",
+                        writtenLine,
+                        blastRadius: updateResult.blastRadius,
+                        successfulPath,
+                    }),
+                    auditor: this._auditorBlockFromDecision(safetyDecision.meta),
+                    dnaBefore: (0, HealReportService_1.summariseSnapshot)(lastKnownState),
+                    dnaAfter: (0, HealReportService_1.summariseSnapshot)(liveSnapshot ?? null),
+                    diffStrategy: updateResult.reason || "ast-update",
+                    blastRadius: updateResult.blastRadius,
+                    definitionSite: updateResult.definitionSite,
+                    contentChange: aiFix.contentChange,
+                };
+                HealReportService_1.sharedHealReport.record(healedEvent);
+                return canonicalSelector;
+            }
+            // AI did not return FIXED — record as FAILED.
+            const failedEvent = {
+                kind: "FAILED",
+                stableId,
+                sourceFile: reportFile,
+                sourceLine: line,
+                testTitle,
+                timestamp: new Date().toISOString(),
+                framePath: [],
+                inIframe: false,
+                inShadowDom: lastKnownStateForReport?.isInShadowDom ?? false,
+                oldSelector: elementSelectorOnly,
+                reason: "AI could not provide a fix (NOT_FOUND)",
+                aiConfidence: aiFix?.confidence,
+                aiExplanation: aiFix?.explanation,
+                dnaBefore: (0, HealReportService_1.summariseSnapshot)(lastKnownStateForReport),
+            };
+            HealReportService_1.sharedHealReport.record(failedEvent);
+            throw new Error("AI could not provide a fix");
+        }
+        catch (error) {
+            console.error(`[Sela] ❌ Healing Failure:`, error.message);
+            // Avoid double-recording when a SafetyGuard PROTECTED event was already pushed.
+            const isSafetyBlock = typeof error?.message === "string" && error.message.includes("[SafetyGuard]");
+            const isNotFoundAlreadyRecorded = typeof error?.message === "string" && error.message === "AI could not provide a fix";
+            if (!isSafetyBlock && !isNotFoundAlreadyRecorded) {
+                const failedEvent = {
+                    kind: "FAILED",
+                    stableId,
+                    sourceFile: reportFile,
+                    sourceLine: line,
+                    testTitle,
+                    timestamp: new Date().toISOString(),
+                    framePath: [],
+                    inIframe: false,
+                    inShadowDom: lastKnownStateForReport?.isInShadowDom ?? false,
+                    oldSelector: elementSelectorOnly,
+                    reason: error?.message ?? "Unknown heal failure",
+                    aiConfidence: aiFixForReport?.confidence,
+                    aiExplanation: aiFixForReport?.explanation,
+                    dnaBefore: (0, HealReportService_1.summariseSnapshot)(lastKnownStateForReport),
+                };
+                HealReportService_1.sharedHealReport.record(failedEvent);
+            }
+            throw error;
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Report helpers
+    // ─────────────────────────────────────────────────────────────
+    _toReportFile(filePath) {
+        if (!filePath)
+            return "";
+        const match = filePath.match(/at\s+(.*)/i);
+        const cleaned = (match ? match[1] : filePath).replace(/^\(|\)$/g, "").trim();
+        const abs = path.isAbsolute(cleaned) ? cleaned : path.resolve(process.cwd(), cleaned);
+        return path.relative(process.cwd(), abs) || abs;
+    }
+    _safeReadLine(filePath, lineNumber) {
+        try {
+            const cleaned = this._toReportFile(filePath);
+            const abs = path.isAbsolute(cleaned) ? cleaned : path.resolve(process.cwd(), cleaned);
+            if (!fs.existsSync(abs))
+                return "";
+            const lines = fs.readFileSync(abs, "utf8").split(/\r?\n/);
+            const idx = Math.max(0, Math.min(lines.length - 1, lineNumber - 1));
+            return lines[idx] ?? "";
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Snapshot the entire file as a string[] of lines.  Returns an empty array
+     * if the file is missing or unreadable.  Used to preserve the PRE-mutation
+     * source so the diff in HealedEvent reflects the line that was actually
+     * mutated (which may differ from the failure line when JumpToDef lands on
+     * a const declaration above).
+     */
+    _safeReadAllLines(filePath) {
+        try {
+            const cleaned = this._toReportFile(filePath);
+            const abs = path.isAbsolute(cleaned) ? cleaned : path.resolve(process.cwd(), cleaned);
+            if (!fs.existsSync(abs))
+                return [];
+            return fs.readFileSync(abs, "utf8").split(/\r?\n/);
+        }
+        catch {
+            return [];
+        }
+    }
+    _auditorBlockFromDecision(meta) {
+        if (!meta || !meta.auditorVerdict)
+            return null;
+        return {
+            verdict: meta.auditorVerdict,
+            confidence: meta.auditorConfidence ?? 0,
+            reason: meta.auditScoreBreakdown
+                ? `Adjusted ${meta.auditScoreBreakdown.rawConfidence}% → ${meta.auditScoreBreakdown.adjustedConfidence}% (penalty ${meta.auditScoreBreakdown.penalty}, bonus +${meta.auditScoreBreakdown.bonus}).`
+                : "Auditor verdict recorded by SafetyGuard.",
+            inversionType: null,
+            rawConfidence: meta.auditScoreBreakdown?.rawConfidence,
+            penalty: meta.auditScoreBreakdown?.penalty,
+            bonus: meta.auditScoreBreakdown?.bonus,
+        };
+    }
+    _buildAlternatives(chainSegments, segments) {
+        const out = [];
+        if (chainSegments && chainSegments.length) {
+            for (const seg of chainSegments) {
+                switch (seg.type) {
+                    case "locator":
+                        out.push(`locator(${JSON.stringify(seg.selector)})`);
+                        break;
+                    case "frameLocator":
+                        out.push(`frameLocator(${JSON.stringify(seg.selector)})`);
+                        break;
+                    case "getByRole":
+                        out.push(`getByRole(${JSON.stringify(seg.role)}${seg.name ? ", { name: " + JSON.stringify(seg.name) + (seg.exact ? ", exact: true" : "") + " }" : ""})`);
+                        break;
+                    case "getByLabel":
+                        out.push(`getByLabel(${JSON.stringify(seg.text)}${seg.exact ? ", { exact: true }" : ""})`);
+                        break;
+                    case "getByText":
+                        out.push(`getByText(${JSON.stringify(seg.text)}${seg.exact ? ", { exact: true }" : ""})`);
+                        break;
+                    case "getByPlaceholder":
+                        out.push(`getByPlaceholder(${JSON.stringify(seg.text)})`);
+                        break;
+                    case "getByTestId":
+                        out.push(`getByTestId(${JSON.stringify(seg.testId)})`);
+                        break;
+                    case "getByAltText":
+                        out.push(`getByAltText(${JSON.stringify(seg.text)})`);
+                        break;
+                    case "getByTitle":
+                        out.push(`getByTitle(${JSON.stringify(seg.text)})`);
+                        break;
+                    case "filter":
+                        out.push(`filter(${JSON.stringify(seg)})`);
+                        break;
+                    case "first":
+                        out.push("first()");
+                        break;
+                    case "last":
+                        out.push("last()");
+                        break;
+                    case "nth":
+                        out.push(`nth(${seg.index})`);
+                        break;
+                }
+            }
+        }
+        if (segments && segments.length) {
+            out.push(segments.map((s) => s.selector).join(" >> "));
+        }
+        return Array.from(new Set(out)).slice(0, 8);
+    }
+    _buildReasoningSteps(ctx) {
+        const steps = [];
+        if (ctx.dnaTag || ctx.dnaText) {
+            steps.push(`Recovered DNA baseline — previously a <${ctx.dnaTag ?? "?"}>` +
+                (ctx.dnaText ? ` with text "${ctx.dnaText}"` : "") + ".");
+        }
+        if (ctx.successfulPath.length > 0) {
+            steps.push(`Resolved DOM context inside ${ctx.successfulPath.length} nested frame(s): ${ctx.successfulPath.join(" >> ")}.`);
+        }
+        const firstSeg = ctx.aiFix.chainSegments?.[0];
+        if (firstSeg) {
+            steps.push(`AI preserved the ${firstSeg.type} pattern — semantic locator over raw CSS path.`);
+        }
+        if (ctx.aiFix.explanation) {
+            steps.push(`AI reasoning: ${ctx.aiFix.explanation}`);
+        }
+        steps.push(`Confidence: ${ctx.aiFix.confidence}%.`);
+        if (ctx.aiFix.contentChange) {
+            steps.push(`Detected content drift: "${ctx.aiFix.contentChange.oldText}" → "${ctx.aiFix.contentChange.newText}".`);
+        }
+        steps.push(`SafetyGuard verdict: ${ctx.safetyLevel} — change cleared for write.`);
+        steps.push(`Source updated via ${ctx.strategy} at line ${ctx.writtenLine}.`);
+        if (ctx.blastRadius != null && ctx.blastRadius > 0) {
+            steps.push(`Blast radius: ${ctx.blastRadius} dependent test reference(s) inherited the fix.`);
+        }
+        return steps;
+    }
+    preloadTestTitle(stableId, testTitle) {
+        this.testTitleBuffer.set(stableId, testTitle);
+    }
+    async saveSnapshot(stableId, data) {
+        this.dnaBuffer.set(stableId, data);
+    }
+    async commitUpdates() {
+        if (this.dnaBuffer.size > 0) {
+            for (const [key, dna] of this.dnaBuffer.entries()) {
+                const meta = this.healMetaBuffer.get(key);
+                const toSave = meta ? { ...dna, ...meta } : dna;
+                await this.snapshotService.save(key, toSave);
+            }
+            this.dnaBuffer.clear();
+            this.healMetaBuffer.clear();
+            this.testTitleBuffer.clear();
+            SourceUpdater_1.SourceUpdater.flushAdvisories();
+        }
+        // ── Sela Insights — render the transparent healing report ───────
+        let reportHtmlPath = null;
+        const healedEvents = HealReportService_1.sharedHealReport.getHealedEvents();
+        const protectedEvents = HealReportService_1.sharedHealReport.getProtectedEvents();
+        if (HealReportService_1.sharedHealReport.hasContent()) {
+            try {
+                reportHtmlPath = HealReportService_1.sharedHealReport.flushToDisk(process.cwd());
+                if (reportHtmlPath) {
+                    console.log(`\n[Sela] 📄 Insights report written: ${path.relative(process.cwd(), reportHtmlPath)}`);
+                    console.log(`[Sela]    Open with:  npx sela show-report`);
+                }
+            }
+            catch (err) {
+                console.warn(`[Sela] ⚠️  Failed to write insights report: ${err.message}`);
+            }
+        }
+        // ── PR Automation — batched git-flow at session end ─────────────
+        if (this.config.prAutomation.enabled) {
+            try {
+                const branchInfo = (0, PRAutomationService_1.detectBranch)(process.cwd());
+                const decision = (0, PRAutomationService_1.decideEffectiveStrategy)(this.config.prAutomation, branchInfo.branch, healedEvents);
+                if (decision.downgradeReason) {
+                    console.warn(`[Sela PR] ⚠️  Strategy downgraded: '${decision.configured}' → '${decision.effective}' ` +
+                        `(reason: ${decision.downgradeReason}, ` +
+                        `minAI: ${decision.minAiConfidence}%, minAuditor: ${decision.minAuditorConfidence}%)`);
+                }
+                else {
+                    console.log(`[Sela PR] 🎯 Effective strategy: '${decision.effective}' on branch '${branchInfo.branch ?? "unknown"}'`);
+                }
+                const ctx = { cwd: process.cwd(), reportHtmlPath };
+                await (0, PRAutomationService_1.execute)(this.config.prAutomation, decision, healedEvents, branchInfo, ctx);
+                await (0, PRAutomationService_1.handleBugDetected)(this.config.prAutomation.onBugDetected, protectedEvents, branchInfo, ctx);
+            }
+            catch (err) {
+                console.warn(`[Sela PR] ⚠️  PR automation step failed: ${err.message}`);
+            }
+        }
+        // Clear the report buffer last so any downstream consumers (e.g. test
+        // re-runs in the same process) start fresh on the next session.
+        if (HealReportService_1.sharedHealReport.hasContent()) {
+            HealReportService_1.sharedHealReport.clear();
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // fetchLiveText — frame-aware innerText fetch (zero-trust probe)
+    //
+    // Navigates the frame chain encoded in successfulPath, then calls
+    // .first().innerText() on the element-only selector.  Uses a short
+    // 1.5 s timeout so it never adds meaningful latency.  Returns null
+    // on ANY failure — the caller must treat null as "no data" and skip
+    // live verification rather than blocking the heal.
+    // ─────────────────────────────────────────────────────────────
+    async fetchLiveText(page, elementOnlySelector, framePath) {
+        try {
+            let ctx = page;
+            for (const frameSel of framePath) {
+                ctx = ctx.frameLocator(frameSel);
+            }
+            const text = await ctx
+                .locator(elementOnlySelector)
+                .first()
+                .innerText({ timeout: 1500 });
+            return text.trim().length > 0 ? text.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    _rebuildSelectorWithFrames(fullSelector, elementSelectorOnly, aiNewSelector) {
+        const fullParts = fullSelector.split(" >> ").map((s) => s.trim());
+        const elementParts = elementSelectorOnly.split(" >> ").map((s) => s.trim());
+        const aiParts = aiNewSelector.split(" >> ").map((s) => s.trim());
+        const frameParts = fullParts.slice(0, fullParts.length - elementParts.length);
+        if (frameParts.length === 0)
+            return aiNewSelector;
+        const aiHasFrameSegments = aiParts.some((p) => p.includes("-frame") ||
+            p === "iframe" ||
+            p === "frame" ||
+            p.includes("frame-"));
+        if (aiHasFrameSegments) {
+            console.log(`[Sela] 🔗 AI returned full frame path — using directly: ${aiNewSelector}`);
+            return aiNewSelector;
+        }
+        return [...frameParts, ...aiParts].join(" >> ");
+    }
+    getAllFiles(dirPath, arrayOfFiles = []) {
+        const files = fs.readdirSync(dirPath);
+        const ignoreList = [
+            "node_modules",
+            ".git",
+            "fixwright-snapshots",
+            "dist",
+            "test-results",
+            "tests/reset-demo.ts",
+        ];
+        files.forEach((file) => {
+            const fullPath = path.join(dirPath, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+                if (!ignoreList.includes(file))
+                    this.getAllFiles(fullPath, arrayOfFiles);
+            }
+            else if (file.endsWith(".ts") || file.endsWith(".js")) {
+                arrayOfFiles.push(fullPath);
+            }
+        });
+        return arrayOfFiles;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // captureSuccessfulElement — capture and buffer a v2 DNA snapshot.
+    //
+    // Replaces the previous DOMUtils.getElementDNA() path with a single
+    // captureElement() call that collects all v2 metrics atomically.
+    // ─────────────────────────────────────────────────────────────
+    async captureSuccessfulElement(page, selector, stableId) {
+        try {
+            const snapshot = await this.snapshotService.captureElement(page, selector);
+            if (snapshot) {
+                const testTitle = this.testTitleBuffer.get(stableId);
+                const enriched = {
+                    ...snapshot,
+                    selector,
+                    ...(testTitle ? { testTitle } : {}),
+                };
+                this.dnaBuffer.set(stableId, enriched);
+                console.log(`[Sela] 🧬 DNA v2 captured for: ${stableId}`);
+            }
+        }
+        catch (error) {
+            console.debug(`[Sela] 🧬 DNA capture skipped: ${error.message}`);
+        }
+    }
+}
+exports.SelaEngine = SelaEngine;