@taodigital/agents 0.0.0-stage → 1.2.1

package/dist/step-coverage.d.ts

@@ -0,0 +1,46 @@
+export interface StepCoverageItem {
+    index: number;
+    step: string;
+    kind: 'navigation' | 'action' | 'assertion';
+    covered: boolean;
+    /** 0..1 weighted token overlap with the best matching statement. */
+    confidence: number;
+    /** 1-based line in the supplied code of the best matching statement. */
+    matchedLine?: number;
+    matchedStatement?: string;
+    /** Present when the step carries its own expected result. */
+    expected?: {
+        text: string;
+        covered: boolean;
+        matchedLine?: number;
+        matchedStatement?: string;
+    };
+}
+export interface StepCoverageResult {
+    method: 'token-overlap-v1';
+    totalSteps: number;
+    coveredSteps: number;
+    /** covered ÷ total × 100, rounded to 1 decimal. 0 when the test case has no steps. */
+    coveragePct: number;
+    /** Expected results (test-level + per-step) matched by an assertion; null when none are defined. */
+    assertionCoverage: {
+        total: number;
+        covered: number;
+        pct: number;
+    } | null;
+    expectedResult?: {
+        text: string;
+        covered: boolean;
+        matchedLine?: number;
+        matchedStatement?: string;
+    };
+    uncoveredSteps: number[];
+    perStep: StepCoverageItem[];
+}
+export declare function computeStepCoverage(opts: {
+    steps: unknown[];
+    expectedResult?: string | null;
+    code: string;
+}): StepCoverageResult;
+/** Aggregate helper used by reports: average of non-null percentages. */
+export declare function averageStepCoverage(values: Array<number | null | undefined>): number | null;

