@mknrt/autotests-overkill 1.1.0

package/dist/src/domain/findFrontendRuntimeLogic.js

@@ -0,0 +1,28 @@
+import { extractFrontendRuntimeLogic } from '../indexer/extractors/frontendRuntimeExtractor.js';
+import { evidenceFile, output } from './shared.js';
+export async function findFrontendRuntimeLogic(input, context) {
+    const runtime = await extractFrontendRuntimeLogic({
+        root: context.config.repos.caseplatformWeb,
+        widgetHint: input.widget,
+    });
+    return output(`Found ${runtime.runtimeSignals.length} runtime signals for ${input.widget}, including methods, branches, and event triggers.`, selectDiverseSignals(runtime.runtimeSignals, 10).map((signal) => evidenceFile(`${signal.kind} ${signal.name}`, signal.path, signal.detail, { kind: signal.kind })), [
+        'Use branch evidence to decide where current specs miss state transitions.',
+        'Treat event binding changes as candidate rerun triggers.',
+    ], runtime.warnings, runtime.runtimeSignals.map((signal) => signal.path));
+}
+function selectDiverseSignals(signals, limit) {
+    const perPath = new Map();
+    const selected = [];
+    for (const signal of signals) {
+        const count = perPath.get(signal.path) ?? 0;
+        if (count >= 2) {
+            continue;
+        }
+        selected.push(signal);
+        perPath.set(signal.path, count + 1);
+        if (selected.length >= limit) {
+            break;
+        }
+    }
+    return selected;
+}

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

