@qulib/core 0.7.0 → 0.9.0

package/dist/adapters/cypress-e2e-adapter.js

@@ -38,15 +38,38 @@ function renderStep(step) {
             return `    // TODO: ${step.description}`;
     }
 }
+/**
+ * Render a recipe-specific step override for Cypress.
+ * Returns null when no override applies — falls through to renderStep.
+ */
+function renderRecipeStep(step, scenario) {
+    const tags = scenario.tags ?? [];
+    // a11y recipe: title assertion — cy.title() instead of cy.get('title')
+    if (tags.includes('recipe-a11y') && step.action === 'assert-text' && step.target === 'title') {
+        return `    cy.title().should('not.be.empty');`;
+    }
+    // a11y recipe: nav count using proper Cypress assertion
+    if (tags.includes('recipe-a11y') && step.action === 'assert-count') {
+        const t = step.target != null ? JSON.stringify(step.target) : null;
+        if (t) {
+            return `    cy.get(${t}).its('length').should('be.gte', ${parseInt(step.value ?? '1', 10)});`;
+        }
+    }
+    return null;
+}
 export class CypressE2EAdapter {
     adapterType = 'cypress-e2e';
     render(scenario) {
         const slug = slugify(scenario.title);
         const filename = `${slug}.cy.ts`;
-        const stepLines = scenario.steps.map(renderStep).join('\n');
+        const stepLines = scenario.steps
+            .map((step) => renderRecipeStep(step, scenario) ?? renderStep(step))
+            .join('\n');
+        const recipeTag = (scenario.tags ?? []).find((t) => t.startsWith('recipe-'));
+        const recipeComment = recipeTag ? `\n// recipe: ${recipeTag.replace('recipe-', '')}` : '';
         const code = [
             `// ${scenario.description}`,
-            `// qulib-generated — scenario: ${scenario.id}`,
+            `// qulib-generated — scenario: ${scenario.id}${recipeComment}`,
             ``,
             `describe(${JSON.stringify(scenario.title)}, () => {`,
             `  it(${JSON.stringify(scenario.description)}, () => {`,

package/dist/adapters/playwright-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playwright-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/playwright-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAExF,qBAAa,iBAAkB,YAAW,WAAW;IACnD,QAAQ,CAAC,WAAW,gBAAgB;IAEpC,MAAM,CAAC,QAAQ,EAAE,eAAe,GAAG,aAAa;IAIhD,SAAS,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,aAAa,EAAE;CAGzD"}
+{"version":3,"file":"playwright-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/playwright-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAY,MAAM,mCAAmC,CAAC;AAqElG,qBAAa,iBAAkB,YAAW,WAAW;IACnD,QAAQ,CAAC,WAAW,gBAAgB;IAEpC,MAAM,CAAC,QAAQ,EAAE,eAAe,GAAG,aAAa;IAmChD,SAAS,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,aAAa,EAAE;CAGzD"}

package/dist/adapters/playwright-adapter.js

@@ -1,9 +1,101 @@
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function renderStep(step) {
+    const t = step.target != null ? JSON.stringify(step.target) : null;
+    const v = step.value != null ? JSON.stringify(step.value) : null;
+    switch (step.action) {
+        case 'navigate':
+            return `    await page.goto(${JSON.stringify(step.target ?? step.value ?? '/')});`;
+        case 'click':
+            return t ? `    await page.locator(${t}).click();` : `    // click: ${step.description}`;
+        case 'type':
+            return t && v ? `    await page.locator(${t}).fill(${v});` : `    // type: ${step.description}`;
+        case 'assert-visible':
+            return t
+                ? `    await expect(page.locator(${t})).toBeVisible();`
+                : `    await expect(page.locator('body')).toBeVisible();`;
+        case 'assert-hidden':
+            return t
+                ? `    await expect(page.locator(${t})).toBeHidden();`
+                : `    // assert-hidden: ${step.description}`;
+        case 'assert-text':
+            if (t && v)
+                return `    await expect(page.locator(${t})).toContainText(${v});`;
+            if (t)
+                return `    await expect(page.locator(${t})).not.toBeEmpty();`;
+            return `    // assert-text: ${step.description}`;
+        case 'assert-disabled':
+            return t
+                ? `    await expect(page.locator(${t})).toBeDisabled();`
+                : `    // assert-disabled: ${step.description}`;
+        case 'assert-count':
+            return t
+                ? `    expect(await page.locator(${t}).count()).toBeGreaterThanOrEqual(${parseInt(step.value ?? '1', 10)});`
+                : `    // assert-count: ${step.description}`;
+        case 'wait':
+            return `    await page.waitForTimeout(${parseInt(step.value ?? '1000', 10)});`;
+        case 'api-call':
+            return `    expect((await page.request.get(${JSON.stringify(step.target ?? step.value ?? '/')})).status()).toBe(200);`;
+        default:
+            return `    // TODO: ${step.description}`;
+    }
+}
+/**
+ * Render a recipe-specific step override for Playwright.
+ * Returns null when no override applies — falls through to renderStep.
+ */
+function renderRecipeStep(step, scenario) {
+    const tags = scenario.tags ?? [];
+    // a11y recipe: title assertion — page.title() instead of page.locator('title')
+    if (tags.includes('recipe-a11y') && step.action === 'assert-text' && step.target === 'title') {
+        return `    expect(await page.title()).not.toBe('');`;
+    }
+    // a11y recipe: nav count using Playwright count()
+    if (tags.includes('recipe-a11y') && step.action === 'assert-count') {
+        const t = step.target != null ? JSON.stringify(step.target) : null;
+        if (t) {
+            return `    expect(await page.locator(${t}).count()).toBeGreaterThanOrEqual(${parseInt(step.value ?? '1', 10)});`;
+        }
+    }
+    return null;
+}
 export class PlaywrightAdapter {
     adapterType = 'playwright';
     render(scenario) {
-        throw new Error('Not implemented');
+        const slug = slugify(scenario.title);
+        const filename = `${slug}.spec.ts`;
+        const stepLines = scenario.steps
+            .map((step) => renderRecipeStep(step, scenario) ?? renderStep(step))
+            .join('\n');
+        const recipeTag = (scenario.tags ?? []).find((t) => t.startsWith('recipe-'));
+        const recipeComment = recipeTag ? `\n// recipe: ${recipeTag.replace('recipe-', '')}` : '';
+        const code = [
+            `// ${scenario.description}`,
+            `// qulib-generated — scenario: ${scenario.id}${recipeComment}`,
+            ``,
+            `import { test, expect } from '@playwright/test';`,
+            ``,
+            `test.describe(${JSON.stringify(scenario.title)}, () => {`,
+            `  test(${JSON.stringify(scenario.description)}, async ({ page }) => {`,
+            stepLines || `    // no steps — add assertions for: ${scenario.targetPath}`,
+            `  });`,
+            `});`,
+            ``,
+        ].join('\n');
+        return {
+            scenarioId: scenario.id,
+            adapter: 'playwright',
+            filename,
+            code,
+            source: 'template',
+            outputPath: `tests/${filename}`,
+        };
     }
     renderAll(scenarios) {
-        throw new Error('Not implemented');
+        return scenarios.map((s) => this.render(s));
     }
 }

package/dist/adapters/pr-metadata-adapter.d.ts

@@ -0,0 +1,75 @@
+/**
+ * PR-metadata evidence adapter (P4 — evidence collectors).
+ *
+ * Maps a pull-request review/checks payload (as returned by `gh pr view --json
+ * reviewDecision,statusCheckRollup,mergeable,number,url,additions,deletions`)
+ * into an `EvidenceItem` for `computeReleaseConfidence`, using the
+ * `deploy-metadata` source kind — the closest P3-reserved kind for
+ * PR-level ship-readiness.
+ *
+ * Design:
+ *   - Pure function. The caller fetches the `gh` JSON; this adapter scores it.
+ *   - Applicability:
+ *       `applicable`     — a PR exists and review/check state is readable
+ *       `not_applicable` — no PR for this ref (direct push, script, etc.)
+ *       `unknown`        — PR exists but checks are still pending / state ambiguous
+ *   - Score formula (0..100):
+ *       Base 60 points:  PR is open and merge-ready (no conflicts)
+ *       +20: reviewDecision === 'APPROVED'
+ *       +20: all status checks pass (statusCheckRollup every entry state === 'SUCCESS')
+ *       Deductions:
+ *         -10: any failing status check  (per failing check, capped at 20)
+ *         -15: reviewDecision === 'CHANGES_REQUESTED'
+ *   - The adapter NEVER fabricates a PR number or URL; if absent from the payload
+ *     the evidence strings omit them (WAVE-GUARDRAILS: no fabricated data).
+ */
+import type { EvidenceItem } from '../schemas/confidence.schema.js';
+/**
+ * Status-check entry shape from `gh pr view --json statusCheckRollup`.
+ * Only the fields we actually use — extra fields are harmlessly ignored.
+ */
+export interface StatusCheck {
+    /** e.g. "SUCCESS", "FAILURE", "PENDING", "SKIPPED", "NEUTRAL" */
+    state: string;
+    /** CI job/check name — optional, used for the evidence string */
+    name?: string;
+    /** Direct URL to the check — never fabricated; omit rather than invent */
+    targetUrl?: string;
+}
+/** GitHub review decision values as returned by the `gh` CLI. */
+export type ReviewDecision = 'APPROVED' | 'CHANGES_REQUESTED' | 'REVIEW_REQUIRED' | null | undefined;
+/** Mergeable state as returned by `gh pr view --json mergeable`. */
+export type MergeableState = 'MERGEABLE' | 'CONFLICTING' | 'UNKNOWN' | null | undefined;
+/**
+ * Raw PR payload the caller provides. All fields are optional — the adapter
+ * degrades gracefully when partial data is available.
+ */
+export interface PrMetadataInput {
+    /** PR number. Never fabricated — omit if absent. */
+    number?: number;
+    /** PR URL. Never fabricated — omit if absent. */
+    url?: string;
+    /** Review decision from the `gh` response. null/undefined = no review yet. */
+    reviewDecision?: ReviewDecision;
+    /** Array of status check entries (the `statusCheckRollup` field). */
+    statusCheckRollup?: StatusCheck[];
+    /**
+     * Whether the PR is currently mergeable (no conflicts).
+     * null/UNKNOWN counts as unknown-state.
+     */
+    mergeable?: MergeableState;
+    /** ISO-8601 when this payload was collected. Defaults to now. */
+    collectedAt?: string;
+    /**
+     * Set to true when there is explicitly NO PR for this ref (e.g. direct push).
+     * Produces a `not_applicable` contribution so the aggregator abstains honestly.
+     */
+    noPr?: boolean;
+}
+/**
+ * Produce a `deploy-metadata` EvidenceItem from a PR metadata payload.
+ * Returns `not_applicable` when `noPr` is true, `unknown` when checks are
+ * pending or state is ambiguous, and `applicable` with a real score otherwise.
+ */
+export declare function prMetadataToEvidence(input: PrMetadataInput, collectedAt?: string): EvidenceItem;
+//# sourceMappingURL=pr-metadata-adapter.d.ts.map

package/dist/adapters/pr-metadata-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pr-metadata-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/pr-metadata-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,iCAAiC,CAAC;AAIxF;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,iEAAiE;AACjE,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,IAAI,GAAG,SAAS,CAAC;AAErG,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,GAAG,IAAI,GAAG,SAAS,CAAC;AAExF;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,WAAW,EAAE,CAAC;IAClC;;;OAGG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CA+H/F"}

package/dist/adapters/pr-metadata-adapter.js

@@ -0,0 +1,146 @@
+/**
+ * PR-metadata evidence adapter (P4 — evidence collectors).
+ *
+ * Maps a pull-request review/checks payload (as returned by `gh pr view --json
+ * reviewDecision,statusCheckRollup,mergeable,number,url,additions,deletions`)
+ * into an `EvidenceItem` for `computeReleaseConfidence`, using the
+ * `deploy-metadata` source kind — the closest P3-reserved kind for
+ * PR-level ship-readiness.
+ *
+ * Design:
+ *   - Pure function. The caller fetches the `gh` JSON; this adapter scores it.
+ *   - Applicability:
+ *       `applicable`     — a PR exists and review/check state is readable
+ *       `not_applicable` — no PR for this ref (direct push, script, etc.)
+ *       `unknown`        — PR exists but checks are still pending / state ambiguous
+ *   - Score formula (0..100):
+ *       Base 60 points:  PR is open and merge-ready (no conflicts)
+ *       +20: reviewDecision === 'APPROVED'
+ *       +20: all status checks pass (statusCheckRollup every entry state === 'SUCCESS')
+ *       Deductions:
+ *         -10: any failing status check  (per failing check, capped at 20)
+ *         -15: reviewDecision === 'CHANGES_REQUESTED'
+ *   - The adapter NEVER fabricates a PR number or URL; if absent from the payload
+ *     the evidence strings omit them (WAVE-GUARDRAILS: no fabricated data).
+ */
+const PR_META_WEIGHT = 0.07; // conservative; real weight rebalanced by the aggregator
+/**
+ * Produce a `deploy-metadata` EvidenceItem from a PR metadata payload.
+ * Returns `not_applicable` when `noPr` is true, `unknown` when checks are
+ * pending or state is ambiguous, and `applicable` with a real score otherwise.
+ */
+export function prMetadataToEvidence(input, collectedAt) {
+    const now = collectedAt ?? input.collectedAt ?? new Date().toISOString();
+    const source = 'deploy-metadata';
+    const weight = PR_META_WEIGHT;
+    // Explicit no-PR case.
+    if (input.noPr) {
+        return {
+            source,
+            score: 0,
+            weight,
+            applicability: 'not_applicable',
+            blocking: false,
+            evidence: ['No pull request exists for this ref (direct push or pre-PR state).'],
+            recommendations: [],
+            reason: 'No PR for this ref — PR review and check signal not applicable.',
+            collectedAt: now,
+            collector: { tool: 'qulib.pr-metadata-adapter' },
+        };
+    }
+    const prLabel = input.number != null ? `PR #${input.number}` : 'PR';
+    const prRef = input.url ?? null;
+    // Checks-pending / UNKNOWN mergeable → unknown applicability (cannot score honestly).
+    const allChecks = input.statusCheckRollup ?? [];
+    const pending = allChecks.filter((c) => c.state === 'PENDING');
+    if ((pending.length > 0 && allChecks.length > 0 && pending.length === allChecks.length) ||
+        input.mergeable === 'UNKNOWN') {
+        const evidence = [
+            `${prLabel}: status checks still pending (${pending.length}/${allChecks.length}).`,
+            ...(prRef ? [`${prRef}`] : []),
+        ];
+        return {
+            source,
+            score: 0,
+            weight,
+            applicability: 'unknown',
+            blocking: false,
+            evidence,
+            recommendations: ['Wait for all status checks to complete before shipping.'],
+            reason: `${prLabel} checks are still pending — cannot score PR readiness honestly.`,
+            collectedAt: now,
+            collector: { tool: 'qulib.pr-metadata-adapter', inputRef: prRef ?? undefined },
+        };
+    }
+    // Score computation.
+    let score = 60; // base: a PR exists and is evaluable
+    // Mergeability.
+    if (input.mergeable === 'CONFLICTING') {
+        score -= 30; // merge conflicts are a hard deduction
+    }
+    // Review decision.
+    const rd = input.reviewDecision;
+    if (rd === 'APPROVED') {
+        score += 20;
+    }
+    else if (rd === 'CHANGES_REQUESTED') {
+        score -= 15;
+    }
+    // REVIEW_REQUIRED or null/undefined: no bonus, no deduction (reviewer not yet assigned)
+    // Status checks.
+    const passing = allChecks.filter((c) => c.state === 'SUCCESS' || c.state === 'NEUTRAL' || c.state === 'SKIPPED');
+    const failing = allChecks.filter((c) => c.state === 'FAILURE' || c.state === 'ERROR');
+    if (allChecks.length > 0 && failing.length === 0) {
+        score += 20; // all checks green
+    }
+    // Deduct per failing check (capped at −20).
+    score -= Math.min(20, failing.length * 10);
+    score = Math.max(0, Math.min(100, score));
+    // Build evidence strings — never fabricated.
+    const evidence = [];
+    const reviewStr = rd === 'APPROVED'
+        ? 'APPROVED'
+        : rd === 'CHANGES_REQUESTED'
+            ? 'CHANGES_REQUESTED'
+            : rd === 'REVIEW_REQUIRED'
+                ? 'REVIEW_REQUIRED'
+                : 'no review yet';
+    const mergeStr = input.mergeable === 'MERGEABLE'
+        ? 'mergeable'
+        : input.mergeable === 'CONFLICTING'
+            ? 'CONFLICTING (merge conflicts)'
+            : 'merge state unknown';
+    evidence.push(`${prLabel}: review=${reviewStr}, ${mergeStr}.`);
+    if (allChecks.length > 0) {
+        evidence.push(`Status checks: ${passing.length} passed, ${failing.length} failed, ${pending.length} pending of ${allChecks.length} total.`);
+        for (const f of failing.slice(0, 3)) {
+            evidence.push(`  Check FAILED: ${f.name ?? 'unnamed'}${f.targetUrl ? ` (${f.targetUrl})` : ''}`);
+        }
+    }
+    else {
+        evidence.push('No status checks configured for this PR.');
+    }
+    if (prRef)
+        evidence.push(prRef);
+    // Recommendations.
+    const recommendations = [];
+    if (rd === 'CHANGES_REQUESTED')
+        recommendations.push('Address review comments before shipping.');
+    if (rd === 'REVIEW_REQUIRED' || rd == null)
+        recommendations.push('Request and obtain PR approval before shipping.');
+    if (failing.length > 0)
+        recommendations.push(`Fix ${failing.length} failing status check(s) before merging.`);
+    if (input.mergeable === 'CONFLICTING')
+        recommendations.push('Resolve merge conflicts before shipping.');
+    return {
+        source,
+        score,
+        weight,
+        applicability: 'applicable',
+        blocking: false,
+        evidence,
+        recommendations,
+        collectedAt: now,
+        collector: { tool: 'qulib.pr-metadata-adapter', inputRef: prRef ?? undefined },
+    };
+}

package/dist/adapters/validate-specs.d.ts

@@ -0,0 +1,55 @@
+import type { GeneratedTest } from '../schemas/gap-analysis.schema.js';
+/**
+ * Per-spec validation outcome from the scaffold dry-run.
+ *
+ * `valid: false` means the TypeScript compiler reported one or more *syntactic*
+ * errors when transpiling the generated spec as a standalone module — i.e. the
+ * generator emitted code that will not parse, so it would fail the moment a
+ * developer ran the test suite. `errors` carries the flattened compiler
+ * messages so the failure is actionable, not just a boolean.
+ */
+export interface SpecValidation {
+    scenarioId: string;
+    filename: string;
+    outputPath: string;
+    valid: boolean;
+    errors: string[];
+}
+/** Aggregate result of validating every generated spec in a scaffold run. */
+export interface SpecValidationReport {
+    ok: boolean;
+    total: number;
+    invalidCount: number;
+    results: SpecValidation[];
+}
+/**
+ * Dry-run a single generated spec through the TypeScript compiler.
+ *
+ * `transpileModule` performs single-file syntax transformation only — no type
+ * checking, no module resolution — so it is the right tool to answer the one
+ * question the scaffold must not get wrong: *does the string we are about to
+ * write to disk actually parse as TypeScript?* A clean run (zero error-category
+ * diagnostics AND non-empty output) means the spec is syntactically valid; any
+ * error diagnostic means the generator produced broken code.
+ *
+ * We deliberately do NOT resolve `@playwright/test` / Cypress globals here:
+ * those are type-level concerns that require the consumer's node_modules. The
+ * gap this closes is *parse/compile-shape*, which is generator-local and cheap
+ * to check at scaffold time.
+ */
+export declare function validateSpecCode(code: string): {
+    valid: boolean;
+    errors: string[];
+};
+/** Validate one GeneratedTest, returning a structured per-spec outcome. */
+export declare function validateGeneratedTest(test: GeneratedTest): SpecValidation;
+/**
+ * Validate every generated spec in a scaffold run.
+ *
+ * `ok` is true only when *all* specs parse. This is the gate the CLI consults
+ * to decide its exit code: a scaffold that writes a spec which cannot parse is a
+ * silent correctness failure, and the whole point of the dry-run is to catch it
+ * before the developer does.
+ */
+export declare function validateGeneratedTests(tests: GeneratedTest[]): SpecValidationReport;
+//# sourceMappingURL=validate-specs.d.ts.map

package/dist/adapters/validate-specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-specs.d.ts","sourceRoot":"","sources":["../../src/adapters/validate-specs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEvE;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA2BnF;AAED,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,CASzE;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,oBAAoB,CASnF"}

package/dist/adapters/validate-specs.js

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+/**
+ * Dry-run a single generated spec through the TypeScript compiler.
+ *
+ * `transpileModule` performs single-file syntax transformation only — no type
+ * checking, no module resolution — so it is the right tool to answer the one
+ * question the scaffold must not get wrong: *does the string we are about to
+ * write to disk actually parse as TypeScript?* A clean run (zero error-category
+ * diagnostics AND non-empty output) means the spec is syntactically valid; any
+ * error diagnostic means the generator produced broken code.
+ *
+ * We deliberately do NOT resolve `@playwright/test` / Cypress globals here:
+ * those are type-level concerns that require the consumer's node_modules. The
+ * gap this closes is *parse/compile-shape*, which is generator-local and cheap
+ * to check at scaffold time.
+ */
+export function validateSpecCode(code) {
+    const result = ts.transpileModule(code, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2020,
+            // isolatedModules keeps this a pure syntax pass and surfaces
+            // single-file-illegal constructs, matching how a bundler would see it.
+            isolatedModules: true,
+        },
+        reportDiagnostics: true,
+    });
+    const errorDiagnostics = (result.diagnostics ?? []).filter((d) => d.category === ts.DiagnosticCategory.Error);
+    const errors = errorDiagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, '\n'));
+    // A clean transpile yields output text. Empty output with no diagnostics would
+    // be suspicious, so treat it as invalid too rather than silently passing.
+    const producedOutput = result.outputText.trim().length > 0;
+    const valid = errors.length === 0 && producedOutput;
+    if (!valid && errors.length === 0) {
+        errors.push('transpile produced no output for a non-empty spec');
+    }
+    return { valid, errors };
+}
+/** Validate one GeneratedTest, returning a structured per-spec outcome. */
+export function validateGeneratedTest(test) {
+    const { valid, errors } = validateSpecCode(test.code);
+    return {
+        scenarioId: test.scenarioId,
+        filename: test.filename,
+        outputPath: test.outputPath,
+        valid,
+        errors,
+    };
+}
+/**
+ * Validate every generated spec in a scaffold run.
+ *
+ * `ok` is true only when *all* specs parse. This is the gate the CLI consults
+ * to decide its exit code: a scaffold that writes a spec which cannot parse is a
+ * silent correctness failure, and the whole point of the dry-run is to catch it
+ * before the developer does.
+ */
+export function validateGeneratedTests(tests) {
+    const results = tests.map(validateGeneratedTest);
+    const invalidCount = results.filter((r) => !r.valid).length;
+    return {
+        ok: invalidCount === 0,
+        total: results.length,
+        invalidCount,
+        results,
+    };
+}

