@taodigital/agents 0.0.0-stage → 1.2.0

package/dist/scenario-agent.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScenarios = generateScenarios;
+const app_brain_1 = require("@taodigital/app-brain");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const core_1 = require("@taodigital/core");
+const SYSTEM = `You are a senior BDD practitioner converting software requirements into precise Gherkin scenarios.
+
+Rules:
+- Generate EXACTLY the requested number of scenarios per requirement tailored to the requirement TYPE:
+  - functional/nonfunctional: happy path, validation errors, edge cases, integration
+  - security: authentication, authorization, injection attacks, data exposure
+  - accessibility: screen reader, keyboard nav, color contrast, ARIA labels
+  - performance: load time, concurrent users, large data sets, timeouts
+  - data: data integrity, boundary values, null handling, format validation
+- Tag scenarios appropriately: @negative, @edge, @security, @accessibility, @performance, @nonfunctional
+- Each scenario MUST use proper Given/When/Then/And/But structure
+- Given: pre-conditions and context (what is already true)
+- When: a single user action or system event
+- Then: observable, verifiable outcome — use exact text, not "it works"
+- And/But: continue Given/When/Then (not standalone)
+- Titles: imperative, specific — "User submits form with invalid email" not "Test login"
+- No emojis, pronouns, or vague assertions
+- Each scenario must trace directly to the provided requirement title, acceptance criteria, business rules, or project context. Do not introduce unrelated features.
+- CRITICAL — use specific values from Business Rules directly in Given/And/Then steps. Never paraphrase or generalise constraints. Examples:
+  - If a rule says "VIN: 17 alphanumeric chars excluding O, I, U, Q, 0, 1, 9", write 'And the VIN field contains "1HGBH41JXMN109186"' (valid) or 'And the VIN field contains "1HGBH41JXMN10918O"' (invalid — contains excluded letter O), NOT 'And an invalid VIN is entered'.
+  - If a rule says "Password: 3-8 characters", write 'And the password field contains "ab"' (too short) or 'And the password field contains "abc123xy9"' (too long — 9 chars), NOT 'And an invalid password is entered'.
+  - Quote exact values, lengths, character sets, and boundary numbers in the step text.
+
+Return ONLY valid JSON:
+{
+  "scenarios": [
+    {
+      "title": "string",
+      "description": "string (optional — brief context note)",
+      "gherkin": "Scenario: Title\\n  Given ...\\n  When ...\\n  Then ..."
+    }
+  ]
+}`;
+async function generateScenarios(opts) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testGeneration');
+    if (!llmCfg)
+        return [];
+    const { reqId, title, actor, acceptanceCriteria, businessRules } = opts.requirement;
+    // ZETA-085: honour the caller-supplied count so exactly N scenarios are generated.
+    const requestedCount = Math.max(1, Math.min(10, Math.floor(opts.count ?? 4)));
+    // Load project context in parallel: workspace domain + skill files + artifact search
+    const knowledgeQuery = [title, acceptanceCriteria?.[0]].filter(Boolean).join(' ');
+    const [domainCtx, skillFiles, knowledgeChunks] = await Promise.all([
+        (0, llm_config_js_1.getWorkspaceDomainContext)(opts.tenantId, opts.projectId),
+        app_brain_1.AppBrain.listSkillFiles(opts.tenantId, opts.projectId, [
+            'BUSINESS_DOMAIN', 'API_CONTRACT', 'ERROR_CATALOGUE', 'INTERACTION_PATTERNS',
+        ]).catch(() => []),
+        app_brain_1.AppBrain.searchKnowledge(opts.tenantId, opts.projectId, knowledgeQuery, 5).catch(() => []),
+    ]);
+    // Build optional project context block from skill files + artifact chunks
+    const projectCtxParts = [];
+    for (const sf of skillFiles) {
+        if (sf?.content?.trim()) {
+            projectCtxParts.push(`## ${sf.kind}\n${sf.content.trim()}`);
+        }
+    }
+    for (const chunk of knowledgeChunks) {
+        if (chunk?.content?.trim() && chunk.source !== 'SKILL_FILE') {
+            projectCtxParts.push(`## Artifact: ${chunk.label ?? 'context'}\n${chunk.content.trim()}`);
+        }
+    }
+    const projectCtx = projectCtxParts.length
+        ? `PROJECT CONTEXT (use to write accurate, specific scenarios):\n\n${projectCtxParts.join('\n\n')}`
+        : '';
+    const { type, priority } = opts.requirement;
+    const userPrompt = [
+        domainCtx,
+        projectCtx,
+        `Requirement: ${reqId} — ${title}`,
+        actor ? `Actor: ${actor}` : '',
+        type ? `Type: ${type} — focus scenarios on ${type} concerns` : '',
+        priority ? `Priority: ${priority}` : '',
+        acceptanceCriteria?.length
+            ? `Acceptance Criteria:\n${acceptanceCriteria.map((c) => `- ${c}`).join('\n')}`
+            : '',
+        businessRules?.length
+            ? `Business Rules (embed the exact values, lengths, and character constraints from these rules directly in the scenario steps — do not paraphrase):\n${businessRules.map((r) => `- ${r}`).join('\n')}`
+            : '',
+        '',
+        `Generate exactly ${requestedCount} Gherkin scenarios for this requirement. Use @tags appropriate to the type: ${type ?? 'functional'}.`,
+    ].filter(Boolean).join('\n');
+    try {
+        // ZETA-086: use temperature=0 + deterministic seed so repeated calls for the same
+        // requirement produce consistent scenarios.
+        const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${reqId}:${title}:${requestedCount}`);
+        const effectiveSystem = await (0, core_1.getAgentPrompt)('scenario-bdd', undefined, opts.tenantId) ?? SYSTEM;
+        const { text } = await (0, llm_js_1.askTracked)(effectiveSystem, userPrompt, llmCfg, 4096, undefined, { temperature: 0, seed });
+        const json = text.match(/\{[\s\S]*\}/)?.[0];
+        if (!json)
+            return [];
+        const parsed = JSON.parse(json);
+        const scenarios = (parsed.scenarios ?? []).filter((s) => s.title && s.gherkin).slice(0, requestedCount);
+        // ZETA-085: pad with deterministic fallback scenarios if the LLM returned fewer than requested.
+        const acList = acceptanceCriteria?.length ? acceptanceCriteria : [title];
+        while (scenarios.length < requestedCount) {
+            const index = scenarios.length + 1;
+            const ac = acList[(index - 1) % acList.length] ?? title;
+            const scenarioTitle = `${title} - coverage path ${index}`;
+            scenarios.push({
+                title: scenarioTitle,
+                description: `Deterministic supplemental scenario for ${reqId}.`,
+                gherkin: [
+                    `Scenario: ${scenarioTitle}`,
+                    actor ? `  Given ${actor} is using the application` : '  Given the application is available',
+                    `  And requirement ${reqId} is in scope`,
+                    `  When the behavior "${title}" is exercised for "${ac}"`,
+                    `  Then the observable result satisfies requirement ${reqId}`,
+                ].join('\n'),
+            });
+        }
+        return scenarios;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/script-agent.d.ts

@@ -0,0 +1,447 @@
+/**
+ * ZeTa-AI Test Script Generation Agent — v2 (ZeTa Framework Standard v1)
+ *
+ * Architecture: deterministic scaffolding layer + model-filled body layer.
+ *
+ * The LLM fills four slots per script:
+ *   locatorsBody   — locator constants/selectors (no class wrapper)
+ *   pageObjectBody — action methods (no class wrapper)
+ *   testDataBody   — VALID/INVALID/EDGE data constants
+ *   specBody       — test functions / step defs (no describe/class wrapper)
+ *
+ * Everything else (imports, BasePage, class declaration, describe, beforeEach,
+ * tags, TC-ref title format, JUnit reporter) is a fixed template per stack.
+ *
+ * Locator priority (§2.4): data-testid > role+name > label/aria-label > exact text > placeholder > CSS.
+ * Forbidden patterns (§5.2): sleep(), Thread.sleep(), cy.wait(number), positional XPath, inlined credentials.
+ *
+ * Supported stacks: playwright-ts · playwright-js · playwright-py · playwright-java
+ *                   cypress-ts · cypress-js · selenium-py · selenium-java · gherkin
+ */
+import { type StepCoverageResult } from './step-coverage.js';
+export declare const SCRIPT_GEN_CONCURRENCY: number;
+export declare const SCRIPT_GEN_MAX_TOKENS: number;
+export type ScriptGenerationReadiness = {
+    ready: boolean;
+    missing: string[];
+    message: string;
+    details: {
+        caseCount: number;
+        screenCount: number;
+        targetType: 'API' | 'NATIVE' | 'WEB';
+        nativePlatforms: string[];
+        nativeBuildPlatforms: string[];
+        casesMissingApproval: string[];
+        casesMissingData: string[];
+        casesMissingScreen: string[];
+    };
+};
+export declare class ScriptGenerationBlockedError extends Error {
+    readonly code = "SCRIPT_CONTEXT_INCOMPLETE";
+    readonly statusCode = 422;
+    readonly readiness: ScriptGenerationReadiness;
+    constructor(readiness: ScriptGenerationReadiness);
+}
+export declare function evaluateScriptGenerationReadiness(input: {
+    appUrl?: string | null;
+    appType?: string | null;
+    nativeBuilds?: Array<{
+        platform?: string | null;
+        fileFormat?: string | null;
+    }>;
+    screens?: any[];
+    cases?: any[];
+    contextPhase?: string | null;
+}): ScriptGenerationReadiness;
+export declare function getScriptGenerationReadiness(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId?: string;
+    suiteId?: string;
+    packType?: string;
+    caseIds?: string[];
+}): Promise<ScriptGenerationReadiness>;
+export declare function assertScriptGenerationReady(opts: Parameters<typeof getScriptGenerationReadiness>[0]): Promise<ScriptGenerationReadiness>;
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export declare const ZETA_BASE_PAGES: Record<string, string>;
+export declare const ZETA_JAVA_V2_DRIVER_FACTORY = "// ZeTa Framework Standard v2 \u2014 DriverFactory (Selenium Java / TestNG)\npackage io.zeta.core;\n\nimport io.github.bonigarcia.wdm.WebDriverManager;\nimport org.openqa.selenium.WebDriver;\nimport org.openqa.selenium.chrome.ChromeDriver;\nimport org.openqa.selenium.chrome.ChromeOptions;\n\npublic final class DriverFactory {\n    private static final ThreadLocal<WebDriver> DRIVER_THREAD_LOCAL = new ThreadLocal<>();\n    private DriverFactory() {}\n\n    /** Call from @BeforeMethod. Browser: -Dzeta.browser=chrome. Headless: -Dzeta.headless=true */\n    public static void initDriver() {\n        WebDriverManager.chromedriver().setup();\n        ChromeOptions opts = new ChromeOptions();\n        boolean headless = Boolean.parseBoolean(System.getProperty(\"zeta.headless\", \"true\"));\n        if (headless) opts.addArguments(\"--headless=new\", \"--no-sandbox\", \"--disable-dev-shm-usage\");\n        opts.addArguments(\"--window-size=1280,800\");\n        DRIVER_THREAD_LOCAL.set(new ChromeDriver(opts));\n    }\n\n    /** Return the WebDriver for the current thread. */\n    public static WebDriver getDriver() {\n        WebDriver d = DRIVER_THREAD_LOCAL.get();\n        if (d == null) throw new IllegalStateException(\"Call initDriver() in @BeforeMethod first.\");\n        return d;\n    }\n\n    /** Call from @AfterMethod(alwaysRun = true). */\n    public static void quitDriver() {\n        WebDriver d = DRIVER_THREAD_LOCAL.get();\n        if (d != null) { try { d.quit(); } finally { DRIVER_THREAD_LOCAL.remove(); } }\n    }\n}";
+interface LintResult {
+    ok: boolean;
+    violations: string[];
+    warnings?: string[];
+}
+export declare function lintScript(code: string, language?: string, expectedLocatorCount?: number): LintResult;
+export declare function stepToPlaywrightLine(step: unknown, indent?: string): string;
+/**
+ * Resolved file placement + import conventions for a specific repo + framework.
+ * Computed ONCE per suite generation job; shared across all test cases.
+ */
+export interface RepoGenerationContext {
+    /** Directory for spec/test files (trailing slash). e.g. "tests/" or "src/tests/" */
+    specDir: string;
+    /** Directory for page object files (trailing slash). e.g. "src/advantage/pages/" */
+    pageObjectDir: string;
+    /** Directory for locator constants (trailing slash) or null if collocated. */
+    locatorsDir: string | null;
+    /** Directory for test data files (trailing slash) or null if collocated. */
+    testDataDir: string | null;
+    /**
+     * Import path FROM page object file TO base page class.
+     * TS/JS: relative file path e.g. "./base.page" or "../../framework/BasePage".
+     * Python: module path e.g. "pages.base_page" or "src.framework.base_page".
+     */
+    basePageImport: string;
+    /**
+     * Relative path FROM specDir directory TO pageObjectDir directory.
+     * Used to build spec → PO import. e.g. "../src/advantage/pages".
+     * Python: module prefix e.g. "pages" or "advantage.pages".
+     */
+    poImportDir: string;
+    /** Page object class name suffix. e.g. "Page", "Steps", "Helper". */
+    poClassSuffix: string;
+    /** Spec file extension suffix. e.g. ".spec.ts", ".cy.ts", "_test.py". */
+    specFileSuffix: string;
+    /**
+     * File stem naming convention detected from the repo.
+     * 'pascal' = ServiceMessagingPage.ts (PascalCase, no separator)
+     * 'kebab'  = service-messaging.page.ts (kebab-case, ZeTa default)
+     * 'snake'  = service_messaging_test.py (snake_case, Python default)
+     */
+    stemCase: 'pascal' | 'kebab' | 'snake';
+    /** Directory for fixture files (trailing slash). e.g. "tests/fixtures/". */
+    fixtureDir: string;
+    /** Test timeout in ms to inject via test.setTimeout(). Undefined = use framework default. */
+    defaultTimeoutMs?: number;
+    /** Base URL extracted from playwright.config.ts / cypress.config.ts — used as default appUrl fallback. */
+    baseURL?: string;
+    /** Sample locator file content from the repo — injected into the prompt so the LLM follows the same naming + selector strategy (ZETA-253). */
+    sampleLocatorFileContent?: string;
+}
+export declare function generateZetaV2Bundle(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId: string;
+    appSlug?: string;
+    repoSkillContext?: string;
+    /** Java base package (e.g. "com.crm.qa") derived from repo scan. Overrides io.zeta default. */
+    basePackage?: string;
+    /** Repo structure type: 'flat' | 'two-tier' | 'zeta-v2' | 'custom'. Non-zeta-v2 → 2-file output. */
+    testStructurePattern?: string;
+    /** Where page object classes live in the repo (e.g. "src/main/java/pages"). Non-zeta-v2 repos. */
+    pageObjectLocation?: string;
+    /** Where test classes live in the repo (e.g. "src/test/java/tests"). Non-zeta-v2 repos. */
+    testLocation?: string;
+    /** Repo base page class name or FQN (e.g. "BasePage" or "com.acme.core.BasePage"). */
+    basePageClass?: string;
+    /** Repo driver factory class name or FQN (e.g. "Browser" or "com.acme.core.DriverFactory"). */
+    driverClass?: string;
+    /** File naming pattern from repo scan (e.g. "{PascalCase}Helper.java") — used to derive PO class suffix. */
+    namingPattern?: string;
+    jobId?: string;
+    /** Pre-extracted Playwright locators from the live page — injected verbatim into the LLM prompt. */
+    extractedLocators?: Array<{
+        key: string;
+        expression: string;
+        description: string;
+        confidence: string;
+    }>;
+}): Promise<{
+    files: Array<{
+        filename: string;
+        path: string;
+        code: string;
+    }>;
+    primaryCode: string;
+}>;
+/**
+ * Pre-execution dry-run: validates that test steps reference elements that exist
+ * in the crawled element inventory. Returns a list of flagged steps that may fail.
+ * Non-blocking — caller decides whether to proceed or surface warnings to the user.
+ */
+export declare function validateStepsAgainstInventory(opts: {
+    tenantId: string;
+    projectId: string;
+    steps: string[];
+    elementInventory?: Array<{
+        label: string;
+        role: string;
+        ariaLabel?: string;
+        cssSelector?: string;
+        selector?: string;
+        textContent?: string;
+    }>;
+}): Promise<{
+    valid: boolean;
+    flaggedSteps: Array<{
+        step: string;
+        reason: string;
+    }>;
+    coverage: number;
+    unmatchedSteps: string[];
+}>;
+export declare function generateTestScript(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId: string;
+    language?: string;
+    /** When true, derive and persist repoTargetPath on the test case for IDE push. */
+    useV2?: boolean;
+    jobId?: string;
+    /** Pre-extracted Playwright locators from the live page — injected verbatim into the LLM prompt. */
+    extractedLocators?: Array<{
+        key: string;
+        expression: string;
+        description: string;
+        confidence: string;
+    }>;
+}): Promise<{
+    language: string;
+    code: string;
+    files: {
+        testCaseId: string;
+        filename: string;
+        path: string;
+        code: string;
+    }[];
+    saved: boolean;
+    lintViolations: never[];
+    lintWarnings?: undefined;
+    dryRunWarnings?: undefined;
+    alignmentScore?: undefined;
+    aligned?: undefined;
+    alignmentIssues?: undefined;
+    stepCoverage?: undefined;
+} | {
+    language: string;
+    code: string;
+    files: {
+        filename: string;
+        code: string;
+        path: string;
+        testCaseId: string;
+        role: string;
+    }[];
+    saved: {
+        tenantId: string;
+        id: string;
+        projectId: string;
+        validationStatus: string;
+        testCaseId: string;
+        language: string;
+        code: string;
+        filePath: string | null;
+        codeKey: string | null;
+        validationErrors: string | null;
+        pushedToPR: boolean;
+        pushedPRId: string | null;
+    };
+    lintViolations: string[];
+    lintWarnings: string[];
+    dryRunWarnings: {
+        step: string;
+        reason: string;
+    }[];
+    alignmentScore: number;
+    aligned: boolean;
+    alignmentIssues: string[];
+    stepCoverage: StepCoverageResult;
+} | {
+    language: string;
+    code: string;
+    files: {
+        filename: string;
+        code: string;
+        path: string;
+        testCaseId: string;
+        role: string;
+    }[];
+    saved: {
+        tenantId: string;
+        id: string;
+        projectId: string;
+        validationStatus: string;
+        testCaseId: string;
+        language: string;
+        code: string;
+        filePath: string | null;
+        codeKey: string | null;
+        validationErrors: string | null;
+        pushedToPR: boolean;
+        pushedPRId: string | null;
+    };
+    lintViolations: string[];
+    lintWarnings: string[];
+    dryRunWarnings: {
+        step: string;
+        reason: string;
+    }[];
+    alignmentScore?: undefined;
+    aligned?: undefined;
+    alignmentIssues?: undefined;
+    stepCoverage?: undefined;
+}>;
+export declare function generateSuiteScript(opts: {
+    tenantId: string;
+    projectId: string;
+    suiteId: string;
+    language?: string;
+    caseIds?: string[];
+    /** When true, derive and persist repoTargetPath on each test case for IDE push. */
+    useV2?: boolean;
+    /** StyleProfile from connected repo — when provided, LLM mirrors repo conventions */
+    styleProfile?: Record<string, unknown>;
+    /** PageObjectInventory from connected repo — injected into LLM for reuse hints */
+    pageObjectInventory?: Array<{
+        filePath: string;
+        className: string;
+        methods: Array<{
+            name: string;
+            params: string;
+            returnType: string;
+        }>;
+        importPath: string;
+    }>;
+    /** Called after each test case is generated with (done, total) counts */
+    onProgress?: (done: number, total: number) => void;
+    jobId?: string;
+    /**
+     * Controls how per-TC spec files are bundled after generation.
+     * - PER_TEST_CASE: each TC gets its own spec file — no grouping.
+     * - BY_SCREEN: TCs sharing the same screenId are merged into a single grouped spec file.
+     * - BY_SECTION: TCs sharing the same scenarioId (or first @-tag) are merged into a single grouped spec file.
+     * - AUTO (default): auto-detect per TC source — BY_SCREEN when ≥60% of TCs have screenId,
+     *   BY_SECTION when ≥60% have artifactId/scenarioId/traceTo, PER_TEST_CASE otherwise.
+     * Non-spec files (locators, page objects, test data, actions, assertions) are never merged.
+     */
+    specGroupingStrategy?: 'PER_TEST_CASE' | 'BY_SCREEN' | 'BY_SECTION' | 'AUTO';
+}): Promise<{
+    language: string;
+    files: Array<{
+        filename: string;
+        code: string;
+        testCaseId?: string;
+    }>;
+    basePage: string | null;
+    errors: Array<{
+        testCaseId: string;
+        title: string;
+        error: string;
+    }>;
+}>;
+export declare function generatePackScript(opts: {
+    tenantId: string;
+    projectId: string;
+    packType: 'regression' | 'smoke' | 'sanity' | 'api' | 'security' | 'integration' | 'e2e' | 'accessibility';
+    language?: string;
+}): Promise<{
+    language: string;
+    files: any[];
+    basePage: string | null;
+}>;
+export declare function patchScriptWithAI(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId: string;
+    language: string;
+    fullCode: string;
+    selection: {
+        startLine: number;
+        endLine: number;
+    } | null;
+    instruction: string;
+    testCaseContext?: {
+        title?: string;
+        steps?: unknown[];
+        expectedResult?: string;
+    };
+}): Promise<{
+    patchedCode: string;
+    explanation: string;
+    lintViolations: string[];
+    lintWarnings: string[];
+}>;
+export declare function verifyScriptAlignment(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId: string;
+    language: string;
+    code: string;
+    locatorsCode?: string;
+    testCase: {
+        title: string;
+        steps: unknown[];
+        expectedResult?: string;
+        kind: string;
+    };
+}): Promise<{
+    aligned: boolean;
+    score: number;
+    issues: string[];
+    summary: string;
+    stepCoverage: StepCoverageResult;
+}>;
+import type { StyleProfile } from './repo-scan-agent.js';
+export declare function generateScriptAligned(opts: {
+    tenantId: string;
+    projectId: string;
+    testCaseId: string;
+    language?: string;
+    styleProfile: StyleProfile;
+    /** Page object inventory from repo scan — injected into LLM prompt for reuse */
+    pageObjectInventory?: Array<{
+        filePath: string;
+        className: string;
+        methods: Array<{
+            name: string;
+            params: string;
+            returnType: string;
+        }>;
+        importPath: string;
+    }>;
+    /** Override target path in repo; if set, saved to TestCase.repoTargetPath */
+    repoTargetPath?: string;
+    save?: boolean;
+}): Promise<{
+    language: string;
+    code: string;
+    saved: boolean;
+    repoTargetPath?: string;
+}>;
+export interface ScriptValidationResult {
+    ok: boolean;
+    errors: string;
+    method: 'tsc' | 'py_compile' | 'syntax_check' | 'skipped';
+}
+export declare function validateGeneratedScript(code: string, _framework: string, language: string): Promise<ScriptValidationResult>;
+/**
+ * LLM-generates a description of the ZIP archive contents for the chosen framework.
+ * Uses repo styleProfile and skill files so the output reflects actual project conventions.
+ */
+export declare function generateScriptZipDescription(opts: {
+    tenantId: string;
+    projectId: string;
+    language: string;
+    styleProfile?: Record<string, unknown>;
+    repoSkillContext?: string;
+}): Promise<{
+    items: string[];
+}>;
+export declare function generateRepoProjectStructure(opts: {
+    tenantId: string;
+    projectId: string;
+    repoName: string;
+    testFilePaths: string[];
+    pageObjectPaths: string[];
+    allRepoPaths?: string[];
+    styleProfile?: Record<string, unknown>;
+}): Promise<{
+    tree: string;
+}>;
+export declare function loadApprovedContextLocators(tenantId: string, projectId: string, screenId?: string | null): Promise<Array<{
+    expression: string;
+    source: 'figma-design' | 'screenshot-extracted';
+    confidence: number;
+    elementType?: string;
+    description?: string;
+}>>;
+export {};