sela-core 1.0.0

package/dist/services/IntentAuditor.js

@@ -0,0 +1,302 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentAuditor = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+// ═══════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════
+const FALLBACK_VERDICT = {
+    verdict: "SUSPICIOUS",
+    confidence: 0,
+    reason: "Auditor unavailable — defaulting to cautious SUSPICIOUS verdict",
+    inversionType: null,
+};
+// Ancestry drift penalties (spec §2.1).
+// Applied as negative adjustments to the LLM's confidence score.
+// Maximum combined penalty: −30 pts.
+const DRIFT_PENALTIES = [
+    { full: -20, partial: -10 }, // depth 1 — direct parent
+    { full: -10, partial: -5 }, // depth 2 — grandparent
+];
+// Anchor bonuses: positive-only (spec §3.3).
+// closestLabel exact match:  +10 pts
+// rowAnchor exact match:      +5 pts
+// Maximum combined bonus:    +15 pts
+const ANCHOR_BONUS_LABEL = 10;
+const ANCHOR_BONUS_ROW = 5;
+const SYSTEM_PROMPT = `You are a semantic intent auditor for a self-healing test automation system.
+
+Your job: given a BEFORE text (DNA baseline) and an AFTER text (live element), decide whether the element's semantic intent is consistent, inconsistent, or suspicious.
+
+You must respond with ONLY a JSON object. No prose, no markdown, no explanation outside the JSON.
+
+VERDICT DEFINITIONS:
+- CONSISTENT: The semantic intent is preserved. The element represents the same concept, state, or action. Minor wording, phrasing, or language differences are acceptable (e.g. "Submit" → "Send", "Username" → "Email address", "Connexion" → "Login"). Small quantitative changes that are not inversions are acceptable (e.g. "3 items" → "4 items").
+- INCONSISTENT: The semantic intent has inverted or fundamentally changed. The element now represents an opposite or unrelated concept. Examples: "Success" → "Error", "Enabled" → "Disabled", "Login" → "Logout", "Confirm" → "Cancel", "Add" → "Remove".
+- SUSPICIOUS: Cannot determine with confidence. The change is ambiguous, the texts are too short to judge, or the relationship is unclear. Err toward SUSPICIOUS when unsure.
+
+INVERSION TYPES (populate when INCONSISTENT, null otherwise):
+- "polarity": Boolean/state opposites (enabled/disabled, on/off, true/false, success/failure)
+- "state": Workflow or lifecycle state inversions (login/logout, open/closed, connected/disconnected)
+- "quantitative": Numeric inversions that suggest logic change (not just count changes)
+- "identity": Fundamentally different concept (e.g. "Delete" button became "Save" button)
+
+RULES:
+1. Language is irrelevant. "Connexion" and "Login" are CONSISTENT.
+2. Casing is irrelevant. "SUBMIT" and "submit" are CONSISTENT.
+3. Minor reformatting is irrelevant. "Save Changes" and "Save" are CONSISTENT.
+4. Role/aria context matters. A button that was "Submit" becoming "Cancel" is INCONSISTENT (identity inversion).
+5. When both texts are very short (3 chars or less) and differ, prefer SUSPICIOUS unless an obvious opposite pair.
+6. In "assertion" mode, be stricter — lean toward SUSPICIOUS or INCONSISTENT when the change is ambiguous.
+7. In "action" mode, be more lenient — lean toward CONSISTENT when the change looks like a UI refactor.
+
+RESPONSE FORMAT (strict JSON, no other text):
+{
+  "verdict": "CONSISTENT" | "INCONSISTENT" | "SUSPICIOUS",
+  "confidence": <integer 0-100>,
+  "reason": "<one sentence explaining the verdict>",
+  "inversionType": "polarity" | "quantitative" | "state" | "identity" | null
+}`;
+// ═══════════════════════════════════════════════════════════════════
+// IntentAuditor
+// ═══════════════════════════════════════════════════════════════════
+class IntentAuditor {
+    anthropic;
+    disabled;
+    constructor() {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            console.warn("[IntentAuditor] ANTHROPIC_API_KEY not set — auditor disabled, will return SUSPICIOUS for all audited heals");
+            this.anthropic = null;
+            this.disabled = true;
+        }
+        else {
+            this.anthropic = new sdk_1.default({ apiKey });
+            this.disabled = false;
+        }
+    }
+    async auditIntent(req) {
+        if (this.disabled || !this.anthropic) {
+            return { ...FALLBACK_VERDICT };
+        }
+        const userMessage = [
+            `BEFORE (DNA baseline): "${req.dnaText}"`,
+            req.dnaRole ? `BEFORE role: ${req.dnaRole}` : null,
+            `AFTER (live text):     "${req.liveText}"`,
+            req.liveRole ? `AFTER role:  ${req.liveRole}` : null,
+            `Heal mode: ${req.healMode}`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        try {
+            const response = await this.anthropic.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 256,
+                temperature: 0.1,
+                system: SYSTEM_PROMPT,
+                messages: [{ role: "user", content: userMessage }],
+            });
+            const raw = response.content[0].type === "text" ? response.content[0].text : "";
+            // parseVerdict returns the raw LLM verdict without the low-confidence
+            // downgrade so that scoring adjustments below are applied first.
+            const rawVerdict = this.parseVerdict(raw);
+            // ── Structural scoring ────────────────────────────────────────
+            // Apply ancestry drift penalty and anchor bonus to the LLM's raw
+            // confidence.  The semantic verdict category (CONSISTENT / SUSPICIOUS /
+            // INCONSISTENT) is never changed by scoring — only the confidence value.
+            // The low-confidence CONSISTENT→SUSPICIOUS downgrade is re-evaluated
+            // after scoring so the adjusted value is used for the threshold.
+            const penalty = this.computeAncestryPenalty(req.dnaAncestry ?? [], req.liveAncestry ?? []);
+            const bonus = this.computeAnchorBonus(req.dnaAnchors, req.liveAnchors);
+            const scoreAdjustment = penalty + bonus;
+            let finalVerdict;
+            if (scoreAdjustment !== 0) {
+                const adjConf = Math.max(0, Math.min(100, rawVerdict.confidence + scoreAdjustment));
+                const parts = [];
+                if (penalty !== 0)
+                    parts.push(`drift ${penalty}`);
+                if (bonus !== 0)
+                    parts.push(`anchor +${bonus}`);
+                console.log(`[IntentAuditor] 📊 Confidence: ${rawVerdict.confidence}% → ${adjConf}% (${parts.join(", ")})`);
+                // Re-apply low-confidence CONSISTENT downgrade with the adjusted value.
+                // The raw check in parseVerdict used the pre-adjustment confidence; a
+                // penalty may push a borderline CONSISTENT below the 50% threshold.
+                const scoring = { rawConfidence: rawVerdict.confidence, penalty, bonus };
+                if (rawVerdict.verdict === "CONSISTENT" && adjConf < 50) {
+                    finalVerdict = {
+                        verdict: "SUSPICIOUS",
+                        confidence: adjConf,
+                        reason: `Low-confidence CONSISTENT downgraded after drift/anchor scoring: ${rawVerdict.reason}`,
+                        inversionType: null,
+                        scoreBreakdown: scoring,
+                    };
+                    console.log(`[IntentAuditor] CONSISTENT→SUSPICIOUS after scoring (${rawVerdict.confidence}%→${adjConf}%)`);
+                }
+                else {
+                    finalVerdict = { ...rawVerdict, confidence: adjConf, scoreBreakdown: scoring };
+                }
+            }
+            else {
+                finalVerdict = rawVerdict;
+            }
+            console.log(`[IntentAuditor] verdict=${finalVerdict.verdict} (${finalVerdict.confidence}%) — ${finalVerdict.reason}`);
+            return finalVerdict;
+        }
+        catch (err) {
+            console.warn(`[IntentAuditor] Warning: Auditor call failed: ${err.message} — returning SUSPICIOUS`);
+            return { ...FALLBACK_VERDICT, reason: `Auditor call failed: ${err.message}` };
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // computeAncestryPenalty — DNA v2 Ancestry Drift  (spec §2)
+    //
+    // Compares at most 2 ancestor depths between the DNA baseline and
+    // the live candidate.  Returns a value in [−30, 0]; 0 = no drift.
+    //
+    // Empty dnaPath → 0 penalty (v1 migrated snapshot has no data).
+    // livePath shorter than dnaPath → compare up to min length (§2.5).
+    //
+    // Penalty table (§2.1):
+    //   depth 1  full mismatch  −20 pts  partial mismatch  −10 pts
+    //   depth 2  full mismatch  −10 pts  partial mismatch  −5 pts
+    //
+    // Full mismatch  = tags differ
+    // Partial mismatch = same tag, fingerprint differs (id or classes)
+    // ─────────────────────────────────────────────────────────────
+    computeAncestryPenalty(dnaPath, livePath) {
+        if (dnaPath.length === 0)
+            return 0; // v1 migrated snapshot — skip
+        let totalPenalty = 0;
+        const maxDepth = Math.min(dnaPath.length, livePath.length, 2);
+        for (let i = 0; i < maxDepth; i++) {
+            const dna = dnaPath[i];
+            const live = livePath[i];
+            const { full, partial } = DRIFT_PENALTIES[i];
+            if (dna.fingerprint === live.fingerprint) {
+                continue; // exact match, no penalty
+            }
+            const depthLabel = i === 0 ? "depth-1 (parent)" : "depth-2 (grandparent)";
+            if (dna.tag !== live.tag) {
+                totalPenalty += full;
+                console.log(`[IntentAuditor] 🏗️  Ancestry drift ${full} pts — ${depthLabel}: ` +
+                    `tag mismatch (${dna.fingerprint} → ${live.fingerprint})`);
+            }
+            else {
+                totalPenalty += partial;
+                console.log(`[IntentAuditor] 🏗️  Ancestry drift ${partial} pts — ${depthLabel}: ` +
+                    `same tag, id/class changed (${dna.fingerprint} → ${live.fingerprint})`);
+            }
+        }
+        return totalPenalty;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // computeAnchorBonus — DNA v2 Anchor Confirmation  (spec §3.3)
+    //
+    // Anchors only provide positive confirmation — no penalty for
+    // mismatch.  Returns a value in [0, +15].
+    //
+    // closestLabel exact match (case-insensitive):  +10 pts
+    // rowAnchor exact match (case-insensitive):      +5 pts
+    // ─────────────────────────────────────────────────────────────
+    computeAnchorBonus(dnaAnchors, liveAnchors) {
+        if (!dnaAnchors || !liveAnchors)
+            return 0;
+        let bonus = 0;
+        const dnaLabel = dnaAnchors.closestLabel?.toLowerCase().trim();
+        const liveLabel = liveAnchors.closestLabel?.toLowerCase().trim();
+        if (dnaLabel && liveLabel && dnaLabel === liveLabel) {
+            bonus += ANCHOR_BONUS_LABEL;
+            console.log(`[IntentAuditor] 🎯 Anchor +${ANCHOR_BONUS_LABEL} pts — closestLabel match: "${dnaAnchors.closestLabel}"`);
+        }
+        const dnaRow = dnaAnchors.rowAnchor?.toLowerCase().trim();
+        const liveRow = liveAnchors.rowAnchor?.toLowerCase().trim();
+        if (dnaRow && liveRow && dnaRow === liveRow) {
+            bonus += ANCHOR_BONUS_ROW;
+            console.log(`[IntentAuditor] 🎯 Anchor +${ANCHOR_BONUS_ROW} pts — rowAnchor match: "${dnaAnchors.rowAnchor}"`);
+        }
+        return bonus;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // PRIVATE: parse and validate raw LLM JSON response.
+    //
+    // Returns the verdict as-is from the LLM.  The low-confidence
+    // CONSISTENT downgrade is intentionally NOT performed here so
+    // that auditIntent() can apply structural scoring first and then
+    // run the downgrade once against the adjusted confidence.
+    // ─────────────────────────────────────────────────────────────
+    parseVerdict(raw) {
+        try {
+            const jsonMatch = raw.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                throw new Error("No JSON object found in response");
+            const parsed = JSON.parse(jsonMatch[0]);
+            const verdict = parsed.verdict === "CONSISTENT" ||
+                parsed.verdict === "INCONSISTENT" ||
+                parsed.verdict === "SUSPICIOUS"
+                ? parsed.verdict
+                : "SUSPICIOUS";
+            const confidence = typeof parsed.confidence === "number"
+                ? Math.max(0, Math.min(100, Math.round(parsed.confidence)))
+                : 0;
+            const reason = typeof parsed.reason === "string" && parsed.reason.length > 0
+                ? parsed.reason
+                : "No reason provided";
+            const validInversionTypes = new Set([
+                "polarity",
+                "quantitative",
+                "state",
+                "identity",
+            ]);
+            const inversionType = validInversionTypes.has(parsed.inversionType)
+                ? parsed.inversionType
+                : null;
+            return { verdict, confidence, reason, inversionType };
+        }
+        catch (err) {
+            console.warn(`[IntentAuditor] Warning: Failed to parse Auditor response: ${err.message}`);
+            return {
+                ...FALLBACK_VERDICT,
+                reason: `Parse failure: ${err.message}`,
+            };
+        }
+    }
+}
+exports.IntentAuditor = IntentAuditor;

package/dist/services/LLMService.d.ts

@@ -0,0 +1,100 @@
+import { FixRequest } from "../types";
+export interface SelectorSegment {
+    type: "frame" | "element";
+    selector: string;
+}
+export interface ContentChange {
+    oldText: string;
+    newText: string;
+}
+export type SmartChainSegment = {
+    type: "locator";
+    selector: string;
+    hasText?: string;
+    has?: string;
+    hasNot?: string;
+} | {
+    type: "frameLocator";
+    selector: string;
+} | {
+    type: "getByRole";
+    role: string;
+    name?: string;
+    exact?: boolean;
+    level?: number;
+    checked?: boolean;
+    pressed?: boolean;
+    expanded?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+} | {
+    type: "getByLabel";
+    text: string;
+    exact?: boolean;
+} | {
+    type: "getByText";
+    text: string;
+    exact?: boolean;
+} | {
+    type: "getByPlaceholder";
+    text: string;
+    exact?: boolean;
+} | {
+    type: "getByTestId";
+    testId: string;
+} | {
+    type: "getByAltText";
+    text: string;
+    exact?: boolean;
+} | {
+    type: "getByTitle";
+    text: string;
+    exact?: boolean;
+} | {
+    type: "filter";
+    hasText?: string;
+    hasNotText?: string;
+    has?: string;
+    hasNot?: string;
+} | {
+    type: "first";
+} | {
+    type: "last";
+} | {
+    type: "nth";
+    index: number;
+};
+export interface FixResponse {
+    status: "FIXED" | "NOT_FOUND";
+    /**
+     * LEGACY/PROXY: This selector is used for IMMEDIATE RETRY in the proxy.
+     * CRITICAL: Must be as specific as the chainSegments to avoid Strict Mode errors.
+     */
+    segments: SelectorSegment[];
+    /**
+     * NEW: Rich semantic chain segments for AST source update.
+     */
+    chainSegments?: SmartChainSegment[];
+    originalChainHint?: SmartChainSegment[];
+    confidence: number;
+    explanation: string;
+    new_selector?: string | null;
+    contentChange?: ContentChange;
+}
+export declare class LLMService {
+    private anthropic;
+    constructor();
+    private cleanJson;
+    /**
+     * Attempts to infer contentChange when the AI did not return the field.
+     *
+     * Strategies (in order of confidence):
+     *
+     * 1. previousState.text  vs  has-text() in new selector
+     * 2. has-text() in old selector vs new selector
+     * 3. intentDescription text vs new selector
+     */
+    private inferContentChange;
+    getFix(request: FixRequest): Promise<FixResponse>;
+}
+//# sourceMappingURL=LLMService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LLMService.d.ts","sourceRoot":"","sources":["../../src/services/LLMService.ts"],"names":[],"mappings":"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"}