sela-core 1.0.6 → 1.0.7

package/dist/utils/IsolatedDiff.js

@@ -0,0 +1,379 @@
+"use strict";
+// src/utils/IsolatedDiff.ts
+//
+// Pure-JS unified-diff generator. No external `diff` package, no shell-out to
+// `git diff` — the result is guaranteed to be a function ONLY of the two
+// in-memory buffers passed in, never of any global working-tree state.
+//
+// This is the foundation of the Clean-Room Architecture: the HTML report
+// renders diffs computed here, so a developer's pre-existing uncommitted
+// edits CANNOT leak into Sela's report.
+//
+// Algorithm: classic LCS over lines, then a unified-diff emitter with
+// configurable context. Memory is O(N*M) which is fine for the spec files
+// Sela mutates (typically a few thousand lines max).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDiff = generateUnifiedDiff;
+exports.extractChangeBlocks = extractChangeBlocks;
+exports.applyChangeBlocks = applyChangeBlocks;
+/**
+ * Generate a `git`-style unified diff between two in-memory strings.
+ * Returns `""` when the two buffers are identical.
+ */
+function generateUnifiedDiff(before, after, opts = {}) {
+    if (before === after)
+        return "";
+    const context = Math.max(0, opts.context ?? 3);
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    if (ops.length === 0)
+        return "";
+    const hunks = groupHunks(ops, { a, b, context });
+    if (hunks.length === 0)
+        return "";
+    const out = [];
+    if (opts.filePath) {
+        const p = opts.filePath.split(/[\\/]/).join("/");
+        out.push(`diff --git a/${p} b/${p}`);
+        out.push(`--- a/${p}`);
+        out.push(`+++ b/${p}`);
+    }
+    for (const hunk of hunks) {
+        out.push(formatHunkHeader(hunk));
+        for (const row of hunk.rows)
+            out.push(row);
+    }
+    return out.join("\n") + "\n";
+}
+// ────────────────────────────────────────────────────────────────────
+// LINE SPLITTER — preserves trailing newline / CRLF so we can emit the
+// canonical `` marker when needed.
+// ────────────────────────────────────────────────────────────────────
+function splitKeepEol(text) {
+    if (text.length === 0)
+        return [];
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10 /* \n */) {
+            out.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < text.length)
+        out.push(text.slice(start));
+    return out;
+}
+function stripEol(line) {
+    if (line.endsWith("\r\n"))
+        return line.slice(0, -2);
+    if (line.endsWith("\n"))
+        return line.slice(0, -1);
+    return line;
+}
+function hasEol(line) {
+    return line.endsWith("\n");
+}
+function diffLines(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const w = n + 1;
+    const dp = new Uint32Array((m + 1) * w);
+    for (let i = m - 1; i >= 0; i--) {
+        const ai = a[i];
+        for (let j = n - 1; j >= 0; j--) {
+            if (ai === b[j]) {
+                dp[i * w + j] = dp[(i + 1) * w + (j + 1)] + 1;
+            }
+            else {
+                const down = dp[(i + 1) * w + j];
+                const right = dp[i * w + (j + 1)];
+                dp[i * w + j] = down >= right ? down : right;
+            }
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            ops.push({ kind: "eq", a: i, b: j });
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * w + j] >= dp[i * w + (j + 1)]) {
+            ops.push({ kind: "del", a: i });
+            i++;
+        }
+        else {
+            ops.push({ kind: "add", b: j });
+            j++;
+        }
+    }
+    while (i < m) {
+        ops.push({ kind: "del", a: i });
+        i++;
+    }
+    while (j < n) {
+        ops.push({ kind: "add", b: j });
+        j++;
+    }
+    return ops;
+}
+function groupHunks(ops, ctx) {
+    const hunks = [];
+    const ctxN = ctx.context;
+    let i = 0;
+    while (i < ops.length) {
+        // Locate the next non-equal op.
+        let firstChange = -1;
+        for (let k = i; k < ops.length; k++) {
+            if (ops[k].kind !== "eq") {
+                firstChange = k;
+                break;
+            }
+        }
+        if (firstChange === -1)
+            break;
+        // Leading-context start, bounded by previous hunk end.
+        let hunkStart = firstChange - ctxN;
+        if (hunkStart < i)
+            hunkStart = i;
+        if (hunkStart < 0)
+            hunkStart = 0;
+        let hunkEnd = firstChange;
+        // Extend by merging change groups separated by <= 2*ctxN equality lines.
+        // Avoid merging across the very end of `ops`.
+        while (true) {
+            let cursor = hunkEnd + 1;
+            let runEqs = 0;
+            let nextChange = -1;
+            while (cursor < ops.length) {
+                if (ops[cursor].kind === "eq") {
+                    runEqs++;
+                    cursor++;
+                    continue;
+                }
+                nextChange = cursor;
+                break;
+            }
+            if (nextChange !== -1 && runEqs <= 2 * ctxN) {
+                hunkEnd = nextChange;
+            }
+            else {
+                break;
+            }
+        }
+        // Trailing context.
+        let trailing = 0;
+        while (hunkEnd + 1 < ops.length &&
+            ops[hunkEnd + 1].kind === "eq" &&
+            trailing < ctxN) {
+            hunkEnd++;
+            trailing++;
+        }
+        // Materialise rows + compute header coordinates.
+        const rows = [];
+        let oldStartIdx = -1;
+        let newStartIdx = -1;
+        let oldLen = 0;
+        let newLen = 0;
+        for (let k = hunkStart; k <= hunkEnd; k++) {
+            const op = ops[k];
+            if (op.kind === "eq") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                const line = ctx.a[op.a];
+                rows.push(" " + stripEol(line));
+                oldLen++;
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else if (op.kind === "del") {
+                if (oldStartIdx === -1)
+                    oldStartIdx = op.a;
+                if (newStartIdx === -1) {
+                    // Anchor on the corresponding `b` position. For pure-deletions at
+                    // the top of file `op.a === 0` ⇒ newStart should be 0 (special
+                    // header form `+0,0`). For mid-file deletions use the running b
+                    // cursor — derive it from prior ops.
+                    newStartIdx = computeBAnchor(ops, k);
+                }
+                const line = ctx.a[op.a];
+                rows.push("-" + stripEol(line));
+                oldLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+            else {
+                if (newStartIdx === -1)
+                    newStartIdx = op.b;
+                if (oldStartIdx === -1)
+                    oldStartIdx = computeAAnchor(ops, k);
+                const line = ctx.b[op.b];
+                rows.push("+" + stripEol(line));
+                newLen++;
+                if (!hasEol(line))
+                    rows.push("\");
+            }
+        }
+        hunks.push({
+            oldStart: oldLen === 0 ? oldStartIdx : oldStartIdx + 1,
+            oldLen,
+            newStart: newLen === 0 ? newStartIdx : newStartIdx + 1,
+            newLen,
+            rows,
+        });
+        i = hunkEnd + 1;
+    }
+    return hunks;
+}
+/**
+ * For a pure-add op at position `k`, walk backwards to find the prior
+ * `a` index (so we know which line of the old file the hunk starts at).
+ */
+function computeAAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.a + 1;
+        if (op.kind === "del")
+            return op.a + 1;
+    }
+    return 0;
+}
+function computeBAnchor(ops, k) {
+    for (let p = k - 1; p >= 0; p--) {
+        const op = ops[p];
+        if (op.kind === "eq")
+            return op.b + 1;
+        if (op.kind === "add")
+            return op.b + 1;
+    }
+    return 0;
+}
+function formatHunkHeader(hunk) {
+    const oldPart = hunk.oldLen === 1 ? `${hunk.oldStart}` : `${hunk.oldStart},${hunk.oldLen}`;
+    const newPart = hunk.newLen === 1 ? `${hunk.newStart}` : `${hunk.newStart},${hunk.newLen}`;
+    return `@@ -${oldPart} +${newPart} @@`;
+}
+function extractChangeBlocks(before, after) {
+    if (before === after)
+        return [];
+    const a = splitKeepEol(before);
+    const b = splitKeepEol(after);
+    const ops = diffLines(a, b);
+    const blocks = [];
+    let i = 0;
+    while (i < ops.length) {
+        if (ops[i].kind === "eq") {
+            i++;
+            continue;
+        }
+        const start = i;
+        while (i < ops.length && ops[i].kind !== "eq")
+            i++;
+        const oldLines = [];
+        const newLines = [];
+        let oldStart = -1;
+        let newStart = -1;
+        for (let k = start; k < i; k++) {
+            const op = ops[k];
+            if (op.kind === "del") {
+                if (oldStart === -1)
+                    oldStart = op.a;
+                oldLines.push(a[op.a]);
+            }
+            else if (op.kind === "add") {
+                if (newStart === -1)
+                    newStart = op.b;
+                newLines.push(b[op.b]);
+            }
+        }
+        let anchorBefore = null;
+        if (oldLines.length === 0) {
+            // Pure addition — find preceding unchanged anchor line.
+            for (let k = start - 1; k >= 0; k--) {
+                const op = ops[k];
+                if (op.kind === "eq") {
+                    anchorBefore = a[op.a];
+                    break;
+                }
+            }
+        }
+        blocks.push({
+            oldBlock: oldLines.join(""),
+            newBlock: newLines.join(""),
+            oldLineStart: oldStart >= 0 ? oldStart + 1 : 0,
+            newLineStart: newStart >= 0 ? newStart + 1 : 0,
+            anchorBefore,
+        });
+    }
+    return blocks;
+}
+/**
+ * Replay a list of change blocks against a fresh base buffer (typically
+ * the file's `HEAD` blob). Each block is applied via UNIQUE substring
+ * replacement — when the old block is missing or ambiguous in the base,
+ * we fail loudly rather than silently mutating the wrong spot.
+ */
+function applyChangeBlocks(base, blocks) {
+    let working = base;
+    for (const block of blocks) {
+        if (block.oldBlock.length === 0) {
+            // Pure addition.
+            if (block.anchorBefore === null) {
+                if (working.length === 0) {
+                    // Empty file — prepend.
+                    working = block.newBlock + working;
+                    continue;
+                }
+                // Prepend at top of file.
+                working = block.newBlock + working;
+                continue;
+            }
+            const idx = working.indexOf(block.anchorBefore);
+            if (idx === -1) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor not found in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const lastIdx = working.lastIndexOf(block.anchorBefore);
+            if (idx !== lastIdx) {
+                return {
+                    ok: false,
+                    reason: `pure-add anchor is not unique in clean base: "${snippet(block.anchorBefore)}"`,
+                };
+            }
+            const insertAt = idx + block.anchorBefore.length;
+            working = working.slice(0, insertAt) + block.newBlock + working.slice(insertAt);
+            continue;
+        }
+        const idx = working.indexOf(block.oldBlock);
+        if (idx === -1) {
+            return {
+                ok: false,
+                reason: `block not found in clean base — developer's dirty state likely overlaps Sela's mutation site: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        const lastIdx = working.lastIndexOf(block.oldBlock);
+        if (idx !== lastIdx) {
+            return {
+                ok: false,
+                reason: `block matches multiple locations in clean base — refusing to guess: "${snippet(block.oldBlock)}"`,
+            };
+        }
+        working =
+            working.slice(0, idx) + block.newBlock + working.slice(idx + block.oldBlock.length);
+    }
+    return { ok: true, result: working };
+}
+function snippet(s) {
+    const flat = s.replace(/\r?\n/g, "\\n");
+    return flat.length > 80 ? flat.slice(0, 77) + "..." : flat;
+}

package/package.json

@@ -1,67 +1,71 @@
-{
-  "name": "sela-core",
-  "version": "1.0.6",
-  "description": "AI self-healing Playwright wrapper — drop-in replacement for @playwright/test",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "bin"
-  ],
-  "bin": {
-    "sela": "bin/sela.js"
-  },
-  "scripts": {
-    "sela": "tsx src/cli/index.ts",
-    "build": "tsc -p tsconfig.build.json",
-    "build:watch": "tsc -p tsconfig.build.json --watch",
-    "prepublishOnly": "npm run build",
-    "test": "npx playwright test demo.spec.ts --headed --retries=0",
-    "test-shadow": "npx playwright test shadow.spec.ts --headed --retries=0",
-    "test-core": "npx playwright test tests/Core/CoreExample.spec.ts --headed --retries=0",
-    "test-DNA": "npx playwright test tests/DnaSurvival/DnaSurvival.spec.ts --headed --retries=0",
-    "test-advanced": "npx playwright test tests/AdvancedLogic/AdvancedLogic.spec.ts --headed --retries=0",
-    "test-isolation": "npx playwright test tests/Isolation/Isolation.spec.ts --headed --retries=0",
-    "test-playwright-actions": "npx playwright test tests/PlaywrightActions/BasicActions/BasicActions.spec.ts --headed --retries=0",
-    "test-forms-actions": "npx playwright test tests/PlaywrightActions/FormsActions/FormsActions.spec.ts --headed --retries=0",
-    "test-locators-actions": "npx playwright test tests/PlaywrightActions/LocatorsActions/LocatorsActions.spec.ts --headed --retries=0",
-    "test-config": "npx playwright test tests/TestConfig/TestConfig.spec.ts --headed --retries=0",
-    "test-safety-guard": "npx playwright test tests/SafetyGuard/SafetyGuard.spec.ts --headed --retries=0",
-    "test-improve-methods": "npx playwright test tests/ImproveMethods/ImproveMethods.spec.ts --headed --retries=0",
-    "test-shadow-dom": "npx playwright test tests/ShadowDom/ShadowDom.spec.ts --headed --retries=0",
-    "test-ut": "npx vitest run tests/unit/DOMUtils.test.ts && npx jest tests/unit/StackUtils.test.ts"
-  },
-  "author": "",
-  "license": "ISC",
-  "peerDependencies": {
-    "@playwright/test": ">=1.40.0"
-  },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
-    "axios": "^1.13.6",
-    "chalk": "^4.1.2",
-    "cli-table3": "^0.6.5",
-    "commander": "^14.0.3",
-    "dotenv": "^17.3.1",
-    "enquirer": "^2.4.1",
-    "ora": "^5.4.1",
-    "playwright": "^1.58.2",
-    "ts-morph": "^27.0.2"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.60.0",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^25.6.2",
-    "jest": "^30.3.0",
-    "jsdom": "^29.0.1",
-    "ts-jest": "^29.4.6",
-    "tsx": "^4.21.0",
-    "vitest": "^4.1.1"
-  }
-}
+{
+  "name": "sela-core",
+  "version": "1.0.7",
+  "description": "AI self-healing Playwright wrapper — drop-in replacement for @playwright/test",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./reporter": {
+      "types": "./dist/reporter/SelaReporter.d.ts",
+      "default": "./dist/reporter/SelaReporter.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "bin": {
+    "sela": "bin/sela.js"
+  },
+  "scripts": {
+    "sela": "tsx src/cli/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "prepublishOnly": "npm run build",
+    "test": "npx playwright test demo.spec.ts --headed --retries=0",
+    "test-shadow": "npx playwright test shadow.spec.ts --headed --retries=0",
+    "test-core": "npx playwright test tests/Core/CoreExample.spec.ts --headed --retries=0",
+    "test-DNA": "npx playwright test tests/DnaSurvival/DnaSurvival.spec.ts --headed --retries=0",
+    "test-advanced": "npx playwright test tests/AdvancedLogic/AdvancedLogic.spec.ts --headed --retries=0",
+    "test-isolation": "npx playwright test tests/Isolation/Isolation.spec.ts --headed --retries=0",
+    "test-playwright-actions": "npx playwright test tests/PlaywrightActions/BasicActions/BasicActions.spec.ts --headed --retries=0",
+    "test-forms-actions": "npx playwright test tests/PlaywrightActions/FormsActions/FormsActions.spec.ts --headed --retries=0",
+    "test-locators-actions": "npx playwright test tests/PlaywrightActions/LocatorsActions/LocatorsActions.spec.ts --headed --retries=0",
+    "test-config": "npx playwright test tests/TestConfig/TestConfig.spec.ts --headed --retries=0",
+    "test-safety-guard": "npx playwright test tests/SafetyGuard/SafetyGuard.spec.ts --headed --retries=0",
+    "test-improve-methods": "npx playwright test tests/ImproveMethods/ImproveMethods.spec.ts --headed --retries=0",
+    "test-shadow-dom": "npx playwright test tests/ShadowDom/ShadowDom.spec.ts --headed --retries=0",
+    "test-ut": "npx vitest run tests/unit/safetyguard/ tests/unit/engine/ tests/unit/ast/ tests/unit/proxy/ tests/unit/_harness/ tests/unit/config/ tests/unit/services/ tests/unit/reporter/ tests/unit/utils/"
+  },
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
+    "axios": "^1.13.6",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "enquirer": "^2.4.1",
+    "ora": "^5.4.1",
+    "playwright": "^1.58.2",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.60.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.6.2",
+    "jest": "^30.3.0",
+    "jsdom": "^29.0.1",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
+    "vitest": "^4.1.1"
+  }
+}