sela-core 0.1.0-alpha.35 → 0.1.0-alpha.37

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,15 @@
 import { Command } from "commander";
+export interface InitOptions {
+    updateImports?: boolean;
+    /** Skip the conventions auto-discovery wizard. */
+    conventions?: boolean;
+    /** Enable the optional LLM polish step (Commander: --no-llm sets false). */
+    llm?: boolean;
+    yes?: boolean;
+    dryRun?: boolean;
+    glob?: string;
+    maxFiles?: string;
+    fileTimeout?: string;
+}
 export declare function registerInit(program: Command): void;
 //# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6BpC,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAWnD"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8BpC,MAAM,WAAW,WAAW;IAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4EAA4E;IAC5E,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoBnD"}

package/dist/cli/commands/init.js

@@ -37,6 +37,7 @@ exports.registerInit = registerInit;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const logger_js_1 = require("../../utils/logger.js");
+const conventionsInit_js_1 = require("../conventionsInit.js");
 const PACKAGE_NAME = "sela-core";
 const CONFIG_TEMPLATE_TS = `import { defineConfig } from '${PACKAGE_NAME}';
 
@@ -60,8 +61,15 @@ const REQUIRED_ENV_VARS = ["ANTHROPIC_API_KEY"];
 function registerInit(program) {
     program
         .command("init")
-        .description("Initialize Sela in the current project")
+        .description("Initialize Sela and auto-discover your testing conventions")
         .option("--no-update-imports", "Skip swapping @playwright/test imports to sela-core")
+        .option("--no-conventions", "Skip the conventions auto-discovery wizard")
+        .option("--no-llm", "Skip the optional Claude refinement step")
+        .option("-y, --yes", "Accept defaults (smart discovery + write)")
+        .option("--dry-run", "Print conventions to stdout without writing")
+        .option("--glob <pattern>", "Scan files matching this glob (non-interactive)")
+        .option("--max-files <n>", "Hard cap on files scanned")
+        .option("--file-timeout <ms>", "Per-file analysis budget (ms)")
         .action(async (opts) => {
         await runInit(opts);
     });
@@ -106,6 +114,18 @@ async function runInit(opts) {
     }
     logger_js_1.logger.info(`\nSpec files should import from:`);
     logger_js_1.logger.info(`   import { test, expect } from '${PACKAGE_NAME}'\n`);
+    // ── Conventions auto-discovery (default ON; opt out --no-conventions) ──
+    if (opts.conventions !== false) {
+        logger_js_1.logger.info(`Discovering testing conventions…`);
+        await (0, conventionsInit_js_1.runConventionsWizard)(cwd, {
+            llm: opts.llm,
+            yes: opts.yes,
+            dryRun: opts.dryRun,
+            glob: opts.glob,
+            maxFiles: opts.maxFiles ? Number(opts.maxFiles) : undefined,
+            fileTimeoutMs: opts.fileTimeout ? Number(opts.fileTimeout) : undefined,
+        });
+    }
 }
 function loadDotEnv(cwd) {
     const envPath = path.join(cwd, ".env");

package/dist/cli/commands/shadowRegression.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { RegressionResult } from "../../services/ReportGenerator.js";
+/**
+ * `sela shadow-regression --manifest <path>`
+ *
+ * Job 2 of the stateless shadow-regression flow. Reads the manifest emitted by
+ * Job 1, re-runs the affected specs with the proposed shared-locator heal hot-
+ * swapped into memory (SELA_REGRESSION_ACTIVE), parses Playwright's JSON
+ * report, and merges a PASSED/FAILED verdict into the existing sela-report.
+ * Zero source-code mutation — the heal lives only in execution memory.
+ *
+ * Exit code: 1 when the regression FAILS (downstream side-effects), else 0.
+ */
+export declare function registerShadowRegression(program: Command): void;
+/**
+ * Flatten a Playwright JSON report into RegressionResult[], walking nested
+ * suites. A spec is FAILED when `ok` is false; the first failing result's error
+ * (message + stack, ANSI-stripped) is attached for the report drilldown.
+ */
+export declare function collectResults(report: any): RegressionResult[];
+//# sourceMappingURL=shadowRegression.d.ts.map

package/dist/cli/commands/shadowRegression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowRegression.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/shadowRegression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOzC,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAe3C;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgI/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,gBAAgB,EAAE,CAqC9D"}

package/dist/cli/commands/shadowRegression.js

@@ -0,0 +1,193 @@
+"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.registerShadowRegression = registerShadowRegression;
+exports.collectResults = collectResults;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const RegressionManifestService_js_1 = require("../../services/RegressionManifestService.js");
+const HealReportService_js_1 = require("../../services/HealReportService.js");
+// eslint-disable-next-line no-control-regex
+const ANSI = /\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI, "");
+}
+/**
+ * `sela shadow-regression --manifest <path>`
+ *
+ * Job 2 of the stateless shadow-regression flow. Reads the manifest emitted by
+ * Job 1, re-runs the affected specs with the proposed shared-locator heal hot-
+ * swapped into memory (SELA_REGRESSION_ACTIVE), parses Playwright's JSON
+ * report, and merges a PASSED/FAILED verdict into the existing sela-report.
+ * Zero source-code mutation — the heal lives only in execution memory.
+ *
+ * Exit code: 1 when the regression FAILS (downstream side-effects), else 0.
+ */
+function registerShadowRegression(program) {
+    program
+        .command("shadow-regression")
+        .description("Verify a bypassed shared-locator heal against its downstream blast radius " +
+        "(stateless, in-memory, zero disk mutation)")
+        .requiredOption("--manifest <path>", "Path to sela-regression-manifest.json (emitted by the primary run)")
+        .option("--dir <path>", "Project dir holding sela-report.json (merge target)", process.cwd())
+        .option("--config <path>", "Playwright config to pass through to the run")
+        .option("--report <path>", "Override path to the base sela-report.json to merge into")
+        .action(async (opts) => {
+        const targetDir = path.resolve(opts.dir ?? process.cwd());
+        const manifestAbs = path.isAbsolute(opts.manifest)
+            ? opts.manifest
+            : path.resolve(process.cwd(), opts.manifest);
+        // 1. Load + validate the manifest (throws loudly on bad input).
+        let manifest;
+        try {
+            manifest = RegressionManifestService_js_1.RegressionManifestService.readManifest(manifestAbs);
+        }
+        catch (err) {
+            process.stderr.write(`[sela] ${err.message}\n`);
+            process.exit(1);
+            return;
+        }
+        if (manifest.records.length === 0) {
+            process.stdout.write("[sela] Manifest has no bypassed locators — nothing to verify.\n");
+            return;
+        }
+        // 2. Union of affected spec files across all records (dedup).
+        const affectedFiles = Array.from(new Set(manifest.records.flatMap((r) => r.affectedFiles)));
+        if (affectedFiles.length === 0) {
+            process.stdout.write("[sela] No affected files in manifest — nothing to re-run.\n");
+            return;
+        }
+        // 3. Run Playwright over the affected files with the JSON reporter and
+        //    the injection env active. JSON goes to a temp file via
+        //    PLAYWRIGHT_JSON_OUTPUT_NAME so stdout stays clean.
+        const tmpJson = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "sela-shadow-")), "pw-report.json");
+        const pwArgs = ["playwright", "test", ...affectedFiles, "--reporter=json"];
+        if (opts.config)
+            pwArgs.push(`--config=${opts.config}`);
+        process.stdout.write(`[sela] Shadow regression: re-running ${affectedFiles.length} affected ` +
+            `spec file(s) with ${manifest.records.length} injected heal(s)…\n`);
+        const run = (0, child_process_1.spawnSync)("npx", pwArgs, {
+            cwd: targetDir,
+            shell: true,
+            env: {
+                ...process.env,
+                SELA_REGRESSION_ACTIVE: "true",
+                SELA_REGRESSION_MANIFEST: manifestAbs,
+                PLAYWRIGHT_JSON_OUTPUT_NAME: tmpJson,
+            },
+            encoding: "utf8",
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        // 4. Parse the JSON report → RegressionResult[].
+        let pwReport;
+        try {
+            pwReport = JSON.parse(fs.readFileSync(tmpJson, "utf8"));
+        }
+        catch (err) {
+            process.stderr.write(`[sela] Could not read Playwright JSON report (${tmpJson}): ${err.message}\n`);
+            if (run.stderr)
+                process.stderr.write(run.stderr.toString());
+            process.exit(1);
+            return;
+        }
+        const regressionTests = collectResults(pwReport);
+        const regressionState = regressionTests.some((t) => t.status === "FAILED")
+            ? "FAILURE"
+            : "SUCCESS";
+        // 5. Merge the verdict into the report + regenerate the dashboard.
+        let htmlPath;
+        try {
+            htmlPath = (0, HealReportService_js_1.mergeRegressionIntoReport)(targetDir, { regressionState, regressionTests }, { reportJsonPath: opts.report });
+        }
+        catch (err) {
+            process.stderr.write(`[sela] Report merge failed: ${err.message}\n`);
+            process.exit(1);
+            return;
+        }
+        const passN = regressionTests.filter((t) => t.status === "PASSED").length;
+        const failN = regressionTests.filter((t) => t.status === "FAILED").length;
+        process.stdout.write(`[sela] Regression ${regressionState}: ${passN} passed · ${failN} failed.\n` +
+            `       Report updated: ${path.relative(process.cwd(), htmlPath)}\n`);
+        // FAILURE = the proposed fix breaks downstream tests → fail the CI job.
+        process.exit(regressionState === "FAILURE" ? 1 : 0);
+    });
+}
+/**
+ * Flatten a Playwright JSON report into RegressionResult[], walking nested
+ * suites. A spec is FAILED when `ok` is false; the first failing result's error
+ * (message + stack, ANSI-stripped) is attached for the report drilldown.
+ */
+function collectResults(report) {
+    const out = [];
+    const walk = (suite, fileFallback) => {
+        const file = suite?.file ?? fileFallback;
+        for (const spec of suite?.specs ?? []) {
+            const specFile = spec.file ?? file ?? "";
+            const ok = spec.ok !== false;
+            let error;
+            if (!ok) {
+                for (const t of spec.tests ?? []) {
+                    for (const r of t.results ?? []) {
+                        if (r.status === "passed" || r.status === "skipped")
+                            continue;
+                        const e = (r.errors && r.errors[0]) || r.error;
+                        if (e) {
+                            error = {
+                                message: stripAnsi(String(e.message ?? "")),
+                                stack: e.stack ? stripAnsi(String(e.stack)) : undefined,
+                            };
+                            break;
+                        }
+                    }
+                    if (error)
+                        break;
+                }
+            }
+            out.push({
+                status: ok ? "PASSED" : "FAILED",
+                testName: spec.title ?? "",
+                filePath: specFile,
+                ...(error ? { error } : {}),
+            });
+        }
+        for (const child of suite?.suites ?? [])
+            walk(child, file);
+    };
+    for (const s of report?.suites ?? [])
+        walk(s);
+    return out;
+}

package/dist/cli/conventionsInit.d.ts

@@ -0,0 +1,51 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import { type ScanOptions } from "../services/ConventionsScanner.js";
+import { type Conventions, type ScanStats } from "../config/Conventions.js";
+export type DiscoveryMode = "smart" | "folders" | "glob";
+export interface ConventionsInitOptions {
+    /** smart | folders | glob. */
+    mode?: DiscoveryMode;
+    /** Folders (cwd-relative) when mode === 'folders'. */
+    folders?: string[];
+    /** Glob pattern when mode === 'glob'. */
+    glob?: string;
+    fileTimeoutMs?: number;
+    maxFiles?: number;
+    /** Run the optional LLM polish step. Default: false. */
+    llm?: boolean;
+    /** Injected Anthropic client (tests). Falls back to a sanitizing client. */
+    client?: Anthropic;
+    model?: string;
+    /** Print JSON to stdout, write nothing. */
+    dryRun?: boolean;
+}
+/** Convert a glob (supports **, *, ?) to an anchored RegExp over posix paths. */
+export declare function globToRegex(glob: string): RegExp;
+/** Resolve the absolute, sorted spec file list for a discovery mode. */
+export declare function resolveSpecFiles(cwd: string, opts: Pick<ConventionsInitOptions, "mode" | "folders" | "glob">): string[];
+export interface GenerationResult {
+    conventions: Conventions;
+    stats: ScanStats;
+}
+export declare function generateConventions(files: string[], opts?: ConventionsInitOptions & {
+    onProgress?: ScanOptions["onProgress"];
+}): Promise<GenerationResult>;
+/**
+ * Optional LLM refinement. Sends ONLY the integer stats blob + the draft (no
+ * raw source) and asks Claude to correct obvious misjudgements while keeping
+ * the exact schema. Fully defensive: any failure returns null → caller keeps
+ * the deterministic draft.
+ */
+export declare function polishConventions(draft: Conventions, stats: ScanStats, client: Anthropic, model: string): Promise<Conventions | null>;
+export interface WriteResult {
+    path: string;
+    json: string;
+    written: boolean;
+}
+export declare function writeConventionsArtifact(cwd: string, conventions: Conventions, opts?: {
+    dryRun?: boolean;
+}): WriteResult;
+export declare function runConventionsWizard(cwd: string, opts?: ConventionsInitOptions & {
+    yes?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=conventionsInit.d.ts.map

package/dist/cli/conventionsInit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventionsInit.d.ts","sourceRoot":"","sources":["../../src/cli/conventionsInit.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAO/C,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,SAAS,EAEf,MAAM,0BAA0B,CAAC;AAelC,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,8BAA8B;IAC9B,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,4EAA4E;IAC5E,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAkCD,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0BhD;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,CAAC,sBAAsB,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,GAC9D,MAAM,EAAE,CAcV;AAMD,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,WAAW,CAAC;IACzB,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,GAAE,sBAAsB,GAAG;IAAE,UAAU,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;CAAO,GAC7E,OAAO,CAAC,gBAAgB,CAAC,CAsB3B;AAQD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA4C7B;AAMD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,WAAW,EACxB,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,WAAW,CAQb;AAMD,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,sBAAsB,GAAG;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GACpD,OAAO,CAAC,IAAI,CAAC,CAgHf"}

package/dist/cli/conventionsInit.js

@@ -0,0 +1,326 @@
+"use strict";
+// src/cli/conventionsInit.ts
+//
+// `sela init` conventions wizard — file discovery, deterministic generation,
+// optional LLM polish, and artifact write. The pure pieces (resolveSpecFiles,
+// generateConventions, writeConventionsArtifact) are exported separately from
+// the interactive `runConventionsWizard` so they can be unit-tested without a
+// TTY or network.
+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.globToRegex = globToRegex;
+exports.resolveSpecFiles = resolveSpecFiles;
+exports.generateConventions = generateConventions;
+exports.polishConventions = polishConventions;
+exports.writeConventionsArtifact = writeConventionsArtifact;
+exports.runConventionsWizard = runConventionsWizard;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_js_1 = require("../utils/logger.js");
+const atomicWrite_js_1 = require("../utils/atomicWrite.js");
+const ProgressReporter_js_1 = require("./ui/ProgressReporter.js");
+const ConventionsTable_js_1 = require("./ui/ConventionsTable.js");
+const enquirer_js_1 = require("../vendor/enquirer.js");
+const SanitizingAnthropic_js_1 = require("../services/SanitizingAnthropic.js");
+const ConventionsScanner_js_1 = require("../services/ConventionsScanner.js");
+const Conventions_js_1 = require("../config/Conventions.js");
+const SPEC_EXTS = [".spec.ts", ".spec.js", ".test.ts", ".test.js"];
+const IGNORE_DIRS = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    "sela-snapshots",
+    "test-results",
+    "playwright-report",
+    ".sela",
+]);
+const DEFAULT_LLM_MODEL = "claude-sonnet-4-6";
+const CONVENTIONS_REL = path.join(".sela", "conventions.json");
+// ─────────────────────────────────────────────────────────────────
+// FILE DISCOVERY
+// ─────────────────────────────────────────────────────────────────
+function isSpec(name) {
+    return SPEC_EXTS.some((e) => name.endsWith(e));
+}
+function walkSpecs(root, matchAll, re, base) {
+    const out = [];
+    const cwd = base ?? root;
+    const recurse = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (!IGNORE_DIRS.has(e.name))
+                    recurse(full);
+            }
+            else if (matchAll ? isSpec(e.name) : re) {
+                const rel = path.relative(cwd, full).replace(/\\/g, "/");
+                if (matchAll ? isSpec(e.name) : re.test(rel))
+                    out.push(full);
+            }
+        }
+    };
+    recurse(root);
+    return out;
+}
+/** Convert a glob (supports **, *, ?) to an anchored RegExp over posix paths. */
+function globToRegex(glob) {
+    const g = glob.replace(/\\/g, "/");
+    let re = "";
+    for (let i = 0; i < g.length; i++) {
+        const c = g[i];
+        if (c === "*") {
+            if (g[i + 1] === "*") {
+                if (g[i + 2] === "/") {
+                    re += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    re += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (c === "?") {
+            re += "[^/]";
+        }
+        else if (".+^${}()|[]\\".includes(c)) {
+            re += "\\" + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    return new RegExp("^" + re + "$");
+}
+/** Resolve the absolute, sorted spec file list for a discovery mode. */
+function resolveSpecFiles(cwd, opts) {
+    const mode = opts.mode ?? "smart";
+    let files;
+    if (mode === "glob" && opts.glob) {
+        files = walkSpecs(cwd, false, globToRegex(opts.glob), cwd);
+    }
+    else if (mode === "folders" && opts.folders?.length) {
+        files = opts.folders.flatMap((f) => walkSpecs(path.resolve(cwd, f), true, undefined, cwd));
+    }
+    else {
+        files = walkSpecs(cwd, true, undefined, cwd);
+    }
+    // Dedupe + sort for fully deterministic scan order.
+    return [...new Set(files)].sort();
+}
+async function generateConventions(files, opts = {}) {
+    const stats = (0, ConventionsScanner_js_1.scan)(files, {
+        fileTimeoutMs: opts.fileTimeoutMs,
+        maxFiles: opts.maxFiles,
+        onProgress: opts.onProgress,
+    });
+    let conventions = (0, ConventionsScanner_js_1.deriveConventions)(stats);
+    if (opts.llm) {
+        const client = opts.client ?? defaultClient();
+        if (client) {
+            const polished = await polishConventions(conventions, stats, client, opts.model ?? process.env.SELA_LLM_MODEL ?? DEFAULT_LLM_MODEL);
+            if (polished)
+                conventions = polished;
+        }
+    }
+    return { conventions, stats };
+}
+function defaultClient() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        return null;
+    return (0, SanitizingAnthropic_js_1.createSanitizingAnthropic)({ apiKey });
+}
+/**
+ * Optional LLM refinement. Sends ONLY the integer stats blob + the draft (no
+ * raw source) and asks Claude to correct obvious misjudgements while keeping
+ * the exact schema. Fully defensive: any failure returns null → caller keeps
+ * the deterministic draft.
+ */
+async function polishConventions(draft, stats, client, model) {
+    const payload = {
+        strategyCounts: stats.strategyCounts,
+        archCounts: stats.archCounts,
+        caseCounts: stats.caseCounts,
+        testIdAttrCounts: stats.testIdAttrCounts,
+        sourceModuleCounts: stats.sourceModuleCounts,
+        draft: {
+            strategies: draft.strategies,
+            architecture: draft.architecture,
+            naming: draft.naming,
+        },
+    };
+    const system = "You refine a Playwright testing-conventions blueprint. You are given " +
+        "integer usage counts and a deterministic draft. Correct only clear " +
+        "misjudgements. Keep the EXACT JSON schema of `draft` (strategies, " +
+        "architecture, naming). Respond ONLY with that raw JSON object.";
+    try {
+        const msg = await client.messages.create({
+            model,
+            max_tokens: 512,
+            system,
+            messages: [{ role: "user", content: JSON.stringify(payload) }],
+        });
+        const text = msg.content[0]?.type === "text" ? msg.content[0].text : "";
+        const json = text.replace(/```json/g, "").replace(/```/g, "").trim();
+        const first = json.indexOf("{");
+        const last = json.lastIndexOf("}");
+        if (first === -1 || last === -1)
+            return null;
+        const parsed = JSON.parse(json.slice(first, last + 1));
+        const merged = {
+            ...draft,
+            strategies: parsed.strategies ?? draft.strategies,
+            architecture: parsed.architecture ?? draft.architecture,
+            naming: parsed.naming ?? draft.naming,
+            _meta: { ...draft._meta, source: "llm-polished" },
+        };
+        if (!(0, Conventions_js_1.validateConventions)(merged).valid)
+            return null;
+        return merged;
+    }
+    catch (err) {
+        logger_js_1.logger.debug(`Conventions polish skipped: ${err.message}`);
+        return null;
+    }
+}
+function writeConventionsArtifact(cwd, conventions, opts = {}) {
+    const target = path.join(cwd, CONVENTIONS_REL);
+    const json = JSON.stringify(conventions, null, 2) + "\n";
+    if (opts.dryRun)
+        return { path: target, json, written: false };
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    (0, atomicWrite_js_1.atomicWriteFile)(target, json);
+    return { path: target, json, written: true };
+}
+// ─────────────────────────────────────────────────────────────────
+// INTERACTIVE WIZARD
+// ─────────────────────────────────────────────────────────────────
+async function runConventionsWizard(cwd, opts = {}) {
+    const interactive = !opts.yes && !opts.glob && !opts.dryRun && Boolean(process.stdout.isTTY);
+    // ── Discovery selection ───────────────────────────────────────
+    let mode = opts.mode ?? (opts.glob ? "glob" : "smart");
+    let glob = opts.glob;
+    let folders = opts.folders;
+    if (interactive && !opts.mode) {
+        const choice = await new enquirer_js_1.Select({
+            message: "How should Sela discover your test files?",
+            choices: [
+                { name: "smart", message: "Smart discovery — scan **/*.spec.{ts,js}" },
+                { name: "folders", message: "Pick folders — choose test directories" },
+                { name: "glob", message: "Custom glob — type your own pattern" },
+            ],
+        }).run();
+        mode = choice;
+        if (mode === "glob") {
+            glob = await new enquirer_js_1.Input({
+                message: "Glob pattern",
+                initial: "tests/**/*.spec.ts",
+            }).run();
+        }
+        else if (mode === "folders") {
+            const raw = await new enquirer_js_1.Input({
+                message: "Folders (comma-separated)",
+                initial: "tests",
+            }).run();
+            folders = raw.split(",").map((s) => s.trim()).filter(Boolean);
+        }
+    }
+    const files = resolveSpecFiles(cwd, { mode, glob, folders });
+    if (files.length === 0) {
+        logger_js_1.logger.warn("No test files matched — nothing to analyze.");
+        return;
+    }
+    // ── Scan (streamed spinner) ───────────────────────────────────
+    const reporter = new ProgressReporter_js_1.ProgressReporter(!interactive);
+    const { conventions, stats } = await reporter.run(`Analyzing ${files.length} file(s)…`, () => generateConventions(files, {
+        ...opts,
+        llm: false, // polish handled separately below (confirmable)
+    }));
+    logger_js_1.logger.success(`Analyzed ${stats.locatorsAnalyzed} locator(s) across ${stats.filesScanned} file(s)`);
+    if (stats.skippedFiles.length > 0) {
+        logger_js_1.logger.warn(`Skipped ${stats.skippedFiles.length} file(s) (exceeded ${opts.fileTimeoutMs ?? 500}ms) — conventions may be partial`);
+    }
+    // ── Optional LLM polish ───────────────────────────────────────
+    let final = conventions;
+    const canPolish = opts.llm !== false && Boolean(process.env.ANTHROPIC_API_KEY);
+    const wantPolish = interactive
+        ? canPolish &&
+            (await new enquirer_js_1.Confirm({
+                message: "Refine with Claude for edge-cases?",
+                initial: false,
+            }).run())
+        : Boolean(opts.llm) && canPolish;
+    if (wantPolish) {
+        const client = opts.client ?? defaultClient();
+        if (client) {
+            const polished = await reporter.run("Refining with Claude…", () => polishConventions(final, stats, client, opts.model ?? process.env.SELA_LLM_MODEL ?? DEFAULT_LLM_MODEL));
+            if (polished)
+                final = polished;
+        }
+    }
+    // ── Summary card ──────────────────────────────────────────────
+    logger_js_1.logger.info("\n" + (0, ConventionsTable_js_1.renderConventionsTable)(final));
+    // ── Dry-run prints JSON to stdout, writes nothing ─────────────
+    if (opts.dryRun) {
+        const { json } = writeConventionsArtifact(cwd, final, { dryRun: true });
+        process.stdout.write(json);
+        logger_js_1.logger.info("(dry-run — no file written)");
+        return;
+    }
+    // ── Confirm + write ───────────────────────────────────────────
+    const confirmWrite = opts.yes ||
+        !interactive ||
+        (await new enquirer_js_1.Confirm({
+            message: "Write .sela/conventions.json?",
+            initial: true,
+        }).run());
+    if (!confirmWrite) {
+        logger_js_1.logger.info("Skipped writing conventions.");
+        return;
+    }
+    const { path: written } = writeConventionsArtifact(cwd, final);
+    logger_js_1.logger.success(`Wrote ${path.relative(cwd, written)} ${"— commit this file to git"}`);
+}