@mknrt/autotests-overkill 1.1.4 → 1.2.0

package/dist/src/domain/reviewTestDraft.js

@@ -0,0 +1,226 @@
+import { unique } from '../utils/pathUtils.js';
+import { analyzeTestGaps } from './analyzeTestGaps.js';
+import { buildSetupTeardownPlan } from './buildSetupTeardownPlan.js';
+import { findBackendTestContext } from './findBackendTestContext.js';
+import { findExistingTestAssets } from './findExistingTestAssets.js';
+import { findTestAreaContext } from './findTestAreaContext.js';
+import { output } from './shared.js';
+import { recommendSelectorStrategy } from './recommendSelectorStrategy.js';
+export async function reviewTestDraft(input, context) {
+    const area = input.area ?? inferArea(input.feature, input.draft);
+    const backendContextPromise = shouldQueryBackendContext(input.feature, input.draft, area)
+        ? findBackendTestContext({ query: input.feature }, context)
+        : Promise.resolve(emptyToolOutput(`No backend context review was needed for '${input.feature}'.`));
+    const [assets, selectorStrategy, areaContext, setupPlan, gaps, backendContext] = await Promise.all([
+        findExistingTestAssets({ query: input.feature }, context),
+        recommendSelectorStrategy({ feature: input.feature }, context),
+        findTestAreaContext({ area, feature: input.feature }, context),
+        buildSetupTeardownPlan({ area, feature: input.feature }, context),
+        analyzeTestGaps({ widget: input.feature }, context),
+        backendContextPromise,
+    ]);
+    const issues = reviewDraft({
+        draft: input.draft,
+        area,
+        gaps,
+        backendContext,
+    });
+    const evidence = [
+        ...issues.map((issue) => ({
+            type: 'symbol',
+            label: `draft issue ${issue.kind}`,
+            snippet: issue.message,
+            metadata: { action: issue.action, area, severity: issue.severity },
+        })),
+        ...supportingEvidence(assets, 'find_existing_test_assets', 3),
+        ...supportingEvidence(selectorStrategy, 'recommend_selector_strategy', 2),
+        ...supportingEvidence(areaContext, 'find_test_area_context', 2),
+        ...supportingEvidence(setupPlan, 'build_setup_teardown_plan', 2),
+        ...supportingEvidence(gaps, 'analyze_test_gaps', 2),
+        ...supportingEvidence(backendContext, 'find_backend_test_context', 3),
+    ];
+    const recommendedActions = unique([
+        ...issues.map((issue) => issue.action),
+        ...selectorStrategy.recommended_actions.slice(0, 1),
+        ...setupPlan.recommended_actions.slice(0, 2),
+        ...backendContext.recommended_actions.slice(0, 2),
+        ...(gaps.evidence.length > 0
+            ? ['Cross-check uncovered runtime signals before considering the draft complete.']
+            : []),
+    ]);
+    const warnings = unique([
+        'Draft review is heuristic and checks Cypress patterns by string analysis; validate the final edits against the referenced project files.',
+        ...assets.warnings,
+        ...selectorStrategy.warnings,
+        ...areaContext.warnings,
+        ...setupPlan.warnings,
+        ...gaps.warnings,
+        ...backendContext.warnings,
+    ]);
+    const repoPaths = unique([
+        ...assets.repo_paths,
+        ...selectorStrategy.repo_paths,
+        ...areaContext.repo_paths,
+        ...setupPlan.repo_paths,
+        ...gaps.repo_paths,
+        ...backendContext.repo_paths,
+    ]);
+    return output(buildReviewSummary(input.feature, area, issues), evidence, recommendedActions, warnings, repoPaths);
+}
+function reviewDraft(input) {
+    const issues = [];
+    const draft = input.draft;
+    if (input.area === 'constructor') {
+        if (!/\binitConf\s*\(/.test(draft)) {
+            issues.push({
+                kind: 'bootstrap',
+                message: 'Constructor draft does not bootstrap with initConf().',
+                action: 'Switch bootstrap to initConf() and expose appNameConf at the describe level.',
+                severity: 'high',
+            });
+        }
+        if (!/cy\.selectAppInConstructor\s*\(/.test(draft)) {
+            issues.push({
+                kind: 'bootstrap',
+                message: 'Constructor draft bypasses cy.selectAppInConstructor(...) navigation reuse.',
+                action: 'Reuse cy.selectAppInConstructor(...) instead of rebuilding constructor navigation.',
+                severity: 'high',
+            });
+        }
+    }
+    else {
+        if (!/\binit\s*\(/.test(draft)) {
+            issues.push({
+                kind: 'bootstrap',
+                message: 'formRunner draft does not call init().',
+                action: 'Add init() at the describe level before reviewing assertions.',
+                severity: 'high',
+            });
+        }
+        if (!/cy\.selectForm\s*\(/.test(draft)) {
+            issues.push({
+                kind: 'bootstrap',
+                message: 'formRunner draft does not reuse cy.selectForm(...) navigation.',
+                action: 'Reuse cy.selectForm(...) from project patterns instead of custom navigation steps.',
+                severity: 'high',
+            });
+        }
+        if (!/cy\.waitVcmForm\s*\(/.test(draft)) {
+            issues.push({
+                kind: 'bootstrap',
+                message: 'formRunner draft does not reuse cy.waitVcmForm() around form navigation.',
+                action: 'Reuse cy.waitVcmForm() around form navigation instead of relying on incidental readiness.',
+                severity: 'medium',
+            });
+        }
+    }
+    if (/cy\.wait\(\s*\d+\s*\)/.test(draft)) {
+        issues.push({
+            kind: 'wait',
+            message: 'Draft uses ad-hoc cy.wait(number) sleeps.',
+            action: 'Replace cy.wait(number) with project wait helpers or explicit readiness assertions.',
+            severity: 'high',
+        });
+    }
+    if (hasBrittleSelector(draft) || !/cy\.getWidget\s*\(/.test(draft)) {
+        issues.push({
+            kind: 'selector',
+            message: 'Draft leans on brittle selectors or skips cy.getWidget(...) reuse.',
+            action: 'Prefer cy.getWidget(...) plus selector-tree or testguid-backed hooks over DOM-order selectors.',
+            severity: 'medium',
+        });
+    }
+    if (/click\(\s*\{\s*force\s*:\s*true/.test(draft) || hasSilentMutation(draft)) {
+        issues.push({
+            kind: 'mutation',
+            message: 'Draft relies on force clicks or direct DOM mutation patterns.',
+            action: 'Remove force clicks and silent DOM mutation patterns until widget readiness is proven explicitly.',
+            severity: 'high',
+        });
+    }
+    appendBackendIssues(issues, input.backendContext, draft);
+    const gapSignal = input.gaps.evidence
+        .find((item) => item.label.startsWith('uncovered branch') || item.label.startsWith('uncovered method') || item.label.startsWith('uncovered event'));
+    if (gapSignal) {
+        const gapHint = gapSignal.snippet ?? gapSignal.label.replace(/^uncovered (?:branch|method|event)\s+/i, '');
+        if (gapHint && !draft.includes(gapHint)) {
+            issues.push({
+                kind: 'coverage',
+                message: `Draft does not mention the current gap signal '${gapHint}'.`,
+                action: `Add an assertion or scenario covering '${gapHint}' before considering the draft complete.`,
+                severity: 'medium',
+            });
+        }
+    }
+    return issues;
+}
+function supportingEvidence(result, sourceTool, limit) {
+    return result.evidence.slice(0, limit).map((item) => ({
+        ...item,
+        metadata: {
+            ...item.metadata,
+            sourceTool,
+        },
+    }));
+}
+function inferArea(feature, draft) {
+    if (/\binitConf\s*\(|cy\.selectAppInConstructor\s*\(|@constructor/i.test(draft) || /constructor|auth|repository|application/i.test(feature)) {
+        return 'constructor';
+    }
+    return 'formRunner';
+}
+function shouldQueryBackendContext(feature, draft, area) {
+    return area === 'constructor'
+        || /\bcy\.request\s*\(|\bfetch\s*\(|\/platform\/|\/rs2\/|api-heavy|backend|request flow|taskId|poll/i.test(`${feature}\n${draft}`);
+}
+function emptyToolOutput(summary) {
+    return {
+        summary,
+        evidence: [],
+        recommended_actions: [],
+        repo_paths: [],
+        confidence: {
+            score: 0,
+            level: 'low',
+            rationale: ['Backend review branch was intentionally skipped for this draft.'],
+        },
+        warnings: [],
+    };
+}
+function buildReviewSummary(feature, area, issues) {
+    const highCount = issues.filter((issue) => issue.severity === 'high').length;
+    const mediumCount = issues.filter((issue) => issue.severity === 'medium').length;
+    return `Reviewed draft for ${feature} in ${area}: found ${issues.length} issue(s) with ${highCount} high severity and ${mediumCount} medium severity findings across project reuse, selector stability, setup patterns, and runtime gap hints.`;
+}
+function appendBackendIssues(issues, backendContext, draft) {
+    const hasBackendEvidence = backendContext.evidence.some((item) => item.label === 'api interaction' || item.label === 'backend endpoint');
+    if (!hasBackendEvidence) {
+        return;
+    }
+    const usesRawRequest = /\bcy\.request\s*\(|\bfetch\s*\(/.test(draft);
+    const reusesKnownFlow = /\bcy\.(sampleAction|waitForSampleAction|authConf|getCurrentAuthUser|logoutFromConstructor)\s*\(/.test(draft);
+    const hasCompletionCheck = /\bwaitFor[A-Z]|poll|status\b|its\(\s*['"]status['"]\s*\)|should\(\s*['"]eq['"]\s*,\s*(200|201|202)/.test(draft);
+    if (usesRawRequest && !reusesKnownFlow) {
+        issues.push({
+            kind: 'backend',
+            message: 'Draft calls backend requests directly instead of reusing the indexed project request flow.',
+            action: 'Reuse the linked autotests2 request flow instead of rebuilding API assumptions from scratch.',
+            severity: 'high',
+        });
+    }
+    if (!hasCompletionCheck) {
+        issues.push({
+            kind: 'backend',
+            message: 'Draft does not verify backend completion, response status, or polling for the indexed API-heavy flow.',
+            action: 'Preserve backend request order, required params, and completion polling from the indexed API interaction before adding UI assertions.',
+            severity: 'high',
+        });
+    }
+}
+function hasBrittleSelector(draft) {
+    return /nth-child|\.eq\(|\.first\(|\.last\(|\.children\(|>\s*div|>\s*span/.test(draft);
+}
+function hasSilentMutation(draft) {
+    return /\.invoke\(\s*['"](show|hide|remove|removeAttr|attr|prop|val|html)['"]/.test(draft)
+        || /\.trigger\(\s*['"](input|change|blur)['"]/.test(draft);
+}

package/dist/src/domain/shared.js

@@ -1,6 +1,7 @@
+import { existsSync } from 'node:fs';
 import { buildToolOutput } from '../contracts/toolOutput.js';
 import { confidenceFromEvidence } from '../contracts/confidence.js';
-import { refreshKnowledge } from '../indexer/refreshPipeline.js';
+import { getRefreshSignature, isRefreshStateExpired, readRefreshState, refreshKnowledge } from '../indexer/refreshPipeline.js';
 import { countDocuments } from '../knowledge/repositories.js';
 import { unique } from '../utils/pathUtils.js';
 let indexedContexts = new WeakSet();
@@ -8,13 +9,25 @@ export async function ensureIndexed(context) {
     if (indexedContexts.has(context)) {
         return;
     }
-    if (countDocuments(context.database) > 0) {
+    const refreshState = readRefreshState(context.config.cacheDir);
+    const currentSignature = getRefreshSignature(context);
+    if (countDocuments(context.database) > 0
+        && ((refreshState && refreshState.repoSignature === currentSignature && !isRefreshStateExpired(refreshState))
+            || (!refreshState && configuredReposUnavailable(context)))) {
         indexedContexts.add(context);
         return;
     }
     await refreshKnowledge(context);
     indexedContexts.add(context);
 }
+function configuredReposUnavailable(context) {
+    const repoRoots = [
+        context.config.repos.autotests2,
+        context.config.repos.caseplatformWeb,
+        context.config.repos.fisPlatform,
+    ].filter((value) => Boolean(value));
+    return repoRoots.every((repoRoot) => !existsSync(repoRoot));
+}
 export function evidenceFile(label, filePath, snippet, metadata) {
     return {
         type: 'file',

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

@@ -5,7 +5,7 @@ export declare function summarizeCiContext(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

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

@@ -8,7 +8,7 @@ export declare function triageFailedRun(input: {
     warnings: string[];
     summary: string;
     evidence: {
-        type: "symbol" | "config" | "file" | "test" | "artifact" | "report" | "diff";
+        type: "symbol" | "test" | "config" | "file" | "artifact" | "report" | "diff";
         label: string;
         path?: string | undefined;
         locator?: string | undefined;

package/dist/src/domain/triageFailedRun.js

@@ -44,9 +44,15 @@ export async function triageFailedRun(input, context) {
         })),
         ...apiBackendContext.interactionHits.map((item) => evidenceFile('api interaction', item.path, item.title, {
             confidence: parseMetadata(item.metadata_json).confidence,
+            normalizedPaths: parseMetadata(item.metadata_json).normalizedPaths,
+            whySelected: parseMetadata(item.metadata_json).whySelected,
         })),
         ...apiBackendContext.backendHits.map((item) => evidenceFile('backend endpoint', item.path, item.title, {
             confidence: parseMetadata(item.metadata_json).confidence,
+            endpointPath: parseMetadata(item.metadata_json).endpointPath,
+            whyMatched: parseMetadata(item.metadata_json).whyMatched,
+            paramNames: parseMetadata(item.metadata_json).paramNames,
+            ruleHints: parseMetadata(item.metadata_json).ruleHints,
         })),
         ...(reportPortal.launchLink ? [{
                 type: 'report',
@@ -104,12 +110,17 @@ async function matchApiCapturesToBackendContext(captureSignals, context) {
         return (metadata.confidence ?? 0) >= 0.7
             && (metadata.normalizedPaths ?? []).some((indexedPath) => captureSignals.some((signal) => pathsOverlap(indexedPath, signal.path)));
     });
-    const backendHits = interactionHits.length > 0
-        ? queryDocuments(context.database, interactionHits.map((item) => item.title).join(' '), {
+    const interactionPaths = [...new Set(interactionHits.flatMap((item) => parseMetadata(item.metadata_json).normalizedPaths ?? []))];
+    const backendHits = interactionPaths.length > 0
+        ? queryDocuments(context.database, interactionPaths.join(' '), {
             repoKind: 'fis-platform',
             sourceKinds: ['backend-endpoint'],
             limit: 6,
-        }).filter((item) => (parseMetadata(item.metadata_json).confidence ?? 0) >= 0.7)
+        }).filter((item) => {
+            const metadata = parseMetadata(item.metadata_json);
+            return (metadata.confidence ?? 0) >= 0.7
+                && interactionPaths.some((candidate) => pathsOverlap(metadata.endpointPath ?? item.title, candidate));
+        })
         : [];
     return { interactionHits, backendHits };
 }

package/dist/src/indexer/extractors/frontendContractExtractor.js

@@ -1,6 +1,6 @@
 import { CaseplatformConnector } from '../../connectors/caseplatformConnector.js';
 import { extractMatches, truncate } from '../../utils/textUtils.js';
-import { unique } from '../../utils/pathUtils.js';
+import { featureIntentTokens, pathIntentTokens, textIntentTokens, unique } from '../../utils/pathUtils.js';
 export async function extractFrontendContract(input) {
     const connector = new CaseplatformConnector(input.root);
     const files = await connector.resolveFeatureFiles(input.widgetHint);
@@ -12,11 +12,15 @@ export async function extractFrontendContract(input) {
     if (files.mode === 'widget' && !files.controlFile) {
         warnings.push(`No control file found for widget '${input.widgetHint}'.`);
     }
-    const sources = files.allFiles.map((filePath) => ({
+    const allSources = files.allFiles.map((filePath) => ({
         path: filePath,
         body: connector.read(filePath),
         kind: connector.classifyFileKind(filePath),
     }));
+    const sources = files.mode === 'conf'
+        ? focusFrontendSources(allSources, input.widgetHint)
+        : allSources;
+    const focusedFiles = sources.map((source) => source.path);
     const properties = files.mode === 'conf'
         ? unique(sources.flatMap((source) => extractConfProperties(source.body)))
         : extractMatches(controlBody, /qname:\s*'([^']+)'/g);
@@ -52,11 +56,51 @@ export async function extractFrontendContract(input) {
         events: [...new Set(events)],
         files: files.mode === 'widget'
             ? unique([files.controlFile, files.singletonFile, files.handlersFile, files.templateFile, files.dataControlFile, ...files.supportFiles].filter(Boolean))
-            : files.allFiles,
+            : focusedFiles,
         snippets,
         warnings,
     };
 }
+function focusFrontendSources(sources, widgetHint) {
+    const intentTokens = featureIntentTokens(widgetHint);
+    if (intentTokens.length === 0) {
+        return sources;
+    }
+    const scoredSources = sources.map((source) => ({
+        source,
+        pathTokens: pathIntentTokens(source.path),
+        score: scoreSourceIntent(source, intentTokens),
+    }));
+    const matchedSources = scoredSources.filter((item) => item.score > 0);
+    if (matchedSources.length === 0) {
+        return sources;
+    }
+    const viewIntentDirectories = new Set(matchedSources
+        .filter((item) => item.source.kind === 'view')
+        .flatMap((item) => directoryIntentTokens(item.source.path))
+        .filter((token) => intentTokens.includes(token)));
+    const focused = matchedSources
+        .filter((item) => {
+        if (item.source.kind !== 'view' || viewIntentDirectories.size === 0) {
+            return true;
+        }
+        return directoryIntentTokens(item.source.path).some((token) => viewIntentDirectories.has(token));
+    })
+        .map((item) => item.source);
+    return focused.length > 0 ? focused : sources;
+}
+function scoreSourceIntent(source, intentTokens) {
+    const pathTokens = pathIntentTokens(source.path);
+    const bodyTokens = new Set(textIntentTokens(source.body));
+    return intentTokens.reduce((score, token) => {
+        const pathScore = pathTokens.includes(token) ? 4 : pathTokens.some((pathToken) => pathToken.includes(token)) ? 2 : 0;
+        const bodyScore = bodyTokens.has(token) ? 1 : 0;
+        return score + pathScore + bodyScore;
+    }, 0);
+}
+function directoryIntentTokens(filePath) {
+    return pathIntentTokens(filePath.replace(/[\\/][^\\/]+$/, ''));
+}
 function extractNamedObjectKeys(source, objectName) {
     const startMatch = new RegExp(`${objectName}\\s*:\\s*\\{`).exec(source);
     if (!startMatch || startMatch.index === undefined) {

package/dist/src/indexer/refreshPipeline.d.ts

@@ -1,4 +1,10 @@
 import type { AppContext } from '../appContext.js';
+export declare const REFRESH_STATE_FILE = "refresh-state.json";
+export declare const REFRESH_STATE_TTL_MS: number;
+type RefreshState = {
+    repoSignature: string;
+    updatedAt: string;
+};
 export declare function refreshKnowledge(context: AppContext): Promise<{
     documentsIndexed: number;
     stats: {
@@ -10,3 +16,7 @@ export declare function refreshKnowledge(context: AppContext): Promise<{
     };
     warnings: string[];
 }>;
+export declare function getRefreshSignature(context: AppContext): string;
+export declare function readRefreshState(cacheDir: string): RefreshState | null;
+export declare function isRefreshStateExpired(refreshState: RefreshState): boolean;
+export {};

package/dist/src/indexer/refreshPipeline.js

@@ -7,16 +7,17 @@ import { extractApiInteractions } from './extractors/apiInteractionExtractor.js'
 import { extractBackendContracts } from './extractors/backendContractExtractor.js';
 import { extractFrontendContract } from './extractors/frontendContractExtractor.js';
 import { SnapshotStore } from './snapshotStore.js';
-import { ensureDirectory } from '../utils/fileUtils.js';
+import { ensureDirectory, readJson, writeJson } from '../utils/fileUtils.js';
+export const REFRESH_STATE_FILE = 'refresh-state.json';
+export const REFRESH_STATE_TTL_MS = 5 * 60 * 1000;
 export async function refreshKnowledge(context) {
     ensureDirectory(context.config.cacheDir);
     const snapshotStore = new SnapshotStore(path.join(context.config.cacheDir, 'snapshots'));
     const documents = [];
     const now = new Date().toISOString();
-    const repoKindsToSync = [];
+    const repoKindsToSync = ['autotests2', 'caseplatform-web', 'fis-platform'];
     const warnings = [];
     if (fs.existsSync(context.config.repos.autotests2)) {
-        repoKindsToSync.push('autotests2');
         const docs = context.autotests2.getAreaDocs();
         const apiCatalog = await buildApiDiscoveryCatalog({
             root: context.config.repos.autotests2,
@@ -106,7 +107,6 @@ export async function refreshKnowledge(context) {
         }
         warnings.push(...apiCatalog.warnings, ...apiInteractions.warnings);
         if (context.fisPlatform && context.config.repos.fisPlatform && fs.existsSync(context.config.repos.fisPlatform)) {
-            repoKindsToSync.push('fis-platform');
             const backendSources = await context.fisPlatform.listFocusedSources(apiCatalog);
             const backendContracts = extractBackendContracts({ sources: backendSources });
             snapshotStore.write('backend-contracts', backendContracts);
@@ -128,7 +128,6 @@ export async function refreshKnowledge(context) {
         warnings.push(`Skipped autotests2 refresh because '${context.config.repos.autotests2}' is unavailable.`);
     }
     if (fs.existsSync(context.config.repos.caseplatformWeb)) {
-        repoKindsToSync.push('caseplatform-web');
         const frontendContract = await extractFrontendContract({
             root: context.config.repos.caseplatformWeb,
             widgetHint: context.config.projectHints?.defaultWidget ?? 'caption',
@@ -152,9 +151,8 @@ export async function refreshKnowledge(context) {
     else {
         warnings.push(`Skipped caseplatform-web refresh because '${context.config.repos.caseplatformWeb}' is unavailable.`);
     }
-    if (repoKindsToSync.length > 0) {
-        syncDocumentsByRepoKinds(context.database, documents, repoKindsToSync);
-    }
+    syncDocumentsByRepoKinds(context.database, documents, repoKindsToSync);
+    writeRefreshState(context, now);
     const uniqueDocuments = dedupeDocuments(documents);
     const stats = {
         attemptedDocuments: documents.length,
@@ -169,6 +167,38 @@ export async function refreshKnowledge(context) {
         warnings,
     };
 }
+export function getRefreshSignature(context) {
+    return JSON.stringify({
+        autotests2: repoState(context.config.repos.autotests2),
+        caseplatformWeb: repoState(context.config.repos.caseplatformWeb),
+        fisPlatform: context.config.repos.fisPlatform ? repoState(context.config.repos.fisPlatform) : null,
+    });
+}
+export function readRefreshState(cacheDir) {
+    const filePath = path.join(cacheDir, REFRESH_STATE_FILE);
+    try {
+        return readJson(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+export function isRefreshStateExpired(refreshState) {
+    return Date.now() - Date.parse(refreshState.updatedAt) > REFRESH_STATE_TTL_MS;
+}
+function writeRefreshState(context, updatedAt) {
+    const filePath = path.join(context.config.cacheDir, REFRESH_STATE_FILE);
+    writeJson(filePath, {
+        repoSignature: getRefreshSignature(context),
+        updatedAt,
+    });
+}
+function repoState(root) {
+    return {
+        root: path.resolve(root),
+        exists: fs.existsSync(root),
+    };
+}
 function documentFrom(input) {
     return {
         id: crypto.createHash('sha1').update(`${input.sourceKind}:${input.path}`).digest('hex'),

package/dist/src/mcp/registerTools.js

@@ -11,6 +11,7 @@ import { findTestAreaContext } from '../domain/findTestAreaContext.js';
 import { generateSpecBlueprint } from '../domain/generateSpecBlueprint.js';
 import { mapFeatureToExistingCoverage } from '../domain/mapFeatureToExistingCoverage.js';
 import { recommendSelectorStrategy } from '../domain/recommendSelectorStrategy.js';
+import { reviewTestDraft } from '../domain/reviewTestDraft.js';
 import { summarizeCiContext } from '../domain/summarizeCiContext.js';
 import { triageFailedRun } from '../domain/triageFailedRun.js';
 import { toolOutputSchema } from '../contracts/toolOutput.js';
@@ -23,6 +24,17 @@ export function buildToolRegistry() {
             outputSchema: toolOutputSchema,
             execute: findExistingTestAssets,
         },
+        {
+            name: 'review_test_draft',
+            description: 'Reviews a draft test for reuse, brittle selectors, setup drift, and likely uncovered signals.',
+            inputSchema: z.object({
+                feature: z.string().min(1),
+                draft: z.string().min(1),
+                area: z.string().optional(),
+            }),
+            outputSchema: toolOutputSchema,
+            execute: reviewTestDraft,
+        },
         {
             name: 'find_backend_test_context',
             description: 'Finds autotests2 API interaction flows plus backend endpoint, validation, async-task, and error hints.',

package/dist/src/utils/pathUtils.d.ts

@@ -5,3 +5,6 @@ export declare function safeRelative(from: string, to: string): string;
 export declare function basenameWithoutExt(filePath: string): string;
 export declare function widgetNameCandidates(widgetHint: string): string[];
 export declare function featureNameCandidates(featureHint: string): string[];
+export declare function featureIntentTokens(featureHint: string): string[];
+export declare function pathIntentTokens(filePath: string): string[];
+export declare function textIntentTokens(value: string): string[];

package/dist/src/utils/pathUtils.js

@@ -57,3 +57,32 @@ export function featureNameCandidates(featureHint) {
     }
     return unique(candidates.filter(Boolean));
 }
+export function featureIntentTokens(featureHint) {
+    return unique(featureNameCandidates(featureHint)
+        .flatMap(splitIntentTokens)
+        .map((token) => token.toLowerCase())
+        .filter((token) => token.length >= 3)
+        .filter((token) => !INTENT_STOP_WORDS.has(token)));
+}
+export function pathIntentTokens(filePath) {
+    const normalized = toPosixPath(filePath).replace(/\.[A-Za-z0-9]+$/, '');
+    return unique(splitIntentTokens(normalized).map((token) => token.toLowerCase()));
+}
+export function textIntentTokens(value) {
+    return unique(splitIntentTokens(value).map((token) => token.toLowerCase()));
+}
+function splitIntentTokens(value) {
+    return value
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean);
+}
+const INTENT_STOP_WORDS = new Set([
+    'and',
+    'constructor',
+    'cypress',
+    'spec',
+    'test',
+    'tests',
+    'the',
+]);