package/dist/step-coverage.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStepCoverage = computeStepCoverage;
+exports.averageStepCoverage = averageStepCoverage;
+/**
+ * Deterministic step-coverage metric for generated automation scripts.
+ *
+ *   stepCoveragePct = covered test-case steps ÷ total test-case steps × 100
+ *
+ * Unlike the LLM-judged alignment score (verifyScriptAlignment), this is a pure function:
+ * the same steps + code always produce the same result, and every decision is explainable
+ * (each step is mapped to the script statement that implements it, or reported as uncovered).
+ *
+ * Method (token-overlap-v1):
+ *  1. Extract executable statements from the script (actions/assertions/page calls, Gherkin
+ *     steps, Java/Python calls). Comments, imports, test titles and declarations are skipped.
+ *  2. Tokenise each step and statement: split camelCase / snake_case / string literals,
+ *     lowercase, drop stop words and code-structure noise, canonicalise verb synonyms
+ *     (type/enter/fill → fill, press/tap/click → click, open/go/visit → navigate, …).
+ *  3. A step is covered when a statement (or two adjacent statements) matches at least one
+ *     content token AND a weighted share (content=1, intent verb=0.5) of the step's tokens.
+ *  4. Expected results (test-level and per-step) are checked against assertion statements only.
+ */
+const step_utils_js_1 = require("./step-utils.js");
+const STOP = new Set([
+    'the', 'a', 'an', 'to', 'of', 'on', 'in', 'into', 'and', 'or', 'with', 'for', 'from', 'then', 'that', 'is', 'are',
+    'be', 'been', 'should', 'will', 'shall', 'can', 'it', 'its', 'this', 'these', 'those', 'at', 'by', 'as', 'user',
+    'page', 'screen', 'application', 'app', 'button', 'field', 'box', 'element', 'textbox', 'input', 'link', 'tab',
+    'given', 'when', 'and', 'but', 'so', 'now', 'has', 'have', 'had', 'does', 'do', 'not', 'no', 'all', 'any',
+    // code-structure noise
+    'await', 'async', 'const', 'let', 'var', 'new', 'return', 'this', 'self', 'actions', 'assertions', 'action',
+    'assertion', 'locator', 'locators', 'getby', 'role', 'name', 'exact', 'first', 'last', 'nth', 'driver', 'find',
+    'by', 'id', 'css', 'xpath', 'void', 'public', 'private', 'string', 'null', 'true', 'false', 'timeout', 'env',
+    'process', 'td', 'testdata', 'data', 'wait', 'text', 'label', 'placeholder', 'testid', 'title',
+]);
+// Canonical verb / noun synonyms. Keys are post-lowercase words; values are canonical tokens.
+const SYNONYMS = {
+    click: 'click', press: 'click', tap: 'click', hit: 'click', push: 'click', choose: 'select', pick: 'select',
+    select: 'select', enter: 'fill', type: 'fill', fill: 'fill', input: 'fill', provide: 'fill', write: 'fill',
+    set: 'fill', populate: 'fill', navigate: 'navigate', open: 'navigate', go: 'navigate', goto: 'navigate',
+    visit: 'navigate', launch: 'navigate', load: 'navigate', browse: 'navigate', verify: 'assert', assert: 'assert',
+    ensure: 'assert', confirm: 'assert', validate: 'assert', expect: 'assert', see: 'assert', displayed: 'assert',
+    display: 'assert', visible: 'assert', shown: 'assert', show: 'assert', appears: 'assert', appear: 'assert',
+    present: 'assert', contain: 'assert', contains: 'assert', equal: 'assert', equals: 'assert', have: 'assert',
+    upload: 'upload', attach: 'upload', hover: 'hover', mouseover: 'hover', signin: 'login', login: 'login',
+    logon: 'login', signout: 'logout', logout: 'logout', logoff: 'logout', submit: 'submit', save: 'submit',
+    checkbox: 'check', tick: 'check', untick: 'uncheck', uncheck: 'uncheck', dropdown: 'select', drop: 'select',
+    password: 'password', passwd: 'password', pwd: 'password', username: 'username', user_name: 'username',
+    email: 'email', mail: 'email', error: 'error', errors: 'error', message: 'message', msg: 'message',
+    redirect: 'url', redirected: 'url', redirects: 'url', url: 'url', dashboard: 'dashboard', home: 'home',
+};
+/** Verbs that describe intent but not subject matter. Weighted lower than content tokens. */
+const INTENT = new Set(['click', 'fill', 'navigate', 'assert', 'select', 'upload', 'hover', 'check', 'uncheck', 'submit']);
+const ASSERT_WORDS = new Set(['assert', 'verify', 'ensure', 'confirm', 'validate', 'expect', 'see', 'displayed',
+    'visible', 'shown', 'appear', 'appears', 'present', 'contains', 'contain', 'equals', 'redirected', 'redirects']);
+function stem(w) {
+    if (w.length > 5 && w.endsWith('ing'))
+        return w.slice(0, -3);
+    if (w.length > 5 && w.endsWith('ies'))
+        return w.slice(0, -3) + 'y';
+    if (w.length > 4 && w.endsWith('ed'))
+        return w.slice(0, -2);
+    if (w.length > 4 && w.endsWith('es'))
+        return w.slice(0, -2);
+    if (w.length > 3 && w.endsWith('s') && !w.endsWith('ss'))
+        return w.slice(0, -1);
+    return w;
+}
+function splitWords(text) {
+    return text
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // camelCase
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2') // HTMLParser → HTML Parser
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+function canon(word) {
+    if (!word || word.length < 2)
+        return null;
+    if (STOP.has(word))
+        return null;
+    const direct = SYNONYMS[word];
+    if (direct)
+        return direct;
+    const st = stem(word);
+    if (STOP.has(st))
+        return null;
+    return SYNONYMS[st] ?? st;
+}
+function tokenize(text) {
+    const out = new Set();
+    for (const w of splitWords(text)) {
+        const c = canon(w);
+        if (c)
+            out.add(c);
+    }
+    return out;
+}
+const ASSERTION_RE = /\bexpect\s*\(|\.should\b|\bassert\w*|\bverify\w*|\bensure\w*|\btoBe\w*|\btoHave\w*|\btoContain\w*|\btoEqual\w*|\bassertions?\./i;
+const NAVIGATION_RE = /\bgoto\s*\(|\.goto\b|\bnavigate\w*\s*\(|\bvisit\s*\(|\bopen(Page|Url|App)?\s*\(|driver\.get\s*\(|\bcy\.visit\b|\bpage\.open\b/i;
+const SKIP_LINE_RE = /^(\s*$|\s*\/\/|\s*#|\s*\*|\s*\/\*|import\s|from\s+\S+\s+import|require\(|export\s+(type|interface)|package\s|@Test|@BeforeMethod|@AfterMethod|@pytest|@Display|test\.(describe|beforeEach|afterEach|use)\b|describe\s*\(|\btest\s*\(\s*['"`]|\bit\s*\(\s*['"`]|def\s+test_|\}\)?;?\s*$|\{\s*$|Feature:|Scenario|Background:|@\w+\s*$)/;
+const DECL_RE = /^\s*(public|private|protected|async|static|function|def|class|interface|type|export\s+(default\s+)?(class|function|const\s+\w+\s*=\s*(async\s*)?\())\b[^=;]*\{?\s*$/;
+function extractStatements(code) {
+    const out = [];
+    const lines = code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const isGherkinStep = /^(Given|When|Then|And|But)\s+\S/.test(line);
+        if (!isGherkinStep && (SKIP_LINE_RE.test(line) || DECL_RE.test(line)))
+            continue;
+        // A statement has to *do* something: a call, an assignment from a call, or a gherkin step.
+        if (!isGherkinStep && !/[A-Za-z_$][\w$]*\s*\(/.test(line))
+            continue;
+        const kind = ASSERTION_RE.test(line) || /^(Then)\b/.test(line)
+            ? 'assertion'
+            : NAVIGATION_RE.test(line) ? 'navigation' : 'action';
+        const tokens = tokenize(line);
+        if (tokens.size === 0)
+            continue;
+        out.push({ line: i + 1, text: line, kind, tokens });
+    }
+    return out;
+}
+function stepInfo(raw) {
+    let expected;
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const o = raw;
+        const e = o.expected ?? o.expectedResult;
+        if (e != null && String(e).trim())
+            expected = (0, step_utils_js_1.stepToText)(e);
+        // Include the step's data so literals ("admin@x.com") count as content tokens.
+        const action = (0, step_utils_js_1.stepToText)({ action: o.action, text: o.text });
+        const data = o.data != null && typeof o.data !== 'object' ? String(o.data) : '';
+        const text = [action, data].filter(Boolean).join(' ').trim() || (0, step_utils_js_1.stepToText)(raw);
+        return { text, expected };
+    }
+    return { text: (0, step_utils_js_1.stepToText)(raw) };
+}
+function stepKind(text, tokens) {
+    const words = splitWords(text);
+    if (words.some((w) => ASSERT_WORDS.has(w)))
+        return 'assertion';
+    if (tokens.has('navigate') && /\b(navigate|open|go to|visit|launch|browse|load)\b/i.test(text))
+        return 'navigation';
+    return 'action';
+}
+function score(stepTokens, stmtTokens) {
+    let contentCount = 0, intentCount = 0, contentHits = 0, intentHits = 0;
+    for (const t of stepTokens) {
+        const isIntent = INTENT.has(t);
+        if (isIntent)
+            intentCount++;
+        else
+            contentCount++;
+        if (stmtTokens.has(t)) {
+            if (isIntent)
+                intentHits++;
+            else
+                contentHits++;
+        }
+    }
+    const denom = contentCount + 0.5 * intentCount;
+    const num = contentHits + 0.5 * intentHits;
+    return { score: denom === 0 ? 0 : num / denom, contentHits, intentHits, contentCount, intentCount };
+}
+function isMatch(s, minScore) {
+    if (s.contentCount > 0)
+        return s.contentHits >= 1 && s.score >= minScore;
+    return s.intentHits >= 1 && s.score >= Math.max(minScore, 0.5);
+}
+function windows(statements) {
+    const out = [];
+    for (let i = 0; i < statements.length; i++) {
+        out.push({ statement: statements[i], tokens: statements[i].tokens });
+        const next = statements[i + 1];
+        // Merge adjacent statements (e.g. locator declaration + .fill()) — only when contiguous lines.
+        if (next && next.line - statements[i].line <= 2) {
+            out.push({ statement: statements[i], tokens: new Set([...statements[i].tokens, ...next.tokens]) });
+        }
+    }
+    return out;
+}
+function best(stepTokens, kind, pool, minScore) {
+    let top = null;
+    for (const cand of pool) {
+        const s = score(stepTokens, cand.tokens);
+        // Kind compatibility: an assertion step must be satisfied by an assertion statement; action and
+        // navigation steps by non-assertion statements. A cross-kind match is allowed but penalised (0.85).
+        const compatible = kind === 'assertion'
+            ? cand.statement.kind === 'assertion'
+            : cand.statement.kind !== 'assertion';
+        const adjusted = compatible ? s.score : s.score * 0.85;
+        const ok = isMatch({ ...s, score: adjusted }, minScore);
+        // Prefer any matching candidate over a non-matching one, then the higher score.
+        if (!top || (ok && !top.ok) || (ok === top.ok && adjusted > top.score)) {
+            top = { score: adjusted, ok, statement: cand.statement };
+        }
+    }
+    if (!top)
+        return { covered: false, confidence: 0 };
+    return { covered: top.ok, confidence: Math.round(Math.min(1, top.score) * 100) / 100, statement: top.statement };
+}
+function trim(s, n = 180) { return s.length > n ? s.slice(0, n - 1) + '…' : s; }
+function computeStepCoverage(opts) {
+    const statements = extractStatements(opts.code ?? '');
+    const pool = windows(statements);
+    const assertionPool = windows(statements.filter((s) => s.kind === 'assertion'));
+    const infos = (opts.steps ?? []).map(stepInfo).filter((i) => i.text.trim().length > 0);
+    const perStep = infos.map((info, idx) => {
+        const tokens = tokenize(info.text);
+        const kind = stepKind(info.text, tokens);
+        // Navigation steps naming a URL are satisfied by any navigation statement mentioning the host/path
+        // or by the project's base URL helper.
+        const m = best(tokens, kind, pool, 0.45);
+        let covered = m.covered;
+        let statement = m.statement;
+        let confidence = m.confidence;
+        if (!covered && kind === 'navigation') {
+            const nav = statements.find((s) => s.kind === 'navigation');
+            if (nav && tokens.size <= 3) {
+                covered = true;
+                statement = nav;
+                confidence = Math.max(confidence, 0.6);
+            }
+        }
+        const item = {
+            index: idx + 1,
+            step: trim(info.text, 240),
+            kind,
+            covered,
+            confidence,
+            ...(covered && statement ? { matchedLine: statement.line, matchedStatement: trim(statement.text) } : {}),
+        };
+        if (info.expected) {
+            const em = best(tokenize(info.expected), 'assertion', assertionPool, 0.4);
+            item.expected = {
+                text: trim(info.expected, 240),
+                covered: em.covered,
+                ...(em.covered && em.statement ? { matchedLine: em.statement.line, matchedStatement: trim(em.statement.text) } : {}),
+            };
+        }
+        return item;
+    });
+    const totalSteps = perStep.length;
+    const coveredSteps = perStep.filter((p) => p.covered).length;
+    let expectedResult;
+    const er = opts.expectedResult?.trim();
+    if (er) {
+        const em = best(tokenize(er), 'assertion', assertionPool, 0.4);
+        expectedResult = {
+            text: trim(er, 240),
+            covered: em.covered,
+            ...(em.covered && em.statement ? { matchedLine: em.statement.line, matchedStatement: trim(em.statement.text) } : {}),
+        };
+    }
+    const expectations = [
+        ...(expectedResult ? [expectedResult.covered] : []),
+        ...perStep.filter((p) => p.expected).map((p) => p.expected.covered),
+    ];
+    const assertionCoverage = expectations.length
+        ? {
+            total: expectations.length,
+            covered: expectations.filter(Boolean).length,
+            pct: Math.round((expectations.filter(Boolean).length / expectations.length) * 1000) / 10,
+        }
+        : null;
+    return {
+        method: 'token-overlap-v1',
+        totalSteps,
+        coveredSteps,
+        coveragePct: totalSteps === 0 ? 0 : Math.round((coveredSteps / totalSteps) * 1000) / 10,
+        assertionCoverage,
+        ...(expectedResult ? { expectedResult } : {}),
+        uncoveredSteps: perStep.filter((p) => !p.covered).map((p) => p.index),
+        perStep,
+    };
+}
+/** Aggregate helper used by reports: average of non-null percentages. */
+function averageStepCoverage(values) {
+    const nums = values.filter((v) => typeof v === 'number' && Number.isFinite(v));
+    if (!nums.length)
+        return null;
+    return Math.round((nums.reduce((a, b) => a + b, 0) / nums.length) * 10) / 10;
+}

package/dist/step-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function stepToText(step: unknown): string;
+export declare function normalizeSteps(steps: unknown): string[];

package/dist/step-utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepToText = stepToText;
+exports.normalizeSteps = normalizeSteps;
+// Decode FZE multi-select encoding ("OR|FUNCOPR|Val1|FUNCVAL|Val2" → "Val1, Val2")
+// and strip element-type prefixes ("Label text:", "Span text:", "I N P U T:").
+function decodeFzeText(s) {
+    return s
+        .replace(/OR\|FUNCOPR\|/g, '')
+        .replace(/\|FUNCVAL\|/g, ', ')
+        .replace(/\|FUNCOPR\|/g, ', ')
+        .replace(/,\s*\|?\s*$/, '')
+        .replace(/^(?:Label|Span|Div|Button|Input)\s+text:\s*/i, '')
+        .replace(/^I(?:\s+N\s+P\s+U\s+T|NPUT):\s*/i, '')
+        // Preserve fze.env.* as [env:NAME] so URL/field extraction can read the variable name;
+        // strip fze.random/local (truly dynamic — no stable value) as [DYNAMIC]
+        .replace(/\{\{\s*fze\.env\.([^}]+)\}\}/gi, '[env:$1]')
+        .replace(/\{\{\s*fze\.(random|local)\.[^}]+\}\}/gi, '[DYNAMIC]')
+        .replace(/'?\[DYNAMIC\]'?/g, '[DYNAMIC]')
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\s{2,}/g, ' ')
+        .trim();
+}
+// Normalize any step shape to a readable string for LLM prompt injection
+function stepToText(step) {
+    if (typeof step === 'string')
+        return decodeFzeText(step.trim());
+    if (step == null)
+        return '';
+    if (Array.isArray(step))
+        return step.map(stepToText).filter(Boolean).join(' ');
+    if (typeof step === 'object') {
+        const obj = step;
+        // When a decoded action is present, skip raw data/expected fields to avoid
+        // embedding FZE-encoded values or "expect X" text into the action string.
+        const action = obj.action != null ? decodeFzeText(String(obj.action)) : null;
+        const text = obj.text != null ? decodeFzeText(String(obj.text)) : null;
+        if (action || text) {
+            const parts = [action, text].filter((v) => Boolean(v && v.trim()));
+            return parts.join(' ').trim();
+        }
+        // Fallback: include data/expected when no action/text
+        const parts = [
+            obj.data ? stepToText(obj.data) : null,
+            obj.expected ? `expect ${stepToText(obj.expected)}` : null,
+            obj.expectedResult ? `expect ${stepToText(obj.expectedResult)}` : null,
+        ].filter((v) => v != null && String(v).trim().length > 0);
+        if (parts.length > 0)
+            return parts.map((v) => stepToText(v)).filter(Boolean).join(' ');
+        try {
+            return JSON.stringify(step);
+        }
+        catch {
+            return String(step);
+        }
+    }
+    return decodeFzeText(String(step).trim());
+}
+function normalizeSteps(steps) {
+    const raw = Array.isArray(steps) ? steps : steps == null ? [] : [steps];
+    return raw.map(stepToText).map((s) => s.trim()).filter(Boolean);
+}

package/dist/test-case-agent.d.ts

@@ -0,0 +1,206 @@
+import type { ElementFact, TestKind } from '@taodigital/core';
+import type { LLMConfig } from './llm.js';
+export declare const GLOBAL_RULES_FALLBACK: string;
+/** @implements {TestGenerationAgent.generateTestCases} */
+export declare function generateTestCases(opts: {
+    tenantId: string;
+    projectId: string;
+    screenId: string;
+    jobId?: string;
+    oversized?: boolean;
+    viewport?: string;
+    apiEndpoints?: Array<{
+        method: string;
+        urlPattern: string;
+    }>;
+    suiteNameOverride?: string;
+    force?: boolean;
+    fullCoverage?: boolean;
+    suiteLastGenAt?: Date;
+    /**
+     * 'append' (default) — deduplicates by content hash + grounding hash + title Jaccard.
+     * 'replace'          — deletes existing AI-generated cases for this screen before inserting.
+     * 'edit'             — upserts: updates steps/gherkin/expectedResult on matched cases, snapshots old version.
+     */
+    mode?: 'replace' | 'append' | 'edit';
+    repository?: {
+        getChangedScreenIds: (tenantId: string, projectId: string, sinceDate: Date) => Promise<string[]>;
+    };
+    llmCfg?: LLMConfig;
+    fastPassLlmCfg?: LLMConfig;
+    /** Override hardcoded GLOBAL_RULES_FALLBACK — load via agent-prompts.ts before calling. */
+    globalRules?: string;
+    /**
+     * When provided, only runs passes that produce these test kinds.
+     * Overrides the always-on behavior — only the requested kinds are generated.
+     * When omitted, all applicable passes run (existing behavior, unchanged).
+     */
+    kinds?: readonly string[];
+    /**
+     * When true, skips injecting project KB (skill files, requirements, knowledge chunks, cross-project patterns).
+     * Use for BRD-only generation where the document itself is the sole source of truth.
+     */
+    ignoreProjectContext?: boolean;
+}): Promise<{
+    skipped: boolean;
+    reason: string;
+    existingCaseCount: number;
+    status?: undefined;
+    raw?: undefined;
+    cases?: undefined;
+    groundedFacts?: undefined;
+    saved?: undefined;
+    passBreakdown?: undefined;
+    coverageReport?: undefined;
+} | {
+    status: string;
+    raw: string;
+    cases: {
+        title: string;
+        ref: string;
+        viewportConstraint: "ALL" | "MOBILE_ONLY" | "TABLET_ONLY";
+        techniqueOfRecord: string | undefined;
+        traceTo: string | undefined;
+        testDataInline: Record<string, unknown> | undefined;
+        category: string[] | undefined;
+        dataNote: string | undefined;
+        scriptNote: string | undefined;
+        structuredSteps: {
+            action: string;
+            target?: string;
+            data?: string;
+        }[] | undefined;
+        kind: TestKind;
+        priority: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+        preconditions: string;
+        expectedResult: string;
+        steps: string[];
+        groundedOn: string[];
+        gherkin: string;
+        tags: string[];
+    }[];
+    groundedFacts: ElementFact[];
+    saved: {
+        suite: {
+            tenantId: string;
+            id: string;
+            projectId: string;
+            name: string;
+            createdAt: Date;
+            genModel: string | null;
+            category: import(".prisma/client").$Enums.SuiteCategory | null;
+            parentId: string | null;
+            ownerUserId: string | null;
+            genTotalTokens: number | null;
+            genTotalCostUsd: number | null;
+            genAt: Date | null;
+            genScreenCount: number | null;
+            coverageReport: import("@prisma/client/runtime/library").JsonValue | null;
+        };
+        testCases: {
+            tenantId: string;
+            screenId: string | null;
+            id: string;
+            projectId: string;
+            source: string;
+            status: string;
+            createdAt: Date;
+            updatedAt: Date;
+            steps: import("@prisma/client/runtime/library").JsonValue;
+            kind: string;
+            tags: import("@prisma/client/runtime/library").JsonValue;
+            approvedBy: string | null;
+            suiteId: string;
+            ref: string | null;
+            title: string;
+            priority: string;
+            preconditions: string | null;
+            expectedResult: string | null;
+            gherkin: string | null;
+            approvedAt: Date | null;
+            groundedOn: import("@prisma/client/runtime/library").JsonValue;
+            caseRefs: import("@prisma/client/runtime/library").JsonValue;
+            viewports: import("@prisma/client/runtime/library").JsonValue;
+            viewportConstraint: string;
+            techniqueOfRecord: string | null;
+            traceTo: string | null;
+            traceToExtra: import("@prisma/client/runtime/library").JsonValue;
+            testDataInline: import("@prisma/client/runtime/library").JsonValue | null;
+            dataNote: string | null;
+            scriptNote: string | null;
+            structuredSteps: import("@prisma/client/runtime/library").JsonValue | null;
+            artifactId: string | null;
+            scenarioId: string | null;
+            suspect: boolean;
+            suspectReason: string | null;
+            flakyScore: number;
+            consecutiveFlakes: number;
+            lastFlakyAt: Date | null;
+            quarantined: boolean;
+            quarantinedAt: Date | null;
+            quarantineReason: string | null;
+            genPromptTokens: number | null;
+            genCompletionTokens: number | null;
+            genCostUsd: number | null;
+            genModel: string | null;
+            dataSetId: string | null;
+            repoTargetPath: string | null;
+            stepsKey: string | null;
+            gherkinKey: string | null;
+            contentHash: string | null;
+            groundingHash: string | null;
+            locatorsJson: import("@prisma/client/runtime/library").JsonValue | null;
+            locatorsExtractedAt: Date | null;
+            captureStepScreenshots: import("@prisma/client/runtime/library").JsonValue | null;
+        }[];
+    };
+    passBreakdown: {
+        [k: string]: number;
+    };
+    coverageReport: {
+        byKind: Record<string, number>;
+        byPriority: Record<string, number>;
+        byTechnique: Record<string, number>;
+        targetsDiscovered: number;
+        targetsCovered: number;
+        gaps: string[];
+        passBreakdown: {
+            [k: string]: number;
+        };
+    };
+    skipped?: undefined;
+    reason?: undefined;
+    existingCaseCount?: undefined;
+}>;
+/**
+ * Regenerate a test case title using AI.
+ * Deterministic: seed = testCaseId + currentTitle + attempt, so each
+ * user click on "Regenerate" after saving produces a different result.
+ */
+export declare function regenerateTestCaseTitle(opts: {
+    tenantId: string;
+    testCaseId: string;
+    currentTitle: string;
+    screenName?: string;
+    steps?: string[];
+    expectedResult?: string;
+    kind?: string;
+    attempt?: number;
+}): Promise<{
+    title: string;
+}>;
+/**
+ * H2: Generate AI output validation test cases for testing LLM/AI feature outputs.
+ * Produces cases with AI-specific assertions: similarity, tone, safety, structured output.
+ */
+export declare function generateAiOutputValidationCases(opts: {
+    tenantId: string;
+    projectId: string;
+    suiteId: string;
+    featureDescription: string;
+    aiModelName?: string;
+    assertionTypes?: Array<'similarity' | 'tone' | 'safety' | 'structured-output' | 'hallucination-check'>;
+}): Promise<{
+    cases: any[];
+    passedLint: number;
+}>;