package/dist/baseline/baseline.d.ts

@@ -0,0 +1,54 @@
+import type { GapAnalysis } from '../schemas/gap-analysis.schema.js';
+import { type BaselineSnapshot, type BaselineDelta } from './baseline.schema.js';
+/**
+ * Produce a filesystem-safe slug from a URL.
+ * e.g. "https://my-app.vercel.app/admin" → "my-app_vercel_app__admin"
+ */
+export declare function slugifyUrl(url: string): string;
+/**
+ * Return the default root for baseline storage: `<cwd>/.qulib-baselines`.
+ * Callers may supply an explicit `baseDir` to override.
+ */
+export declare function defaultBaselineRoot(): string;
+/**
+ * Save a baseline snapshot derived from the given `GapAnalysis` result.
+ *
+ * @returns The saved snapshot.
+ */
+export declare function saveBaseline(analysis: GapAnalysis, url: string, options?: {
+    baseDir?: string;
+    label?: string;
+}): Promise<BaselineSnapshot>;
+/**
+ * Load a specific baseline snapshot by its `id`.
+ *
+ * @throws If the file does not exist or fails schema validation.
+ */
+export declare function loadBaseline(id: string, options?: {
+    baseDir?: string;
+}): Promise<BaselineSnapshot>;
+/**
+ * List all saved baselines for the given URL, sorted newest-first.
+ *
+ * Returns an empty array if no baselines exist yet.
+ */
+export declare function listBaselines(url: string, options?: {
+    baseDir?: string;
+}): Promise<BaselineSnapshot[]>;
+/**
+ * Delete a specific baseline snapshot by its `id`.
+ *
+ * @throws If the file does not exist.
+ */
+export declare function deleteBaseline(id: string, options?: {
+    baseDir?: string;
+}): Promise<void>;
+/**
+ * Compare two baseline snapshots and return a structured delta report.
+ *
+ * - `newGaps`: problems present in `current` but not in `prior`.
+ * - `resolvedGaps`: problems present in `prior` but no longer in `current`.
+ * - `severityChanges`: same problem (matching key) with a different severity.
+ */
+export declare function compareBaselines(prior: BaselineSnapshot, current: BaselineSnapshot): BaselineDelta;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/baseline/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../../src/baseline/baseline.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAO,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,sBAAsB,CAAC;AAY9B;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAeD;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,WAAW,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACjD,OAAO,CAAC,gBAAgB,CAAC,CA0B3B;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAuB5G;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACjC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoC7B;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAclG;AAcD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,GAAG,aAAa,CAiFlG"}