@mknrt/autotests-overkill 1.1.5 → 1.2.1

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/backendContractExtractor.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 export function extractBackendContracts(input) {
     const documents = input.sources.flatMap((source) => extractRecordsFromSource(source));
     return {
@@ -26,7 +27,14 @@ function createRecord(source, httpMethod, endpointPath, body) {
     ].filter((value) => Boolean(value));
     const ruleHints = extractRuleHints(body);
     return {
-        id: `fis-platform:${source.matchedFamily}:${httpMethod ?? 'RESOURCE'}:${source.path}:${resolvedEndpointPath}`,
+        id: [
+            'fis-platform',
+            source.matchedFamily,
+            httpMethod ?? 'RESOURCE',
+            source.path,
+            resolvedEndpointPath,
+            crypto.createHash('sha1').update(body).digest('hex').slice(0, 12),
+        ].join(':'),
         title: `${httpMethod ? `${httpMethod} ` : ''}${resolvedEndpointPath}`,
         path: source.path,
         body,

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

@@ -1,10 +1,9 @@
 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);
-    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) : '';
@@ -13,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 = focusedFiles.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);
@@ -58,12 +61,45 @@ export async function extractFrontendContract(input) {
         warnings,
     };
 }
-function focusFrontendFiles(filePaths, widgetHint) {
-    if (!/auth|login/i.test(widgetHint)) {
-        return filePaths;
+function focusFrontendSources(sources, widgetHint) {
+    const intentTokens = featureIntentTokens(widgetHint);
+    if (intentTokens.length === 0) {
+        return sources;
     }
-    const focused = filePaths.filter((filePath) => /(?:^|[\\/])auth(?:[\\/]|$)|Auth|login/i.test(filePath));
-    return focused.length > 0 ? focused : filePaths;
+    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);

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,
@@ -95,6 +96,7 @@ export async function refreshKnowledge(context) {
         }
         for (const record of apiInteractions.documents) {
             documents.push(documentFrom({
+                id: record.id,
                 sourceKind: record.sourceKind,
                 repoKind: record.repoKind,
                 path: record.path,
@@ -106,12 +108,12 @@ 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);
             for (const record of backendContracts.documents) {
                 documents.push(documentFrom({
+                    id: record.id,
                     sourceKind: record.sourceKind,
                     repoKind: record.repoKind,
                     path: record.path,
@@ -128,7 +130,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 +153,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,9 +169,46 @@ 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'),
+        id: input.id ?? crypto.createHash('sha1').update([
+            input.repoKind,
+            input.sourceKind,
+            input.path,
+            input.title,
+        ].join(':')).digest('hex'),
         sourceKind: input.sourceKind,
         repoKind: input.repoKind,
         path: input.path,

package/dist/src/knowledge/database.d.ts

@@ -1,3 +1,3 @@
-import Database from 'better-sqlite3';
-export type KnowledgeDatabase = Database.Database;
+import { DatabaseSync } from 'node:sqlite';
+export type KnowledgeDatabase = DatabaseSync;
 export declare function createKnowledgeDatabase(filePath: string): KnowledgeDatabase;

package/dist/src/knowledge/database.js

@@ -1,8 +1,15 @@
-import Database from 'better-sqlite3';
+import { DatabaseSync } from 'node:sqlite';
 import { baseMigrations } from './migrations.js';
 export function createKnowledgeDatabase(filePath) {
-    const db = new Database(filePath);
-    db.pragma('journal_mode = WAL');
+    const db = new DatabaseSync(filePath);
+    // This database is a rebuildable cache, so we optimize for fast refreshes over crash durability.
+    db.exec(`
+    PRAGMA journal_mode = MEMORY;
+    PRAGMA synchronous = OFF;
+    PRAGMA temp_store = MEMORY;
+    PRAGMA cache_size = -20000;
+    PRAGMA busy_timeout = 5000;
+  `);
     db.exec(baseMigrations);
     return db;
 }

package/dist/src/knowledge/repositories.js

@@ -1,7 +1,11 @@
+const INSERT_DOCUMENT_SQL = `
+  INSERT INTO documents (id, source_kind, repo_kind, path, title, body, metadata_json, updated_at)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+`;
+const INSERT_FTS_SQL = 'INSERT INTO documents_fts (id, path, title, body) VALUES (?, ?, ?, ?)';
 export function upsertDocuments(db, documents) {
     const upsertDocument = db.prepare(`
-    INSERT INTO documents (id, source_kind, repo_kind, path, title, body, metadata_json, updated_at)
-    VALUES (@id, @sourceKind, @repoKind, @path, @title, @body, @metadataJson, @updatedAt)
+    ${INSERT_DOCUMENT_SQL}
     ON CONFLICT(id) DO UPDATE SET
       source_kind = excluded.source_kind,
       repo_kind = excluded.repo_kind,
@@ -12,35 +16,32 @@ export function upsertDocuments(db, documents) {
       updated_at = excluded.updated_at
   `);
     const deleteFts = db.prepare('DELETE FROM documents_fts WHERE id = ?');
-    const insertFts = db.prepare('INSERT INTO documents_fts (id, path, title, body) VALUES (?, ?, ?, ?)');
-    const transaction = db.transaction((records) => {
-        for (const record of records) {
-            upsertDocument.run(record);
+    const insertFts = db.prepare(INSERT_FTS_SQL);
+    runInTransaction(db, () => {
+        for (const record of documents) {
+            upsertDocument.run(record.id, record.sourceKind, record.repoKind, record.path, record.title, record.body, record.metadataJson, record.updatedAt);
             deleteFts.run(record.id);
             insertFts.run(record.id, record.path, record.title, record.body);
         }
     });
-    transaction(documents);
 }
 export function syncDocumentsByRepoKinds(db, documents, repoKinds) {
-    upsertDocuments(db, documents);
     const normalizedRepoKinds = [...new Set(repoKinds)];
-    const selectIds = db.prepare('SELECT id FROM documents WHERE repo_kind = ?');
-    const deleteDocument = db.prepare('DELETE FROM documents WHERE id = ?');
-    const deleteFts = db.prepare('DELETE FROM documents_fts WHERE id = ?');
-    const transaction = db.transaction(() => {
-        for (const repoKind of normalizedRepoKinds) {
-            const desiredIds = new Set(documents.filter((record) => record.repoKind === repoKind).map((record) => record.id));
-            const existingIds = selectIds.all(repoKind);
-            for (const row of existingIds) {
-                if (!desiredIds.has(row.id)) {
-                    deleteDocument.run(row.id);
-                    deleteFts.run(row.id);
-                }
-            }
+    const insertDocument = db.prepare(INSERT_DOCUMENT_SQL);
+    const insertFts = db.prepare(INSERT_FTS_SQL);
+    runInTransaction(db, () => {
+        if (normalizedRepoKinds.length > 0) {
+            const placeholders = normalizedRepoKinds.map(() => '?').join(', ');
+            db.prepare(`DELETE FROM documents_fts WHERE id IN (SELECT id FROM documents WHERE repo_kind IN (${placeholders}))`)
+                .run(...normalizedRepoKinds);
+            db.prepare(`DELETE FROM documents WHERE repo_kind IN (${placeholders})`)
+                .run(...normalizedRepoKinds);
+        }
+        for (const record of documents) {
+            insertDocument.run(record.id, record.sourceKind, record.repoKind, record.path, record.title, record.body, record.metadataJson, record.updatedAt);
+            insertFts.run(record.id, record.path, record.title, record.body);
         }
     });
-    transaction();
 }
 export function countDocuments(db) {
     const row = db.prepare('SELECT COUNT(*) AS count FROM documents').get();
@@ -76,3 +77,14 @@ function normalizeFtsQuery(query) {
         .map((token) => `"${token.replaceAll('"', '""')}"`)
         .join(' OR ');
 }
+function runInTransaction(db, operation) {
+    db.exec('BEGIN');
+    try {
+        operation();
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}