@mknrt/autotests-overkill 1.1.4 → 1.1.5

package/dist/src/domain/findBackendTestContext.js

@@ -2,11 +2,15 @@ import { queryDocuments } from '../knowledge/repositories.js';
 import { ensureIndexed, evidenceFile, output } from './shared.js';
 export async function findBackendTestContext(input, context) {
     await ensureIndexed(context);
+    const queryTokens = normalizeTokens(input.query);
+    const queryPaths = extractQueryPaths(input.query);
     const interactionHits = highConfidence(queryDocuments(context.database, input.query, {
         repoKind: 'autotests2',
         sourceKinds: ['api-interaction'],
         limit: 6,
-    }));
+    }))
+        .filter((item) => isRelevantInteraction(item, queryTokens, queryPaths))
+        .slice(0, 3);
     const interactionBridgeQuery = interactionHits
         .flatMap((item) => {
         const metadata = parseMetadata(item.metadata_json);
@@ -21,20 +25,23 @@ export async function findBackendTestContext(input, context) {
         repoKind: 'fis-platform',
         sourceKinds: ['backend-endpoint'],
         limit: 8,
-    }));
-    const linkedAutotestQuery = [...interactionHits, ...backendHits]
-        .flatMap((item) => {
-        const metadata = parseMetadata(item.metadata_json);
-        return [...(metadata.consumerSignalIds ?? []), ...(metadata.evidencePaths ?? [])];
-    })
-        .join(' ');
-    const linkedAssets = linkedAutotestQuery
-        ? queryDocuments(context.database, linkedAutotestQuery, {
-            repoKind: 'autotests2',
-            sourceKinds: ['spec', 'command', 'helper'],
-            limit: 8,
-        })
-        : [];
+    }))
+        .filter((item) => isRelevantBackendEndpoint(item, interactionHits, queryTokens, queryPaths))
+        .slice(0, 6);
+    const evidencePaths = [...interactionHits, ...backendHits]
+        .flatMap((item) => parseMetadata(item.metadata_json).evidencePaths ?? []);
+    const exactLinkedAssets = findDocumentsByPaths(context, evidencePaths);
+    const linkedSpecQuery = [
+        input.query,
+        ...interactionHits.map((item) => item.title),
+        ...interactionHits.flatMap((item) => parseMetadata(item.metadata_json).normalizedPaths ?? []),
+    ].join(' ');
+    const linkedSpecAssets = queryDocuments(context.database, linkedSpecQuery, {
+        repoKind: 'autotests2',
+        sourceKinds: ['spec', 'command', 'helper'],
+        limit: 8,
+    }).filter((item) => isRelevantLinkedAsset(item, queryTokens));
+    const linkedAssets = uniqueDocumentHits([...exactLinkedAssets, ...linkedSpecAssets]).slice(0, 8);
     const evidence = [
         ...interactionHits.map((item) => evidenceFile('api interaction', item.path, truncate(item.body, 260), {
             retrieval: 'knowledge-store',
@@ -67,6 +74,84 @@ export async function findBackendTestContext(input, context) {
 function highConfidence(items) {
     return items.filter((item) => (parseMetadata(item.metadata_json).confidence ?? 0) >= 0.7);
 }
+function findDocumentsByPaths(context, paths) {
+    const uniquePaths = [...new Set(paths)];
+    if (uniquePaths.length === 0) {
+        return [];
+    }
+    const statement = context.database.prepare(`
+    SELECT id, path, title, body, metadata_json, 0 AS rank
+    FROM documents
+    WHERE repo_kind = 'autotests2'
+      AND source_kind IN ('spec', 'command', 'helper')
+      AND path = ?
+  `);
+    return uniquePaths.flatMap((filePath) => statement.all(filePath));
+}
+function uniqueDocumentHits(items) {
+    const seen = new Map();
+    for (const item of items) {
+        seen.set(item.id, item);
+    }
+    return [...seen.values()];
+}
+function isRelevantLinkedAsset(item, queryTokens) {
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body.slice(0, 1200)}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function isRelevantInteraction(item, queryTokens, queryPaths) {
+    const metadata = parseMetadata(item.metadata_json);
+    const normalizedPaths = metadata.normalizedPaths ?? [];
+    if (queryPaths.length > 0) {
+        return normalizedPaths.some((indexedPath) => queryPaths.some((queryPath) => pathsOverlap(indexedPath, queryPath)));
+    }
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body} ${normalizedPaths.join(' ')}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function isRelevantBackendEndpoint(item, interactions, queryTokens, queryPaths) {
+    const metadata = parseMetadata(item.metadata_json);
+    const endpointPath = metadata.endpointPath ?? item.title;
+    const interactionPaths = interactions.flatMap((interaction) => parseMetadata(interaction.metadata_json).normalizedPaths ?? []);
+    const endpointTokens = normalizeTokens(endpointPath);
+    if (queryPaths.length > 0 || interactionPaths.length > 0) {
+        return queryPaths.some((candidate) => pathsOverlap(endpointPath, candidate))
+            || queryTokens.some((token) => endpointTokens.includes(token))
+            || (queryPaths.length === 0 && interactionPaths.some((candidate) => pathsOverlap(endpointPath, candidate)));
+    }
+    const searchable = normalizeTokens(`${item.title} ${item.path} ${item.body} ${endpointPath}`);
+    return queryTokens.some((token) => searchable.includes(token));
+}
+function extractQueryPaths(query) {
+    return [...query.matchAll(/(?:https?:\/\/[^/\s]+)?(\/[A-Za-z0-9_/${}?.=&*-]+)+/g)]
+        .map((match) => match[0])
+        .map((value) => normalizePath(value))
+        .filter((value) => normalizeTokens(value).length >= 2)
+        .filter(Boolean);
+}
+function pathsOverlap(left, right) {
+    const leftTokens = normalizeTokens(normalizePath(left));
+    const rightTokens = normalizeTokens(normalizePath(right));
+    const sharedTokens = leftTokens.filter((token) => rightTokens.includes(token));
+    return normalizePath(left).includes(normalizePath(right))
+        || normalizePath(right).includes(normalizePath(left))
+        || (leftTokens.length > 0 && rightTokens.length > 0 && sharedTokens.length >= Math.min(2, rightTokens.length));
+}
+function normalizePath(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.pathname;
+    }
+    catch {
+        return (value.split('?')[0] ?? value).replace(/^\$\{[^}]+\}/, '');
+    }
+}
+function normalizeTokens(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 1 && !/^(platform|rs2|api|rest|sec)$/.test(token));
+}
 function parseMetadata(metadataJson) {
     try {
         return JSON.parse(metadataJson);

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

@@ -4,6 +4,7 @@ import { unique } from '../../utils/pathUtils.js';
 export async function extractFrontendContract(input) {
     const connector = new CaseplatformConnector(input.root);
     const files = await connector.resolveFeatureFiles(input.widgetHint);
+    const focusedFiles = focusFrontendFiles(files.allFiles, input.widgetHint);
     const warnings = [];
     const controlBody = files.controlFile ? connector.read(files.controlFile) : '';
     const singletonBody = files.singletonFile ? connector.read(files.singletonFile) : '';
@@ -12,7 +13,7 @@ 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 sources = focusedFiles.map((filePath) => ({
         path: filePath,
         body: connector.read(filePath),
         kind: connector.classifyFileKind(filePath),
@@ -52,11 +53,18 @@ 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 focusFrontendFiles(filePaths, widgetHint) {
+    if (!/auth|login/i.test(widgetHint)) {
+        return filePaths;
+    }
+    const focused = filePaths.filter((filePath) => /(?:^|[\\/])auth(?:[\\/]|$)|Auth|login/i.test(filePath));
+    return focused.length > 0 ? focused : filePaths;
+}
 function extractNamedObjectKeys(source, objectName) {
     const startMatch = new RegExp(`${objectName}\\s*:\\s*\\{`).exec(source);
     if (!startMatch || startMatch.index === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mknrt/autotests-overkill",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "private": false,
   "type": "module",
   "description": "AI-assisted testing intelligence platform for autotests2, caseplatform-web, and CI artifacts",