@mknrt/autotests-overkill 1.1.0

package/dist/src/connectors/reportPortalConnector.js

@@ -0,0 +1,84 @@
+export class ReportPortalConnector {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async describeLaunch(stats) {
+        const launchId = stats.launch_id;
+        const launchLink = stats.launch_link;
+        if (!launchId && !launchLink) {
+            return {
+                source: 'unavailable',
+                warnings: this.config
+                    ? ['ReportPortal adapter is configured, but the stats file does not expose launch metadata.']
+                    : [],
+            };
+        }
+        if (!this.config) {
+            return {
+                launchId,
+                launchLink,
+                source: 'local-stats',
+                warnings: [],
+            };
+        }
+        if (!this.config.project || !this.config.token) {
+            return {
+                launchId,
+                launchLink,
+                source: 'local-stats',
+                warnings: ['ReportPortal live lookup is disabled because token or project is missing. Using launch metadata from local stats only.'],
+            };
+        }
+        if (!launchId) {
+            return {
+                launchLink,
+                source: 'local-stats',
+                warnings: ['ReportPortal launch ID is missing, so live enrichment was skipped.'],
+            };
+        }
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1500);
+            const apiBase = normalizeReportPortalApiBase(this.config.endpoint);
+            const response = await fetch(`${apiBase}/api/v1/${encodeURIComponent(this.config.project)}/launch/${encodeURIComponent(launchId)}`, {
+                headers: {
+                    Authorization: `bearer ${this.config.token}`,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                return {
+                    launchId,
+                    launchLink,
+                    source: 'local-stats',
+                    warnings: [`ReportPortal live lookup failed with status ${response.status}. Using launch metadata from local stats only.`],
+                };
+            }
+            const payload = await response.json();
+            return {
+                launchId,
+                launchLink,
+                launchStatus: payload.status,
+                source: 'live-api',
+                warnings: [],
+            };
+        }
+        catch (error) {
+            return {
+                launchId,
+                launchLink,
+                source: 'local-stats',
+                warnings: [`ReportPortal live lookup failed: ${error instanceof Error ? error.message : 'unknown error'}. Using launch metadata from local stats only.`],
+            };
+        }
+    }
+}
+function normalizeReportPortalApiBase(endpoint) {
+    const normalized = endpoint.replace(/\/+$/, '');
+    if (normalized.includes('/api/')) {
+        return normalized;
+    }
+    return normalized.replace(/\/ui(?:\/#.*)?$/, '');
+}

package/dist/src/contracts/confidence.d.ts

@@ -0,0 +1,8 @@
+export type ConfidenceLevel = 'low' | 'medium' | 'high';
+export type ConfidenceScore = {
+    score: number;
+    level: ConfidenceLevel;
+    rationale: string[];
+};
+export declare function createConfidence(score: number, rationale: string[]): ConfidenceScore;
+export declare function confidenceFromEvidence(evidenceCount: number, warnings: string[], modifiers?: string[]): ConfidenceScore;

package/dist/src/contracts/confidence.js

@@ -0,0 +1,33 @@
+export function createConfidence(score, rationale) {
+    const bounded = Math.max(0, Math.min(1, score));
+    return {
+        score: Number(bounded.toFixed(2)),
+        level: bounded >= 0.75 ? 'high' : bounded >= 0.45 ? 'medium' : 'low',
+        rationale,
+    };
+}
+export function confidenceFromEvidence(evidenceCount, warnings, modifiers = []) {
+    let score = Math.min(0.95, 0.25 + evidenceCount * 0.12);
+    score -= warnings.length * 0.08;
+    if (modifiers.length > 0) {
+        score += Math.min(0.1, modifiers.length * 0.03);
+    }
+    return createConfidence(score, [
+        `${evidenceCount} evidence item(s) contributed to the result.`,
+        ...modifiers,
+        ...warnings.map(classifyWarningRationale),
+    ]);
+}
+function classifyWarningRationale(warning) {
+    const normalized = warning.toLowerCase();
+    if (normalized.includes('disabled') || normalized.includes('failed') || normalized.includes('unavailable')) {
+        return `Unavailable source lowered confidence: ${warning}`;
+    }
+    if (normalized.includes('stale') || normalized.includes('outdated') || normalized.includes('refresh')) {
+        return `Potentially stale data lowered confidence: ${warning}`;
+    }
+    if (normalized.includes('no ') || normalized.includes('not found') || normalized.includes('missing')) {
+        return `Missing source lowered confidence: ${warning}`;
+    }
+    return `Warning lowered confidence: ${warning}`;
+}

package/dist/src/contracts/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class OverkillError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export declare function toWarning(error: unknown): string;

package/dist/src/contracts/errors.js

@@ -0,0 +1,18 @@
+export class OverkillError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}
+export function toWarning(error) {
+    if (error instanceof OverkillError) {
+        return `${error.code}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/src/contracts/toolOutput.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { type ConfidenceScore } from './confidence.js';
+export declare const evidenceSchema: z.ZodObject<{
+    type: z.ZodEnum<["file", "symbol", "test", "artifact", "report", "diff", "config"]>;
+    label: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    locator: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+    label: string;
+    path?: string | undefined;
+    locator?: string | undefined;
+    snippet?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+    label: string;
+    path?: string | undefined;
+    locator?: string | undefined;
+    snippet?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const toolOutputSchema: z.ZodObject<{
+    summary: z.ZodString;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["file", "symbol", "test", "artifact", "report", "diff", "config"]>;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        snippet: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    recommended_actions: z.ZodArray<z.ZodString, "many">;
+    repo_paths: z.ZodArray<z.ZodString, "many">;
+    confidence: z.ZodObject<{
+        score: z.ZodNumber;
+        level: z.ZodEnum<["low", "medium", "high"]>;
+        rationale: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    }, {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    }>;
+    warnings: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}, {
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;
+export type EvidenceItem = z.infer<typeof evidenceSchema>;
+export type NormalizedToolOutput = z.infer<typeof toolOutputSchema>;
+type BuildToolOutputInput = {
+    summary: string;
+    evidence: EvidenceItem[];
+    recommended_actions: string[];
+    repo_paths?: string[];
+    confidence?: ConfidenceScore;
+    warnings?: string[];
+};
+export declare function buildToolOutput(input: BuildToolOutputInput): NormalizedToolOutput;
+export {};

package/dist/src/contracts/toolOutput.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { confidenceFromEvidence } from './confidence.js';
+export const evidenceSchema = z.object({
+    type: z.enum(['file', 'symbol', 'test', 'artifact', 'report', 'diff', 'config']),
+    label: z.string(),
+    path: z.string().optional(),
+    locator: z.string().optional(),
+    snippet: z.string().optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+export const toolOutputSchema = z.object({
+    summary: z.string(),
+    evidence: z.array(evidenceSchema),
+    recommended_actions: z.array(z.string()),
+    repo_paths: z.array(z.string()),
+    confidence: z.object({
+        score: z.number(),
+        level: z.enum(['low', 'medium', 'high']),
+        rationale: z.array(z.string()),
+    }),
+    warnings: z.array(z.string()),
+});
+export function buildToolOutput(input) {
+    const warnings = input.warnings ?? [];
+    const repoPaths = input.repo_paths ?? input.evidence.flatMap((item) => item.path ? [item.path] : []);
+    const uniquePaths = [...new Set(repoPaths)];
+    return {
+        summary: input.summary,
+        evidence: input.evidence,
+        recommended_actions: input.recommended_actions,
+        repo_paths: uniquePaths,
+        confidence: input.confidence ?? confidenceFromEvidence(input.evidence.length, warnings),
+        warnings,
+    };
+}

package/dist/src/domain/analyzeDiffImpact.d.ts

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function analyzeDiffImpact(input: {
+    changedFiles: string[];
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/analyzeDiffImpact.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { normalizeChangedFiles } from '../connectors/diffConnector.js';
+import { queryDocuments } from '../knowledge/repositories.js';
+import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
+import { basenameWithoutExt } from '../utils/pathUtils.js';
+import { ensureIndexed, evidenceFile, output } from './shared.js';
+export async function analyzeDiffImpact(input, context) {
+    const changedFiles = normalizeChangedFiles(input.changedFiles);
+    const featureHints = changedFiles.map((filePath) => deriveFeatureHint(filePath)).filter(Boolean);
+    const uniqueFeatures = [...new Set(featureHints)];
+    const evidence = changedFiles.map((filePath) => evidenceFile('changed file', filePath));
+    const impactedSpecs = new Set();
+    await ensureIndexed(context);
+    for (const feature of uniqueFeatures) {
+        const indexed = queryDocuments(context.database, feature, {
+            repoKind: 'autotests2',
+            sourceKinds: ['spec'],
+            limit: 12,
+        });
+        for (const item of indexed) {
+            impactedSpecs.add(item.path);
+        }
+        if (indexed.length > 0) {
+            continue;
+        }
+        const assets = await extractTestAssets({
+            root: context.config.repos.autotests2,
+            featureHint: feature,
+        });
+        for (const spec of assets.specs.slice(0, 8)) {
+            impactedSpecs.add(spec.path);
+        }
+    }
+    return output(`Diff impact analysis mapped ${changedFiles.length} changed file(s) to ${impactedSpecs.size} affected spec candidate(s).`, [
+        ...evidence,
+        ...[...impactedSpecs].slice(0, 10).map((filePath) => evidenceFile('impacted spec', filePath)),
+    ], [
+        'Rerun directly impacted specs before broader regression.',
+        'Inspect widget events and container variants when the diff touches shared widget files.',
+    ], impactedSpecs.size === 0 ? ['No impacted specs were found via naming heuristics.'] : []);
+}
+function deriveFeatureHint(filePath) {
+    const base = basenameWithoutExt(filePath);
+    if (/caption/i.test(base)) {
+        return 'caption';
+    }
+    if (/date.*range/i.test(base) || /daterange/i.test(base)) {
+        return 'dateRange';
+    }
+    const parent = path.basename(path.dirname(filePath));
+    return parent;
+}

package/dist/src/domain/analyzeTestGaps.d.ts

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function analyzeTestGaps(input: {
+    widget: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/analyzeTestGaps.js

@@ -0,0 +1,41 @@
+import { extractFrontendContract } from '../indexer/extractors/frontendContractExtractor.js';
+import { extractFrontendRuntimeLogic } from '../indexer/extractors/frontendRuntimeExtractor.js';
+import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
+import { unique } from '../utils/pathUtils.js';
+import { evidenceFile, output } from './shared.js';
+export async function analyzeTestGaps(input, context) {
+    const [contract, runtime, assets] = await Promise.all([
+        extractFrontendContract({
+            root: context.config.repos.caseplatformWeb,
+            widgetHint: input.widget,
+        }),
+        extractFrontendRuntimeLogic({
+            root: context.config.repos.caseplatformWeb,
+            widgetHint: input.widget,
+        }),
+        extractTestAssets({
+            root: context.config.repos.autotests2,
+            featureHint: input.widget,
+        }),
+    ]);
+    const specText = assets.specs.map((spec) => spec.body).join('\n');
+    const uncoveredMethods = contract.methods.filter((method) => !specText.includes(method));
+    const uncoveredEvents = contract.events.filter((eventName) => !specText.includes(eventName));
+    const uncoveredBranches = runtime.runtimeSignals
+        .filter((signal) => signal.kind === 'branch')
+        .filter((signal) => !specText.includes(signal.name));
+    const repoPaths = unique([
+        ...contract.files,
+        ...uncoveredBranches.map((branch) => branch.path),
+    ]);
+    const gapCount = uncoveredMethods.length + uncoveredEvents.length + uncoveredBranches.length;
+    const warnings = gapCount === 0 ? ['No obvious gaps detected; heuristics may be missing hidden branches.'] : [];
+    return output(`Gap analysis for ${input.widget}: ${gapCount} likely gap signal(s) detected.`, [
+        ...uncoveredMethods.slice(0, 4).map((method) => ({ type: 'symbol', label: `uncovered method ${method}`, snippet: method })),
+        ...uncoveredEvents.slice(0, 4).map((eventName) => ({ type: 'symbol', label: `uncovered event ${eventName}`, snippet: eventName })),
+        ...uncoveredBranches.slice(0, 4).map((branch) => evidenceFile(`uncovered branch ${branch.name}`, branch.path, branch.detail)),
+    ], [
+        'Add assertions around uncovered runtime signals before expanding new feature coverage.',
+        'Review container variants separately when only the base widget appears covered.',
+    ], warnings, repoPaths);
+}

package/dist/src/domain/buildRerunScope.d.ts

@@ -0,0 +1,23 @@
+import type { AppContext } from '../appContext.js';
+export declare function buildRerunScope(input: {
+    changedFiles?: string[];
+    statsFile: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/buildRerunScope.js

@@ -0,0 +1,17 @@
+import { analyzeDiffImpact } from './analyzeDiffImpact.js';
+import { output } from './shared.js';
+export async function buildRerunScope(input, context) {
+    const stats = context.ciArtifacts.readStats(input.statsFile);
+    const diffImpact = input.changedFiles?.length
+        ? await analyzeDiffImpact({ changedFiles: input.changedFiles }, context)
+        : null;
+    const rerunSpecs = [
+        ...(stats.failed_specs ?? []),
+        ...(diffImpact?.repo_paths.filter((repoPath) => repoPath.endsWith('.cy.js')) ?? []),
+    ];
+    const uniqueSpecs = [...new Set(rerunSpecs)];
+    return output(`Built rerun scope with ${uniqueSpecs.length} spec candidate(s).`, uniqueSpecs.map((repoPath) => ({ type: 'test', label: 'rerun spec', path: repoPath })), [
+        'Run the union of failed specs and impacted specs first.',
+        'Keep the rerun pack minimal before escalating to a broader suite.',
+    ], uniqueSpecs.length === 0 ? ['No explicit rerun spec candidates were discovered.'] : []);
+}

package/dist/src/domain/buildSetupTeardownPlan.d.ts

@@ -0,0 +1,23 @@
+import type { AppContext } from '../appContext.js';
+export declare function buildSetupTeardownPlan(input: {
+    area: string;
+    feature: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/buildSetupTeardownPlan.js

@@ -0,0 +1,13 @@
+import { evidenceFile, output } from './shared.js';
+export async function buildSetupTeardownPlan(input, context) {
+    const docs = context.autotests2.getAreaDocs();
+    const initPattern = input.area === 'constructor' ? 'initConf()' : 'init()';
+    return output(`Setup/teardown for ${input.feature} in ${input.area}: bootstrap with ${initPattern}, reuse existing auth and wait helpers, and keep teardown inside existing commands.`, [
+        evidenceFile('base support', input.area === 'constructor' ? `${context.config.repos.autotests2}/cypress/support/baseConf.js` : `${context.config.repos.autotests2}/cypress/support/base.js`),
+        evidenceFile('testing rules', docs.testingPath, docs.testingText.slice(0, 220)),
+    ], [
+        `Call ${initPattern} at the describe level.`,
+        'Use cy.waitFormsInFr / cy.waitVcmForm instead of ad-hoc sleeps.',
+        'Reuse auth helpers from cypress/support/auth.commands.js before adding setup code.',
+    ]);
+}

package/dist/src/domain/findExistingTestAssets.d.ts

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function findExistingTestAssets(input: {
+    query: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/findExistingTestAssets.js

@@ -0,0 +1,50 @@
+import { queryDocuments } from '../knowledge/repositories.js';
+import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
+import { truncate } from '../utils/textUtils.js';
+import { ensureIndexed, evidenceFile, output } from './shared.js';
+export async function findExistingTestAssets(input, context) {
+    await ensureIndexed(context);
+    const indexedPrimary = queryDocuments(context.database, input.query, {
+        repoKind: 'autotests2',
+        sourceKinds: ['spec', 'command', 'helper', 'selector'],
+        limit: 12,
+    });
+    const indexedReusable = queryDocuments(context.database, 'Cypress Commands helper selector getWidget selectForm waitVcmForm', {
+        repoKind: 'autotests2',
+        sourceKinds: ['command', 'helper', 'selector'],
+        limit: 6,
+    });
+    const indexed = dedupeByPath([...indexedPrimary, ...indexedReusable]);
+    const indexedEvidence = indexed.map((item) => evidenceFile(item.title || 'indexed result', item.path, truncate(item.body, 220), {
+        retrieval: 'knowledge-store',
+    }));
+    if (indexedEvidence.length > 0) {
+        return output(`Found ${indexedEvidence.length} indexed asset candidate(s) related to '${input.query}'.`, indexedEvidence, [
+            'Reuse indexed specs and commands before creating a new draft.',
+            'Fall back to direct scan only when indexed evidence is insufficient.',
+        ]);
+    }
+    const assets = await extractTestAssets({
+        root: context.config.repos.autotests2,
+        featureHint: input.query,
+    });
+    const evidence = [
+        ...assets.specs.slice(0, 6).map((spec) => evidenceFile('matched spec', spec.path, truncate(spec.body, 220), { score: spec.score, retrieval: 'direct-scan' })),
+        ...assets.commands.slice(0, 4).map((command) => evidenceFile(`command ${command.name}`, command.path, undefined, { retrieval: 'direct-scan' })),
+        ...assets.helpers.slice(0, 4).map((helper) => evidenceFile(`helper ${helper.name}`, helper.path, undefined, { retrieval: 'direct-scan' })),
+    ];
+    return output(`Found ${assets.specs.length} specs, ${assets.commands.length} commands, and ${assets.helpers.length} helper candidates related to '${input.query}'.`, evidence, [
+        'Reuse matching specs before creating a new draft.',
+        'Prefer existing Cypress commands and helpers over ad-hoc Cypress chains.',
+    ], assets.warnings);
+}
+function dedupeByPath(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item.path)) {
+            return false;
+        }
+        seen.add(item.path);
+        return true;
+    });
+}

package/dist/src/domain/findFrontendContract.d.ts

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function findFrontendContract(input: {
+    widget: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;

package/dist/src/domain/findFrontendContract.js

@@ -0,0 +1,13 @@
+import { extractFrontendContract } from '../indexer/extractors/frontendContractExtractor.js';
+import { evidenceFile, output } from './shared.js';
+export async function findFrontendContract(input, context) {
+    const contract = await extractFrontendContract({
+        root: context.config.repos.caseplatformWeb,
+        widgetHint: input.widget,
+    });
+    const evidence = contract.snippets.map((snippet) => evidenceFile(`${input.widget} ${snippet.label}`, snippet.path, snippet.snippet, { label: snippet.label }));
+    return output(`${input.widget} exposes ${contract.properties.length} properties, ${contract.events.length} events, and ${contract.methods.length} methods.`, evidence, [
+        `Use ${contract.properties[0] ?? 'the extracted properties'} as the starting point for spec assertions.`,
+        'Cross-check runtime branches before concluding the widget is fully covered.',
+    ], contract.warnings, contract.files);
+}

package/dist/src/domain/findFrontendRuntimeLogic.d.ts

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function findFrontendRuntimeLogic(input: {
+    widget: string;
+}, context: AppContext): Promise<{
+    warnings: string[];
+    summary: string;
+    evidence: {
+        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        label: string;
+        path?: string | undefined;
+        locator?: string | undefined;
+        snippet?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    recommended_actions: string[];
+    repo_paths: string[];
+    confidence: {
+        score: number;
+        level: "low" | "medium" | "high";
+        rationale: string[];
+    };
+}>;