@@ -0,0 +1,23 @@
+import type { AppContext } from '../appContext.js';
+export declare function findTestAreaContext(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/findTestAreaContext.js

@@ -0,0 +1,30 @@
+import { queryDocuments } from '../knowledge/repositories.js';
+import { ensureIndexed, evidenceFile, output } from './shared.js';
+export async function findTestAreaContext(input, context) {
+    const docs = context.autotests2.getAreaDocs();
+    const area = input.area ?? inferArea(input.feature ?? '');
+    const initPattern = area === 'constructor' ? 'initConf()' : 'init()';
+    const selectPattern = area === 'constructor' ? 'cy.selectAppInConstructor(...)' : 'cy.selectForm(...)';
+    await ensureIndexed(context);
+    const indexedDocs = queryDocuments(context.database, area === 'constructor' ? 'initConf constructor' : 'init selectForm formRunner', {
+        repoKind: 'autotests2',
+        sourceKinds: ['doc'],
+        limit: 4,
+    });
+    const directEvidence = [
+        docs.contextText ? evidenceFile('project context', docs.contextPath, docs.contextText.slice(0, 220), { retrieval: 'direct-scan' }) : null,
+        docs.testingText ? evidenceFile('testing rules', docs.testingPath, docs.testingText.slice(0, 220), { retrieval: 'direct-scan' }) : null,
+    ].filter((item) => item !== null);
+    const indexedEvidence = indexedDocs.map((item) => evidenceFile(item.title, item.path, item.body.slice(0, 220), { retrieval: 'knowledge-store' }));
+    const evidence = directEvidence.length > 0 ? directEvidence : indexedEvidence;
+    return output(`Area '${area}' uses ${initPattern} as the primary bootstrap pattern and keeps selectors stable via project helpers.`, evidence, [
+        `Bootstrap the draft with ${initPattern}.`,
+        `Use ${selectPattern} when navigating to the feature under test.`,
+    ]);
+}
+function inferArea(feature) {
+    if (/constructor|arm|repository|application/i.test(feature)) {
+        return 'constructor';
+    }
+    return 'formRunner';
+}

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

@@ -0,0 +1,23 @@
+import type { AppContext } from '../appContext.js';
+export declare function generateSpecBlueprint(input: {
+    feature: string;
+    area?: 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/generateSpecBlueprint.js

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
+import { safeRelative, toPosixPath } from '../utils/pathUtils.js';
+import { evidenceFile, output } from './shared.js';
+export async function generateSpecBlueprint(input, context) {
+    const assets = await extractTestAssets({
+        root: context.config.repos.autotests2,
+        featureHint: input.feature,
+    });
+    const area = input.area ?? inferAreaFromSpecs(assets.specs, input.feature);
+    const referenceSpecs = pickReferenceSpecs(assets.specs, area);
+    const referenceSpec = referenceSpecs[0];
+    const initIdentifier = area === 'constructor' ? 'initConf' : 'init';
+    const initExpose = area === 'constructor' ? 'appNameConf' : 'appVcm2Id';
+    const importTarget = buildImportTarget(referenceSpec?.path, context.config.repos.autotests2, area);
+    const hookPlan = buildHookPlan(referenceSpec, area);
+    const reuseCandidates = [
+        ...pickNamedCommands(assets.commands, ['getWidget', 'selectForm', 'selectAppInConstructor', 'waitVcmForm', 'waitFormsInFr', 'fixCypressSpec']),
+        ...pickHelpers(assets.helpers),
+    ];
+    const selectorPaths = assets.selectors
+        .filter((selector) => isFeatureSpecificSelector(selector.path, input.feature))
+        .slice(0, 3)
+        .map((selector) => toPosixPath(selector.path));
+    const selectorGuidance = selectorPaths.length > 0
+        ? `Prefer selectors already defined in ${selectorPaths.join(', ')} before adding new hooks.`
+        : 'Prefer cy.getWidget(...) plus the selectors tree from cypress/support/selectors/index.js; do not add new selectors under cypress/support/selectors/elements.';
+    const blueprint = buildBlueprint({
+        area,
+        feature: input.feature,
+        initIdentifier,
+        initExpose,
+        importTarget,
+        hookPlan,
+        referenceSpecPath: referenceSpec ? toPosixPath(referenceSpec.path) : undefined,
+        reuseCandidates,
+        selectorGuidance,
+    });
+    return output(`Generated a ${area}-oriented spec draft for ${input.feature} with reference-spec setup, import targets, reuse candidates, and selector guidance from autotests2.`, [
+        ...referenceSpecs.map((spec) => evidenceFile('reference spec', spec.path)),
+        ...reuseCandidates.slice(0, 4).map((candidate) => evidenceFile(candidate.label, candidate.path)),
+        ...selectorPaths.slice(0, 2).map((selectorPath) => evidenceFile('selector file', selectorPath)),
+        {
+            type: 'symbol',
+            label: 'blueprint',
+            snippet: blueprint,
+        },
+    ], [
+        `Import ${initIdentifier} from ${importTarget} and keep bootstrap at the describe level.`,
+        `Reuse the ${hookPlan.beforeSummary} before() pattern and the ${hookPlan.beforeEachSummary} beforeEach() pattern from ${referenceSpec ? toPosixPath(referenceSpec.path) : 'the closest area reference spec'}.`,
+        `Borrow commands/helpers from ${reuseCandidates.map((candidate) => candidate.name).join(', ')} before introducing new support code.`,
+        selectorGuidance,
+    ], assets.warnings);
+}
+function buildBlueprint(context) {
+    const tags = context.area === 'constructor'
+        ? `[ '@constructor', '@regress' ]`
+        : `[ '@vcm', '@regress', '@parallel-true' ]`;
+    const reuseLines = context.reuseCandidates.length > 0
+        ? context.reuseCandidates.map((candidate) => ` * - ${candidate.name}: ${toPosixPath(candidate.path)}`).join('\n')
+        : ' * - cy.getWidget / cy.waitVcmForm from cypress/support/commands';
+    const referenceComment = context.referenceSpecPath
+        ? ` * Reference spec: ${context.referenceSpecPath}`
+        : ' * Reference spec: inspect the closest area match in autotests2 before finalizing widget names.';
+    return `/**\n * Draft spec blueprint for ${context.feature}\n${referenceComment}\n * Suggested import target: ${context.importTarget}\n * Setup hints:\n * - ${context.hookPlan.beforeSummary}\n * - ${context.hookPlan.beforeEachSummary}\n * Reuse candidates:\n${reuseLines}\n * Selector guidance: ${context.selectorGuidance}\n */\nimport ${context.initIdentifier} from '${context.importTarget}';\n\ndescribe('[Overkill] ${context.feature}', { tags: ${tags} }, () => {\n  ${context.initIdentifier}(Cypress.expose('${context.initExpose}'));\n\n${renderHook('before', context.hookPlan.beforeLines)}\n\n${renderHook('beforeEach', context.hookPlan.beforeEachLines)}\n\n  const target = '<widget control name from reference spec>';\n\n  it('covers the primary ${context.feature} flow', () => {\n    cy.getWidget('<action widget from reference spec>').click();\n    cy.getWidget(target).should('be.visible');\n    cy.getWidget(target)\n      .find('<stable inner selector or selector-tree locator>')\n      .should('exist');\n  });\n});`;
+}
+function renderHook(name, lines) {
+    const body = lines.map((line) => `    ${line}`).join('\n');
+    return `  ${name}(() => {\n${body}\n  });`;
+}
+function buildHookPlan(referenceSpec, area) {
+    const beforeLines = sanitizeHookLines(extractHookLines(referenceSpec?.body, 'before'));
+    const beforeEachLines = sanitizeHookLines(extractHookLines(referenceSpec?.body, 'beforeEach'));
+    const fallbackBeforeLines = defaultBeforeLines(area);
+    const fallbackBeforeEachLines = defaultBeforeEachLines(area);
+    return {
+        beforeLines: beforeLines.length > 0 ? beforeLines : fallbackBeforeLines,
+        beforeEachLines: beforeEachLines.length > 0 ? beforeEachLines : fallbackBeforeEachLines,
+        beforeSummary: summarizeHook(beforeLines.length > 0 ? beforeLines : fallbackBeforeLines),
+        beforeEachSummary: summarizeHook(beforeEachLines.length > 0 ? beforeEachLines : fallbackBeforeEachLines),
+    };
+}
+function extractHookLines(body, hookName) {
+    if (!body) {
+        return [];
+    }
+    const patterns = [
+        new RegExp(`${hookName}\\(\\(\\) => \\{([\\s\\S]*?)\\n\\s*\\}\\);`),
+        new RegExp(`${hookName}\\(function \\(\\) \\{([\\s\\S]*?)\\n\\s*\\}\\);`),
+    ];
+    for (const pattern of patterns) {
+        const match = body.match(pattern);
+        if (match?.[1]) {
+            return match[1]
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .filter((line) => !line.startsWith('//'));
+        }
+    }
+    return [];
+}
+function sanitizeHookLines(lines) {
+    return lines.map((line) => {
+        if (line.startsWith('cy.selectForm(')) {
+            return "cy.selectForm('<form name from reference spec>');";
+        }
+        if (line.startsWith('cy.selectAppInConstructor(')) {
+            return "cy.selectAppInConstructor('<app or branch from reference spec>');";
+        }
+        if (line.includes('.contains(')) {
+            return line
+                .replace(/cy\.getWidget\((?:'|")[^'"]+(?:'|")\)/, "cy.getWidget('<navigation widget from reference spec>')")
+                .replace(/\.contains\((?:'|")[^'"]+(?:'|")\)/, ".contains('<navigation text from reference spec>')");
+        }
+        if (line.startsWith('cy.getWidget(')) {
+            return "cy.getWidget('<widget control name from reference spec>').should('be.visible');";
+        }
+        return line;
+    });
+}
+function defaultBeforeLines(area) {
+    if (area === 'constructor') {
+        return [
+            'cy.waitLoading();',
+        ];
+    }
+    return [
+        "cy.waitFormsInFr('<form count if the feature opens nested forms>');",
+    ];
+}
+function defaultBeforeEachLines(area) {
+    if (area === 'constructor') {
+        return [
+            "cy.selectAppInConstructor('<app or branch from reference spec>');",
+            'cy.waitLoading();',
+        ];
+    }
+    return [
+        'cy.waitVcmForm();',
+        'cy.fixCypressSpec();',
+        "cy.selectForm('<form name from reference spec>');",
+        'cy.waitVcmForm();',
+        "cy.getWidget('<widget control name from reference spec>').should('be.visible');",
+    ];
+}
+function summarizeHook(lines) {
+    return lines
+        .slice(0, 2)
+        .map((line) => line.replace(/;$/, ''))
+        .join(' + ');
+}
+function pickReferenceSpecs(specs, area) {
+    const inArea = specs.filter((spec) => toPosixPath(spec.path).includes(`/${area}/`));
+    return (inArea.length > 0 ? inArea : specs).slice(0, 3);
+}
+function inferAreaFromSpecs(specs, feature) {
+    const scored = specs.slice(0, 8).reduce((acc, spec) => {
+        const specPath = toPosixPath(spec.path);
+        if (specPath.includes('/constructor/')) {
+            acc.constructor += 1;
+        }
+        if (specPath.includes('/formRunner/')) {
+            acc.formRunner += 1;
+        }
+        return acc;
+    }, { constructor: 0, formRunner: 0 });
+    if (scored.formRunner > scored.constructor) {
+        return 'formRunner';
+    }
+    if (scored.constructor > scored.formRunner) {
+        return 'constructor';
+    }
+    return /constructor|arm|repository|application/i.test(feature) ? 'constructor' : 'formRunner';
+}
+function buildImportTarget(referenceSpecPath, autotestsRoot, area) {
+    const supportFile = area === 'constructor' ? 'baseConf.js' : 'base.js';
+    const fromDir = referenceSpecPath
+        ? path.dirname(referenceSpecPath)
+        : path.join(autotestsRoot, 'cypress', 'e2e', 'tests', area);
+    const toFile = path.join(autotestsRoot, 'cypress', 'support', supportFile);
+    const relativePath = safeRelative(fromDir, toFile).replace(/\.js$/, '');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function pickNamedCommands(matches, preferredNames) {
+    const picked = [];
+    for (const preferredName of preferredNames) {
+        const match = matches.find((candidate) => candidate.name === preferredName);
+        if (match) {
+            picked.push({
+                name: match.name,
+                label: `command ${match.name}`,
+                path: match.path,
+            });
+        }
+    }
+    return picked;
+}
+function pickHelpers(matches) {
+    return matches.slice(0, 2).map((match) => ({
+        name: match.name,
+        label: `helper ${match.name}`,
+        path: match.path,
+    }));
+}
+function isFeatureSpecificSelector(selectorPath, feature) {
+    const normalizedPath = toPosixPath(selectorPath).toLowerCase();
+    return feature
+        .toLowerCase()
+        .split(/[\s_\-/]+/)
+        .filter((token) => token.length >= 4)
+        .some((token) => normalizedPath.includes(token));
+}

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

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function mapFeatureToExistingCoverage(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/mapFeatureToExistingCoverage.js

@@ -0,0 +1,56 @@
+import { evidenceFile } from './shared.js';
+import { extractTestAssets } from '../indexer/extractors/testAssetExtractor.js';
+import { output } from './shared.js';
+export async function mapFeatureToExistingCoverage(input, context) {
+    const assets = await extractTestAssets({
+        root: context.config.repos.autotests2,
+        featureHint: input.widget,
+    });
+    const sourceFiles = await context.caseplatform.resolveFeatureFiles(input.widget);
+    const evidence = assets.specs.slice(0, 8).map((spec) => evidenceFile('coverage spec', spec.path, spec.body.slice(0, 180), { score: spec.score }));
+    const sourceEvidence = selectSourceHints(sourceFiles.primaryFiles, context).slice(0, 4).map((filePath) => evidenceFile('source hint', filePath, undefined, { kind: context.caseplatform.classifyFileKind(filePath) }));
+    return output(`Mapped ${assets.specs.length} existing specs to ${input.widget}${sourceEvidence.length > 0 ? ` and found ${sourceEvidence.length} caseplatform source hint(s)` : ''}.`, [...evidence, ...sourceEvidence], [
+        'Prioritize the highest-scoring specs as reuse candidates.',
+        sourceEvidence.length > 0
+            ? 'Use attached caseplatform source hints to inspect implementation before expanding coverage.'
+            : 'If implementation sources are unclear, run frontend contract/runtime tools explicitly.',
+        'Check whether container and non-container coverage are both present.',
+    ], assets.warnings);
+}
+function selectSourceHints(filePaths, context) {
+    const byKind = new Map();
+    for (const filePath of filePaths) {
+        const kind = context.caseplatform.classifyFileKind(filePath);
+        byKind.set(kind, [...(byKind.get(kind) ?? []), filePath]);
+    }
+    const rankedViews = rankViewHints(byKind.get('view') ?? []);
+    return [
+        ...rankedViews.slice(0, 2),
+        ...(byKind.get('controller') ?? []).slice(0, 1),
+        ...(byKind.get('model') ?? []).slice(0, 1),
+        ...filePaths,
+    ].filter((filePath, index, items) => items.indexOf(filePath) === index);
+}
+function rankViewHints(filePaths) {
+    return filePaths.slice().sort((left, right) => scoreViewHint(right) - scoreViewHint(left));
+}
+function scoreViewHint(filePath) {
+    const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+    let score = 0;
+    if (normalized.endsWith('/tabpanel.js')) {
+        score += 6;
+    }
+    if (normalized.endsWith('/grid.js')) {
+        score += 5;
+    }
+    if (normalized.endsWith('/form.js')) {
+        score += 4;
+    }
+    if (normalized.includes('/apperror/')) {
+        score += 3;
+    }
+    if (normalized.includes('/application/')) {
+        score += 2;
+    }
+    return score;
+}

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

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function recommendSelectorStrategy(input: {
+    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/recommendSelectorStrategy.js

@@ -0,0 +1,13 @@
+import { evidenceFile, output } from './shared.js';
+export async function recommendSelectorStrategy(input, context) {
+    const selectors = await context.autotests2.findSelectors(input.feature);
+    const commands = await context.autotests2.findCommands();
+    const getWidgetCommand = commands.find((command) => command.name === 'getWidget');
+    return output(`Selector strategy for ${input.feature}: prefer project widget helpers and stable testguid-backed selectors.`, [
+        ...(getWidgetCommand ? [evidenceFile('getWidget command', getWidgetCommand.path)] : []),
+        ...selectors.slice(0, 4).map((selector) => evidenceFile('selector file', selector.path)),
+    ], [
+        'Start with cy.getWidget(...) for runtime widgets.',
+        'Prefer selectors tree and testguid-based hooks over DOM-order selectors.',
+    ], selectors.length === 0 ? [`No dedicated selector file matched '${input.feature}', so fallback to getWidget is recommended.`] : []);
+}

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

@@ -0,0 +1,5 @@
+import type { AppContext } from '../appContext.js';
+import { type EvidenceItem, type NormalizedToolOutput } from '../contracts/toolOutput.js';
+export declare function ensureIndexed(context: AppContext): Promise<void>;
+export declare function evidenceFile(label: string, filePath: string, snippet?: string, metadata?: Record<string, unknown>): EvidenceItem;
+export declare function output(summary: string, evidence: EvidenceItem[], recommendedActions: string[], warnings?: string[], repoPaths?: string[]): NormalizedToolOutput;

package/dist/src/domain/shared.js

@@ -0,0 +1,36 @@
+import { buildToolOutput } from '../contracts/toolOutput.js';
+import { confidenceFromEvidence } from '../contracts/confidence.js';
+import { refreshKnowledge } from '../indexer/refreshPipeline.js';
+import { countDocuments } from '../knowledge/repositories.js';
+import { unique } from '../utils/pathUtils.js';
+let indexedContexts = new WeakSet();
+export async function ensureIndexed(context) {
+    if (indexedContexts.has(context)) {
+        return;
+    }
+    if (countDocuments(context.database) > 0) {
+        indexedContexts.add(context);
+        return;
+    }
+    await refreshKnowledge(context);
+    indexedContexts.add(context);
+}
+export function evidenceFile(label, filePath, snippet, metadata) {
+    return {
+        type: 'file',
+        label,
+        path: filePath,
+        snippet,
+        metadata,
+    };
+}
+export function output(summary, evidence, recommendedActions, warnings = [], repoPaths) {
+    return buildToolOutput({
+        summary,
+        evidence,
+        recommended_actions: recommendedActions,
+        repo_paths: unique(repoPaths ?? evidence.flatMap((item) => item.path ? [item.path] : [])),
+        confidence: confidenceFromEvidence(evidence.length, warnings),
+        warnings,
+    });
+}

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

@@ -0,0 +1,22 @@
+import type { AppContext } from '../appContext.js';
+export declare function summarizeCiContext(input: {
+    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/summarizeCiContext.js

@@ -0,0 +1,35 @@
+import { evidenceFile, output } from './shared.js';
+export async function summarizeCiContext(input, context) {
+    const stats = context.ciArtifacts.readStats(input.statsFile);
+    const [reportPortal, gitlab] = await Promise.all([
+        context.reportPortal.describeLaunch(stats),
+        context.gitlab.describePipeline(),
+    ]);
+    const warnings = [
+        ...reportPortal.warnings,
+        ...gitlab.warnings,
+    ];
+    return output(`CI context: ${stats.total ?? 0} tests, ${stats.passed ?? 0} passed, ${stats.failed ?? 0} failed, ${stats.skipped ?? 0} skipped.`, [
+        evidenceFile('stats report', input.statsFile, JSON.stringify(stats).slice(0, 220)),
+        ...(reportPortal.launchLink ? [{
+                type: 'report',
+                label: reportPortal.launchStatus ? `ReportPortal launch (${reportPortal.launchStatus})` : 'ReportPortal launch',
+                snippet: reportPortal.launchLink,
+                metadata: { source: reportPortal.source, launchId: reportPortal.launchId },
+            }] : []),
+        ...(gitlab.pipelineUrl ? [{
+                type: 'report',
+                label: gitlab.pipelineStatus ? `GitLab pipeline (${gitlab.pipelineStatus})` : 'GitLab pipeline',
+                snippet: gitlab.pipelineUrl,
+                metadata: { source: gitlab.source },
+            }] : []),
+    ], [
+        reportPortal.launchLink
+            ? 'Use the ReportPortal launch link when deeper run metadata is needed.'
+            : 'Rely on local artifact metadata first; add ReportPortal config only when live launch enrichment is needed.',
+        gitlab.pipelineUrl
+            ? 'Use the GitLab pipeline link when you need upstream CI context.'
+            : 'Rely on local artifacts first; add GitLab projectId/token only when live pipeline lookup is required.',
+        'Combine this summary with artifact triage before changing test code.',
+    ], warnings);
+}

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

@@ -0,0 +1,25 @@
+import type { AppContext } from '../appContext.js';
+export declare function triageFailedRun(input: {
+    statsFile: string;
+    screenshotsRoot: string;
+    videosRoot: string;
+    apiCaptureRoot: 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/triageFailedRun.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import { evidenceFile, output } from './shared.js';
+export async function triageFailedRun(input, context) {
+    const stats = context.ciArtifacts.readStats(input.statsFile);
+    const [reportPortal, gitlab] = await Promise.all([
+        context.reportPortal.describeLaunch(stats),
+        context.gitlab.describePipeline(),
+    ]);
+    const screenshots = context.ciArtifacts.listArtifacts(input.screenshotsRoot, '**/*.png');
+    const videos = context.ciArtifacts.listArtifacts(input.videosRoot, '**/*.mp4');
+    const apiCaptures = context.ciArtifacts.listArtifacts(input.apiCaptureRoot, '**/*.json');
+    const failedSpecs = stats.failed_specs ?? [];
+    const repeatedAttempts = screenshots.filter((filePath) => filePath.includes('attempt 2')).length;
+    const warnings = failedSpecs.length === 0
+        ? ['Current stats file reports zero failed specs; using persisted screenshots and artifact residue for triage context.']
+        : [];
+    warnings.push(...reportPortal.warnings, ...gitlab.warnings);
+    const actions = [
+        failedSpecs.length > 0 ? 'Rerun only the failed specs first.' : 'Start from the specs named in persisted screenshots before broad reruns.',
+        repeatedAttempts > 0 ? 'Inspect flaky or environment-sensitive failures because repeated attempts are present.' : 'Inspect first-failure artifacts before assuming flakiness.',
+        apiCaptures.length > 0 ? 'Compare API capture payloads for the affected run before editing selectors.' : 'Capture API traffic on the next rerun to reduce ambiguity.',
+    ];
+    return output(`CI triage summary: stats show ${stats.total ?? 0} tests, ${stats.failed ?? 0} current failures, ${screenshots.length} screenshots, ${videos.length} videos, and ${apiCaptures.length} captured API artifacts.`, [
+        evidenceFile('stats report', input.statsFile, JSON.stringify({
+            total: stats.total,
+            passed: stats.passed,
+            failed: stats.failed,
+            launch_id: stats.launch_id,
+        })),
+        ...failedSpecs.slice(0, 5).map((specPath) => ({ type: 'test', label: 'failed spec', path: specPath })),
+        ...screenshots.slice(0, 5).map((filePath) => evidenceFile('failure screenshot', filePath, fs.existsSync(filePath) ? undefined : 'missing')),
+        ...videos.slice(0, 3).map((filePath) => evidenceFile('failure video', filePath)),
+        ...(reportPortal.launchLink ? [{
+                type: 'report',
+                label: reportPortal.launchStatus ? `ReportPortal launch (${reportPortal.launchStatus})` : 'ReportPortal launch',
+                snippet: reportPortal.launchLink,
+                metadata: { source: reportPortal.source, launchId: reportPortal.launchId },
+            }] : []),
+        ...(gitlab.pipelineUrl ? [{
+                type: 'report',
+                label: gitlab.pipelineStatus ? `GitLab pipeline (${gitlab.pipelineStatus})` : 'GitLab pipeline',
+                snippet: gitlab.pipelineUrl,
+                metadata: { source: gitlab.source },
+            }] : []),
+    ], actions, warnings);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './appContext.js';
+export * from './config/consumerConfig.js';
+export * from './contracts/toolOutput.js';
+export * from './mcp/server.js';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+export * from './appContext.js';
+export * from './config/consumerConfig.js';
+export * from './contracts/toolOutput.js';
+export * from './mcp/server.js';

package/dist/src/indexer/extractors/frontendContractExtractor.d.ts

@@ -0,0 +1,17 @@
+export type FrontendContractExtraction = {
+    widgetName: string;
+    properties: string[];
+    methods: string[];
+    events: string[];
+    files: string[];
+    snippets: Array<{
+        label: string;
+        path: string;
+        snippet: string;
+    }>;
+    warnings: string[];
+};
+export declare function extractFrontendContract(input: {
+    root: string;
+    widgetHint: string;
+}): Promise<FrontendContractExtraction>;