@scantrix/cli 1.0.0

package/dist/configExtractor.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateNumericExpression = evaluateNumericExpression;
+exports.extractPlaywrightConfig = extractPlaywrightConfig;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const astConfigParser_1 = require("./astConfigParser");
+// small helpers
+function matchFirst(content, re) {
+    const m = content.match(re);
+    return m?.[1];
+}
+/**
+ * Evaluate common numeric expressions found in Playwright configs.
+ *
+ * Handles:
+ *   - Plain integers: 60000
+ *   - Underscore notation: 60_000
+ *   - Scientific notation: 6e4
+ *   - Simple multiplication: 60 * 1000, 1000 * 60, 2 * 60 * 1000
+ *
+ * Does NOT handle:
+ *   - Ternary expressions: process.env.CI ? 30000 : 60000
+ *   - Variable references: MY_TIMEOUT
+ *   - Function calls: getTimeout()
+ *   - Template literals or string concatenation
+ *
+ * Returns undefined for expressions it cannot evaluate.
+ */
+function evaluateNumericExpression(expr) {
+    if (!expr)
+        return undefined;
+    const cleaned = expr
+        .trim()
+        .replace(/_/g, "") // 60_000 -> 60000
+        .replace(/\s+/g, " "); // normalise whitespace
+    // Direct number (handles 60000, 6e4, 0x... etc.)
+    const direct = Number(cleaned);
+    if (Number.isFinite(direct))
+        return direct;
+    // Simple multiplication chain: N * M [ * P ... ]
+    const parts = cleaned.split(/\s*\*\s*/);
+    if (parts.length >= 2 && parts.every((p) => /^\d+(?:\.\d+)?(?:e\d+)?$/.test(p))) {
+        const result = parts.reduce((acc, p) => acc * Number(p), 1);
+        if (Number.isFinite(result))
+            return result;
+    }
+    return undefined;
+}
+// very small “object block” extraction: finds `key: { ... }` and returns {...} as text
+function extractBlock(content, key) {
+    const idx = content.indexOf(`${key}:`);
+    if (idx < 0)
+        return undefined;
+    const braceStart = content.indexOf("{", idx);
+    if (braceStart < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = braceStart; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === "{")
+            depth++;
+        if (ch === "}")
+            depth--;
+        if (depth === 0) {
+            return content.slice(braceStart, i + 1);
+        }
+    }
+    return undefined;
+}
+function extractArrayBlock(content, key) {
+    const idx = content.indexOf(`${key}:`);
+    if (idx < 0)
+        return undefined;
+    const arrStart = content.indexOf("[", idx);
+    if (arrStart < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = arrStart; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === "[")
+            depth++;
+        if (ch === "]")
+            depth--;
+        if (depth === 0) {
+            return content.slice(arrStart, i + 1);
+        }
+    }
+    return undefined;
+}
+function parseLaunchArgs(useBlock) {
+    if (!useBlock)
+        return undefined;
+    const launchBlock = extractBlock(useBlock, "launchOptions");
+    if (!launchBlock)
+        return undefined;
+    // args: ['--a','--b']
+    const m = launchBlock.match(/\bargs\s*:\s*\[([\s\S]*?)\]/);
+    if (!m)
+        return undefined;
+    const inside = m[1];
+    const args = [...inside.matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1]);
+    return args.length ? args : undefined;
+}
+function parseReporters(content) {
+    // We only need to detect common reporters + key fields.
+    // Find occurrences like ['html', { outputFolder: 'playwright-report', open: 'never' }]
+    const reporters = [];
+    // html
+    const htmlMatches = [...content.matchAll(/\[\s*['"`]html['"`]\s*,\s*\{([\s\S]*?)\}\s*\]/g)];
+    for (const m of htmlMatches) {
+        const block = m[1];
+        const outputFolder = matchFirst(block, /\boutputFolder\s*:\s*['"`]([^'"`]+)['"`]/);
+        const open = matchFirst(block, /\bopen\s*:\s*['"`]([^'"`]+)['"`]/);
+        reporters.push({ name: "html", details: { outputFolder, open } });
+    }
+    // junit
+    const junitMatches = [...content.matchAll(/\[\s*['"`]junit['"`]\s*,\s*\{([\s\S]*?)\}\s*\]/g)];
+    for (const m of junitMatches) {
+        const block = m[1];
+        const outputFile = matchFirst(block, /\boutputFile\s*:\s*['"`]([^'"`]+)['"`]/);
+        reporters.push({ name: "junit", details: { outputFile } });
+    }
+    // list
+    if (/\[\s*['"`]list['"`]\s*\]/.test(content) || /['"`]list['"`]/.test(content)) {
+        reporters.push({ name: "list" });
+    }
+    // azure reporter
+    if (/@alex_neo\/playwright-azure-reporter/.test(content)) {
+        const orgUrl = matchFirst(content, /\borgUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+        const projectName = matchFirst(content, /\bprojectName\s*:\s*['"`]([^'"`]+)['"`]/);
+        const uploadAttachments = /uploadAttachments\s*:\s*true/.test(content);
+        const attachmentsType = [...content.matchAll(/\battachmentsType\s*:\s*\[([\s\S]*?)\]/g)]
+            .flatMap((m) => [...m[1].matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1]));
+        reporters.push({
+            name: "@alex_neo/playwright-azure-reporter",
+            details: {
+                orgUrl,
+                projectName,
+                uploadAttachments,
+                attachmentsType: attachmentsType.length ? attachmentsType : undefined,
+            },
+        });
+    }
+    return reporters.length ? reporters : undefined;
+}
+function parseProjects(projectsBlock) {
+    if (!projectsBlock)
+        return undefined;
+    const projects = [];
+    // very lightweight: find "name: '...'" occurrences and nearby grep/browserName/isMobile text
+    const entries = projectsBlock.split(/\}\s*,\s*\{/g).map((s) => s.replace(/^\[/, "{").replace(/\]$/, "}"));
+    for (const entry of entries) {
+        const name = matchFirst(entry, /\bname\s*:\s*['"`]([^'"`]+)['"`]/);
+        if (!name)
+            continue;
+        const grep = matchFirst(entry, /\bgrep\s*:\s*(\/[^\/]+\/[gimsuy]*)/);
+        const browserName = matchFirst(entry, /\bbrowserName\s*:\s*['"`]([^'"`]+)['"`]/);
+        const isMobile = /\bisMobile\s*:\s*true/.test(entry) ? true : /\bisMobile\s*:\s*false/.test(entry) ? false : undefined;
+        projects.push({ name, grep, browserName, isMobile });
+    }
+    return projects.length ? projects : undefined;
+}
+async function extractPlaywrightConfig(repoPath, 
+/** Optional direct path to the config file (skips root-level search). */
+configFilePath) {
+    // Find config file — prefer the explicitly provided path, then search repo root
+    let configPath = configFilePath;
+    if (!configPath) {
+        const candidates = [
+            path_1.default.join(repoPath, "playwright.config.ts"),
+            path_1.default.join(repoPath, "playwright.config.js"),
+            path_1.default.join(repoPath, "playwright.config.mjs"),
+            path_1.default.join(repoPath, "playwright.config.cjs"),
+        ];
+        for (const c of candidates) {
+            try {
+                await promises_1.default.access(c);
+                configPath = c;
+                break;
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!configPath)
+        return undefined;
+    const content = await promises_1.default.readFile(configPath, "utf8");
+    // ── Strategy 1: AST-based parsing (handles computed values, spreads, etc.) ──
+    const astResult = (0, astConfigParser_1.parseConfigWithAst)(configPath, content);
+    if (astResult) {
+        // Augment with env hints (regex-based, cheap, and AST doesn't do these)
+        astResult.envHints = {
+            headlessEnvVar: content.includes("HEADLESS_MODE") ? "HEADLESS_MODE" : undefined,
+            workersEnvVar: content.includes("process.env.WORKERS") ? "WORKERS" : undefined,
+            ciEnvVar: content.includes("process.env.CI") ? "CI" : undefined,
+            azureTokenEnvVar: content.includes("AZURE_TOKEN") ? "AZURE_TOKEN" : undefined,
+            planIdEnvVar: content.includes("PLAN_ID") ? "PLAN_ID" : undefined,
+        };
+        // Augment with reporters if AST didn't capture them well (complex array syntax)
+        if (!astResult.reporters?.length) {
+            astResult.reporters = parseReporters(content);
+        }
+        return astResult;
+    }
+    // ── Strategy 2: Regex fallback (legacy, handles simpler configs) ──
+    const summary = { configPath };
+    // top-level
+    summary.testDir = matchFirst(content, /\btestDir\s*:\s*['"`]([^'"`]+)['"`]/);
+    // Timeout: extract the raw expression after `timeout:` and evaluate it.
+    // Supports: 60000, 60_000, 6e4, 60 * 1000, 1000 * 60, 2 * 60 * 1000.
+    const rawTimeout = matchFirst(content, /(?<![.\w])timeout\s*:\s*([^,\n{}]+)/);
+    summary.timeoutMs = evaluateNumericExpression(rawTimeout);
+    // expect.timeout (often written as 20 * 1000)
+    const expectBlock = extractBlock(content, "expect");
+    if (expectBlock) {
+        const rawExpectTimeout = matchFirst(expectBlock, /\btimeout\s*:\s*([^,\n{}]+)/);
+        summary.expectTimeoutMs = evaluateNumericExpression(rawExpectTimeout);
+    }
+    summary.workers = matchFirst(content, /\bworkers\s*:\s*([^,\n]+)/)?.trim();
+    summary.retries = matchFirst(content, /\bretries\s*:\s*([^,\n]+)/)?.trim();
+    summary.globalSetup = matchFirst(content, /\bglobalSetup\s*:\s*require\.resolve\(\s*['"`]([^'"`]+)['"`]\s*\)/);
+    // use block
+    const useBlock = extractBlock(content, "use");
+    if (useBlock) {
+        const headlessExpr = matchFirst(useBlock, /\bheadless\s*:\s*([^,\n]+)/)?.trim();
+        const rawActionTimeout = matchFirst(useBlock, /\bactionTimeout\s*:\s*([^,\n{}]+)/);
+        const traceExpr = matchFirst(useBlock, /\btrace\s*:\s*([^,\n]+)/)?.trim();
+        const videoExpr = matchFirst(useBlock, /\bvideo\s*:\s*['"`]([^'"`]+)['"`]/);
+        const screenshotExpr = matchFirst(useBlock, /\bscreenshot\s*:\s*['"`]([^'"`]+)['"`]/);
+        const ignoreHttps = /\bignoreHTTPSErrors\s*:\s*true/.test(useBlock) ? true : /\bignoreHTTPSErrors\s*:\s*false/.test(useBlock) ? false : undefined;
+        const launchArgs = parseLaunchArgs(useBlock);
+        const baseURLExpr = matchFirst(useBlock, /\bbaseURL\s*:\s*(['"`][^'"`]+['"`]|[^,\n]+)/)?.trim();
+        summary.use = {
+            headless: headlessExpr,
+            actionTimeoutMs: evaluateNumericExpression(rawActionTimeout),
+            trace: traceExpr,
+            video: videoExpr,
+            screenshot: screenshotExpr,
+            ignoreHTTPSErrors: ignoreHttps,
+            launchArgs,
+            baseURL: baseURLExpr,
+        };
+    }
+    // reporters + projects
+    summary.reporters = parseReporters(content);
+    summary.projects = parseProjects(extractArrayBlock(content, "projects"));
+    // env hinting (we can detect usage by simple matches)
+    summary.envHints = {
+        headlessEnvVar: content.includes("HEADLESS_MODE") ? "HEADLESS_MODE" : undefined,
+        workersEnvVar: content.includes("process.env.WORKERS") ? "WORKERS" : undefined,
+        ciEnvVar: content.includes("process.env.CI") ? "CI" : undefined,
+        azureTokenEnvVar: content.includes("AZURE_TOKEN") ? "AZURE_TOKEN" : undefined,
+        planIdEnvVar: content.includes("PLAN_ID") ? "PLAN_ID" : undefined,
+    };
+    return summary;
+}

package/dist/cypressExtractor.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * Cypress configuration extractor.
+ *
+ * Detects Cypress projects and parses their configuration from:
+ *   - cypress.config.ts / cypress.config.js  (Cypress 10+)
+ *   - cypress.json                            (Cypress <10, legacy)
+ *
+ * Also detects the Cypress directory structure (cypress/e2e, cypress/integration).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCypressConfig = extractCypressConfig;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
+async function extractCypressConfig(repoPath) {
+    // Priority order: TS > JS > JSON
+    const candidates = [
+        { file: "cypress.config.ts", format: "ts" },
+        { file: "cypress.config.js", format: "js" },
+        { file: "cypress.config.mjs", format: "js" },
+        { file: "cypress.json", format: "json" },
+    ];
+    let configPath;
+    let configFormat = "ts";
+    for (const c of candidates) {
+        const full = path_1.default.join(repoPath, c.file);
+        try {
+            await promises_1.default.access(full);
+            configPath = full;
+            configFormat = c.format;
+            break;
+        }
+        catch {
+            // not found
+        }
+    }
+    if (!configPath) {
+        // Also check if cypress/ directory exists without config (very old projects)
+        try {
+            const cypressDir = path_1.default.join(repoPath, "cypress");
+            const stat = await promises_1.default.stat(cypressDir);
+            if (stat.isDirectory()) {
+                return {
+                    configPath: cypressDir,
+                    configFormat: "json",
+                    testDir: "cypress",
+                };
+            }
+        }
+        catch {
+            // no cypress directory either
+        }
+        return undefined;
+    }
+    const content = await promises_1.default.readFile(configPath, "utf8");
+    if (configFormat === "json") {
+        return parseJsonConfig(configPath, content);
+    }
+    return parseTsJsConfig(configPath, content, configFormat);
+}
+// ─── JSON Config (Cypress <10) ───────────────────────────────────────
+function parseJsonConfig(configPath, content) {
+    try {
+        const json = JSON.parse(content);
+        return {
+            configPath,
+            configFormat: "json",
+            baseUrl: json.baseUrl,
+            defaultCommandTimeout: asNum(json.defaultCommandTimeout),
+            requestTimeout: asNum(json.requestTimeout),
+            responseTimeout: asNum(json.responseTimeout),
+            pageLoadTimeout: asNum(json.pageLoadTimeout),
+            viewportWidth: asNum(json.viewportWidth),
+            viewportHeight: asNum(json.viewportHeight),
+            video: asBool(json.video),
+            screenshotOnRunFailure: asBool(json.screenshotOnRunFailure),
+            retries: parseRetries(json.retries),
+            testDir: json.integrationFolder ?? "cypress/integration",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+// ─── TS/JS Config (Cypress 10+) ─────────────────────────────────────
+function parseTsJsConfig(configPath, content, format) {
+    try {
+        const sourceFile = typescript_1.default.createSourceFile(configPath, content, typescript_1.default.ScriptTarget.Latest, true);
+        const configObj = findDefineConfigOrDefault(sourceFile);
+        if (!configObj)
+            return undefined;
+        const raw = evalObj(configObj);
+        // Cypress 10+ configs nest most settings under `e2e:` or `component:`
+        const e2e = raw.e2e ?? raw;
+        return {
+            configPath,
+            configFormat: format,
+            baseUrl: asStr(e2e.baseUrl),
+            specPattern: asStr(e2e.specPattern),
+            defaultCommandTimeout: asNum(e2e.defaultCommandTimeout),
+            requestTimeout: asNum(e2e.requestTimeout),
+            responseTimeout: asNum(e2e.responseTimeout),
+            pageLoadTimeout: asNum(e2e.pageLoadTimeout),
+            viewportWidth: asNum(e2e.viewportWidth ?? raw.viewportWidth),
+            viewportHeight: asNum(e2e.viewportHeight ?? raw.viewportHeight),
+            video: asBool(e2e.video ?? raw.video),
+            screenshotOnRunFailure: asBool(e2e.screenshotOnRunFailure ?? raw.screenshotOnRunFailure),
+            retries: parseRetries(e2e.retries ?? raw.retries),
+            testDir: asStr(e2e.specPattern)
+                ? path_1.default.dirname(asStr(e2e.specPattern).split("*")[0]) || "cypress/e2e"
+                : "cypress/e2e",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function findDefineConfigOrDefault(sourceFile) {
+    let result;
+    function visit(node) {
+        if (result)
+            return;
+        if (typescript_1.default.isCallExpression(node) &&
+            typescript_1.default.isIdentifier(node.expression) &&
+            node.expression.text === "defineConfig" &&
+            node.arguments.length >= 1 &&
+            typescript_1.default.isObjectLiteralExpression(node.arguments[0])) {
+            result = node.arguments[0];
+            return;
+        }
+        if (typescript_1.default.isExportAssignment(node) && !node.isExportEquals) {
+            let expr = node.expression;
+            if (typescript_1.default.isAsExpression(expr))
+                expr = expr.expression;
+            if (typescript_1.default.isObjectLiteralExpression(expr)) {
+                result = expr;
+                return;
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return result;
+}
+// ─── Lightweight AST evaluator ───────────────────────────────────────
+function evalNode(node) {
+    if (typescript_1.default.isNumericLiteral(node))
+        return Number(node.text);
+    if (typescript_1.default.isStringLiteral(node))
+        return node.text;
+    if (node.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+        return false;
+    if (typescript_1.default.isObjectLiteralExpression(node))
+        return evalObj(node);
+    if (typescript_1.default.isArrayLiteralExpression(node))
+        return node.elements.map(evalNode);
+    if (typescript_1.default.isBinaryExpression(node)) {
+        const l = evalNode(node.left);
+        const r = evalNode(node.right);
+        if (typeof l === "number" && typeof r === "number") {
+            if (node.operatorToken.kind === typescript_1.default.SyntaxKind.AsteriskToken)
+                return l * r;
+            if (node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken)
+                return l + r;
+        }
+        return node.getText();
+    }
+    if (typescript_1.default.isConditionalExpression(node))
+        return node.getText();
+    if (typescript_1.default.isPropertyAccessExpression(node))
+        return node.getText();
+    if (typescript_1.default.isParenthesizedExpression(node))
+        return evalNode(node.expression);
+    return node.getText();
+}
+function evalObj(node) {
+    const result = {};
+    for (const prop of node.properties) {
+        if (typescript_1.default.isPropertyAssignment(prop) && typescript_1.default.isIdentifier(prop.name)) {
+            result[prop.name.text] = evalNode(prop.initializer);
+        }
+    }
+    return result;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────
+function asNum(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    return undefined;
+}
+function asStr(v) {
+    if (typeof v === "string")
+        return v;
+    return undefined;
+}
+function asBool(v) {
+    if (typeof v === "boolean")
+        return v;
+    return undefined;
+}
+function parseRetries(v) {
+    if (typeof v === "number")
+        return { runMode: v, openMode: 0 };
+    if (v && typeof v === "object") {
+        return {
+            runMode: asNum(v.runMode),
+            openMode: asNum(v.openMode),
+        };
+    }
+    return undefined;
+}