sela-core 0.1.0-alpha.1

package/dist/services/MutationApplier.js

@@ -0,0 +1,360 @@
+"use strict";
+// src/services/MutationApplier.ts
+//
+// Ticket #2 — Stage 4: Write-Discipline & the Drain Loop.
+//
+// Applies MutationPlans to disk under three hard contracts:
+//
+//   1. ZERO LAYOUT NOISE (§4.1) — surgical string splice over the EXACT node
+//      span [getStart(), getEnd()). getStart() excludes leading trivia, so
+//      comments / indentation / Prettier layout outside the span are byte-
+//      identical. We never call sourceFile.formatText() / ts.Printer.
+//
+//   2. TYPE-SAFETY GATE + ROLLBACK (§4.3) — after splicing in memory we
+//      re-parse and baseline-diff the diagnostics. A mutation that introduces
+//      a NEW real error (syntax break, non-Locator return) is rolled back and
+//      the file is left byte-for-byte untouched. A cheap Locator-shape pre-
+//      check rejects obviously wrong return types before the splice.
+//
+//   3. BATCH APPLICATION (§3.3) — mutations are grouped by file, anchors are
+//      RE-RESOLVED against the fresh parse (never trusting flag-time offsets),
+//      edits applied highest-offset-first, then the file is written atomically
+//      (temp + rename).
+//
+// Stage 1 (resolveAnchor) provides line-shift-immune relocation; Stage-1
+// applyEdits provides the reverse-offset splice + overlap guard.
+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.MutationApplier = void 0;
+exports.isLocatorReturningExpr = isLocatorReturningExpr;
+const fs = __importStar(require("fs"));
+const ts_morph_1 = require("ts-morph");
+const AnchorResolver_1 = require("./AnchorResolver");
+const DecisionEngine_1 = require("./DecisionEngine");
+const TraceBackEngine_1 = require("./TraceBackEngine");
+const SelectorSanitizer_1 = require("./SelectorSanitizer");
+const PathScopeGuard_1 = require("../config/PathScopeGuard");
+const atomicWrite_1 = require("../utils/atomicWrite");
+const FileLock_1 = require("../utils/FileLock");
+// Diagnostic codes that are pure "missing types" noise in an in-memory parse
+// without node_modules — identical allowlist to ASTSourceUpdater's validator.
+// Syntax/binder errors (codes 1000–1999) are NEVER allowlisted.
+const NOISE_CODES = new Set([
+    2304, 2339, 2345, 2554, 2571, 2580, 2503, 7006, 7016, 7031, 18004,
+]);
+const LOCATOR_RETURNING_CATEGORIES = new Set(["selector", "frame", "modifier"]);
+// ═══════════════════════════════════════════════════════════════════
+// MutationApplier
+// ═══════════════════════════════════════════════════════════════════
+class MutationApplier {
+    /** Apply many batches; each file is processed independently. */
+    static applyBatches(batches, opts = {}) {
+        return batches.map((b) => MutationApplier.applyFileBatch(b, opts));
+    }
+    /**
+     * Apply a file batch under a per-file cross-process lock (SELA-5).
+     *
+     * The lock makes the read-modify-write of a single source file atomic across
+     * concurrent Playwright workers — the real lost-update risk is two specs that
+     * heal a SHARED page-object simultaneously (each reads the same baseline and
+     * the second write drops the first's fix). The lock dir is keyed by file
+     * path, so heals on DIFFERENT files never serialise — worker scalability is
+     * preserved. Read-only / dry-run runs skip the lock entirely (no disk RMW).
+     *
+     * A stale lock (crashed holder) is reclaimed after 30s so a worker crash can
+     * never permanently wedge CI.
+     */
+    static applyFileBatch(batch, opts = {}) {
+        const write = opts.write ?? true;
+        const respectDryRun = opts.respectDryRun ?? true;
+        const dryRun = respectDryRun && process.env.SELA_DRY_RUN === "1";
+        // Only the write path mutates disk; gate/dry-run runs need no lock.
+        if (!write || dryRun) {
+            return MutationApplier.applyFileBatchUnlocked(batch, opts);
+        }
+        const lock = new FileLock_1.FileLock((0, FileLock_1.lockDirFor)(batch.filePath), { staleMs: 30_000 });
+        const outcome = lock.withLockSync(() => MutationApplier.applyFileBatchUnlocked(batch, opts));
+        if (outcome === undefined) {
+            // Lost the per-file lock race past the busy-wait window — skip rather
+            // than risk a clobbering write. The heal is recorded as not-applied; the
+            // caller treats it like any other skipped mutation.
+            let finalContent = "";
+            try {
+                finalContent = fs.readFileSync(batch.filePath, "utf8");
+            }
+            catch {
+                /* unreadable — leave empty */
+            }
+            return {
+                filePath: batch.filePath,
+                status: "skipped",
+                reason: "could not acquire per-file write lock (concurrent heal in progress)",
+                written: false,
+                finalContent,
+                skipped: [],
+            };
+        }
+        return outcome;
+    }
+    static applyFileBatchUnlocked(batch, opts = {}) {
+        const write = opts.write ?? true;
+        const respectDryRun = opts.respectDryRun ?? true;
+        const dryRun = respectDryRun && process.env.SELA_DRY_RUN === "1";
+        const { filePath } = batch;
+        const skipped = [];
+        let original;
+        try {
+            original = fs.readFileSync(filePath, "utf8");
+        }
+        catch (e) {
+            return {
+                filePath,
+                status: "skipped",
+                reason: `cannot read file: ${e.message}`,
+                written: false,
+                finalContent: "",
+                skipped,
+            };
+        }
+        // Fresh parse — the single source of truth for span resolution.
+        const project = newGateProject();
+        const sf = project.createSourceFile(filePath, original, { overwrite: true });
+        const baseline = realDiagnosticCounts(sf);
+        // ── Resolve each edit to a concrete span ─────────────────────────
+        const concrete = [];
+        for (const e of batch.edits) {
+            let replacement = e.replacement;
+            // ABSOLUTE GUARD: translate any internal engine selector to its public
+            // method form before writing; refuse if it cannot be translated. No
+            // `internal:role=…` string ever reaches the developer's source.
+            if (e.kind === "replace") {
+                const san = (0, SelectorSanitizer_1.sanitizeLocatorExpression)(replacement);
+                if (!san.safe) {
+                    skipped.push({
+                        reason: `internal-engine-selector: cannot translate "${truncate(replacement)}" to a public Playwright method`,
+                    });
+                    continue;
+                }
+                replacement = san.text;
+            }
+            const requireLocator = e.requireLocator ?? e.kind === "replace";
+            if (requireLocator && !isLocatorReturningExpr(replacement)) {
+                skipped.push({
+                    reason: `type-incompat: replacement is not a Locator expression ("${truncate(replacement)}")`,
+                });
+                continue;
+            }
+            if (e.kind === "replace" && e.anchor) {
+                const r = (0, AnchorResolver_1.resolveAnchor)(sf, e.anchor);
+                if (r.status !== "resolved") {
+                    skipped.push({
+                        reason: `anchor ${r.status}: ${"reason" in r ? r.reason : ""}`,
+                    });
+                    continue;
+                }
+                concrete.push({
+                    kind: "replace",
+                    span: { start: r.node.getStart(), end: r.node.getEnd() },
+                    replacement,
+                });
+            }
+            else if (e.span) {
+                concrete.push({
+                    kind: e.kind,
+                    span: e.span,
+                    replacement,
+                });
+            }
+            else {
+                skipped.push({ reason: "edit has neither anchor nor span" });
+            }
+        }
+        if (concrete.length === 0) {
+            return {
+                filePath,
+                status: "no-op",
+                reason: "no applicable edits after resolution",
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Splice (reverse-offset; overlap-guarded) ─────────────────────
+        let newContent;
+        try {
+            newContent = (0, DecisionEngine_1.applyEdits)(original, concrete);
+        }
+        catch (e) {
+            return {
+                filePath,
+                status: "rolled-back",
+                reason: `splice failed: ${e.message}`,
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        if (newContent === original) {
+            return {
+                filePath,
+                status: "no-op",
+                reason: "edits produced identical content",
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Type-safety gate: baseline-diff diagnostics ──────────────────
+        const afterSf = project.createSourceFile(filePath, newContent, {
+            overwrite: true,
+        });
+        const after = realDiagnosticCounts(afterSf);
+        const regression = diagnosticRegression(baseline, after);
+        if (regression) {
+            return {
+                filePath,
+                status: "rolled-back",
+                reason: `type-safety gate: mutation introduced a new error (${regression}) — file left untouched`,
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Atomic write ─────────────────────────────────────────────────
+        if (write && !dryRun) {
+            // Safe path scoping (T1): block writes outside allowedPaths.
+            if (!PathScopeGuard_1.PathScopeGuard.enforce(filePath)) {
+                return {
+                    filePath,
+                    status: "skipped",
+                    reason: "blocked by allowedPaths (outside safe path scope)",
+                    written: false,
+                    finalContent: original,
+                    skipped,
+                };
+            }
+            try {
+                (0, atomicWrite_1.atomicWriteFile)(filePath, newContent);
+            }
+            catch (e) {
+                return {
+                    filePath,
+                    status: "rolled-back",
+                    reason: `atomic write failed: ${e.message}`,
+                    written: false,
+                    finalContent: original,
+                    skipped,
+                };
+            }
+        }
+        return {
+            filePath,
+            status: "applied",
+            reason: `${concrete.length} edit(s) applied${dryRun ? " (dry-run, not written)" : ""}`,
+            written: write && !dryRun,
+            finalContent: newContent,
+            skipped,
+        };
+    }
+}
+exports.MutationApplier = MutationApplier;
+// ═══════════════════════════════════════════════════════════════════
+// TYPE-SAFETY HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function newGateProject() {
+    return new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            allowJs: true,
+            noEmit: true,
+            skipLibCheck: true,
+            noResolve: true,
+        },
+    });
+}
+/** Map of real (non-noise) diagnostic code → count. */
+function realDiagnosticCounts(sf) {
+    const counts = new Map();
+    for (const d of sf.getPreEmitDiagnostics()) {
+        if (d.getCategory() !== 1 /* Error */)
+            continue;
+        const code = d.getCode();
+        if (NOISE_CODES.has(code))
+            continue;
+        counts.set(code, (counts.get(code) ?? 0) + 1);
+    }
+    return counts;
+}
+/** Returns a description of the first NEW/elevated error, or null. */
+function diagnosticRegression(baseline, after) {
+    for (const [code, n] of after) {
+        if (n > (baseline.get(code) ?? 0)) {
+            return `TS${code}`;
+        }
+    }
+    return null;
+}
+/**
+ * Cheap return-type pre-check. The replacement must be an expression whose
+ * OUTERMOST call is a Locator-returning Playwright method (locator / getBy* /
+ * frameLocator / nth / first / last / filter / and / or). Rejects actions
+ * (.click()), string queries (.title(), .textContent()), bare literals, etc.
+ */
+function isLocatorReturningExpr(text) {
+    const project = newGateProject();
+    let sf;
+    try {
+        sf = project.createSourceFile("_probe.ts", `const __x = ${text};`, {
+            overwrite: true,
+        });
+    }
+    catch {
+        return false;
+    }
+    const decl = sf.getVariableDeclaration("__x");
+    const init = decl?.getInitializer();
+    if (!init)
+        return false;
+    // Outermost expression must be a call whose method is Locator-returning.
+    if (!ts_morph_1.Node.isCallExpression(init))
+        return false;
+    const callee = init.getExpression();
+    if (!ts_morph_1.Node.isPropertyAccessExpression(callee))
+        return false;
+    return LOCATOR_RETURNING_CATEGORIES.has((0, TraceBackEngine_1.categorizeMethod)(callee.getName()));
+}
+function truncate(s, n = 48) {
+    return s.length > n ? `${s.slice(0, n)}…` : s;
+}

package/dist/services/PRAutomationService.d.ts

@@ -0,0 +1,50 @@
+import type { ResolvedPRAutomation, PRStrategy, BugAction } from "../config/SelaConfig";
+import type { HealedEvent, ProtectedEvent } from "./HealReportService";
+import { type WorkspaceSnapshotService } from "./WorkspaceSnapshotService";
+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;
+    /**
+     * Lowest AI confidence observed across this session's heals, or `undefined`
+     * when no heal carried a numeric confidence (LLM omitted the field). Render
+     * via `fmtPct` so the absence reads as "n/a" instead of 0%.
+     */
+    minAiConfidence: number | undefined;
+    /** Same semantics as `minAiConfidence`, for the auditor's adjusted score. */
+    minAuditorConfidence: number | undefined;
+}
+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 declare function fmtPct(v: unknown): string;
+export interface ExecutionResult {
+    effective: PRStrategy;
+    prUrl: string | null;
+    branchPushed: string | null;
+    errors: string[];
+}
+/**
+ * Clean-Room execution lifecycle.
+ *
+ * The legacy flow committed the developer's whole dirty working tree onto
+ * the PR branch - polluting reviewers with `test.only`, commented debug
+ * blocks, etc. This refactor isolates Sela's specific AST changes onto an
+ * ephemeral branch, leaves the developer's local workspace byte-identical
+ * to its pre-Sela state, and is wrapped in a try/finally that restores
+ * the workspace even on mid-flight crashes.
+ */
+export declare function execute(cfg: ResolvedPRAutomation, decision: StrategyDecision, heals: HealedEvent[], branchInfo: BranchInfo, ctx: ExecuteContext, 
+/** Injectable for tests - defaults to the module singleton. */
+workspace?: WorkspaceSnapshotService): 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,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AAQpC,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;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAiFD,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,UAAU,CA+EpE;AAMD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,WAAW,EAAE,GACnB,gBAAgB,CAgElB;AAMD,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzC;AA6FD,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;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,oBAAoB,EACzB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,WAAW,EAAE,EACpB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc;AACnB,+DAA+D;AAC/D,SAAS,GAAE,wBAAkD,GAC5D,OAAO,CAAC,eAAe,CAAC,CAkG1B;AAsTD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,cAAc,EAAE,EACxB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC,CAgGf"}