@mknrt/autotests-overkill 1.1.0

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

@@ -0,0 +1,109 @@
+import { CaseplatformConnector } from '../../connectors/caseplatformConnector.js';
+import { extractMatches, truncate } from '../../utils/textUtils.js';
+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 warnings = [];
+    const controlBody = files.controlFile ? connector.read(files.controlFile) : '';
+    const singletonBody = files.singletonFile ? connector.read(files.singletonFile) : '';
+    const handlersBody = files.handlersFile ? connector.read(files.handlersFile) : '';
+    const supportBodies = files.supportFiles.map((filePath) => ({ path: filePath, body: connector.read(filePath) }));
+    if (files.mode === 'widget' && !files.controlFile) {
+        warnings.push(`No control file found for widget '${input.widgetHint}'.`);
+    }
+    const sources = files.allFiles.map((filePath) => ({
+        path: filePath,
+        body: connector.read(filePath),
+        kind: connector.classifyFileKind(filePath),
+    }));
+    const properties = files.mode === 'conf'
+        ? unique(sources.flatMap((source) => extractConfProperties(source.body)))
+        : extractMatches(controlBody, /qname:\s*'([^']+)'/g);
+    const events = files.mode === 'conf'
+        ? unique(sources.flatMap((source) => extractConfEvents(source.body)))
+        : extractNamedObjectKeys(controlBody, 'events');
+    const methods = files.mode === 'conf'
+        ? unique(sources.flatMap((source) => extractConfMethods(source.body)))
+        : [
+            ...extractNamedObjectKeys(controlBody, 'methods'),
+            ...extractMatches(singletonBody, /\n\s+([gs]et[A-Za-z0-9_]+)\s*\(/g),
+            ...extractMatches(singletonBody, /\n\s+(on[A-Za-z0-9_]+)\s*\(/g),
+            ...extractMatches(singletonBody, /\.([A-Za-z0-9_]+)\s*=\s*function/g),
+            ...extractMatches(handlersBody, /([a-zA-Z0-9_]+):\s*function/g),
+            ...extractMatches(handlersBody, /\.([A-Za-z0-9_]+)\s*=\s*function/g),
+        ];
+    const snippets = files.mode === 'conf'
+        ? sources.slice(0, 5).map((source) => ({
+            label: source.kind,
+            path: source.path,
+            snippet: truncate(source.body, 280),
+        }))
+        : [
+            files.controlFile ? { label: 'control', path: files.controlFile, snippet: truncate(controlBody, 280) } : null,
+            files.singletonFile ? { label: 'singleton', path: files.singletonFile, snippet: truncate(singletonBody, 280) } : null,
+            files.handlersFile ? { label: 'handlers', path: files.handlersFile, snippet: truncate(handlersBody, 280) } : null,
+            ...supportBodies.slice(0, 3).map((file) => ({ label: 'support', path: file.path, snippet: truncate(file.body, 280) })),
+        ].filter(Boolean);
+    return {
+        widgetName: input.widgetHint,
+        properties: [...new Set(properties)],
+        methods: [...new Set(methods)],
+        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,
+        snippets,
+        warnings,
+    };
+}
+function extractNamedObjectKeys(source, objectName) {
+    const startMatch = new RegExp(`${objectName}\\s*:\\s*\\{`).exec(source);
+    if (!startMatch || startMatch.index === undefined) {
+        return [];
+    }
+    const openBraceIndex = source.indexOf('{', startMatch.index);
+    let depth = 0;
+    let endIndex = -1;
+    for (let index = openBraceIndex; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === '{') {
+            depth += 1;
+        }
+        else if (char === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                endIndex = index;
+                break;
+            }
+        }
+    }
+    if (endIndex === -1) {
+        return [];
+    }
+    const block = source.slice(openBraceIndex + 1, endIndex);
+    return [...new Set(extractMatches(block, /^\s*([A-Za-z0-9_]+)\s*:\s*\{/gm))];
+}
+function extractConfProperties(source) {
+    return unique([
+        ...extractMatches(source, /dataIndex:\s*'([^']+)'/g),
+        ...extractMatches(source, /testguid\s*[:=]\s*['"]([^'"]+)['"]/g),
+        ...extractMatches(source, /title:\s*TEXT\.get\('([^']+)'/g),
+        ...extractMatches(source, /iconCls:\s*'([^']+)'/g),
+        ...extractMatches(source, /extend:\s*'([^']+)'/g),
+    ]);
+}
+function extractConfEvents(source) {
+    return unique([
+        ...extractNamedObjectKeys(source, 'listeners'),
+        ...extractMatches(source, /\.on\('([^']+)'/g),
+        ...extractMatches(source, /fireEvent\('([^']+)'/g),
+    ]);
+}
+function extractConfMethods(source) {
+    return unique([
+        ...extractMatches(source, /(?:^|\n)\s*([A-Za-z0-9_]+)\s*:\s*function\b/g),
+        ...extractMatches(source, /(?:^|\n)\s*(onFacade[A-Za-z0-9_]+)\s*:\s*function\b/g),
+        ...extractMatches(source, /(?:^|\n)\s*(onIncomingMessage[A-Za-z0-9_]+)\s*:\s*function\b/g),
+    ]);
+}

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

@@ -0,0 +1,14 @@
+export type RuntimeSignal = {
+    kind: 'method' | 'branch' | 'event' | 'constant';
+    name: string;
+    detail: string;
+    path: string;
+};
+export declare function extractFrontendRuntimeLogic(input: {
+    root: string;
+    widgetHint: string;
+}): Promise<{
+    widgetName: string;
+    runtimeSignals: RuntimeSignal[];
+    warnings: string[];
+}>;

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

@@ -0,0 +1,110 @@
+import { CaseplatformConnector } from '../../connectors/caseplatformConnector.js';
+import { scoreTextMatch, truncate } from '../../utils/textUtils.js';
+export async function extractFrontendRuntimeLogic(input) {
+    const connector = new CaseplatformConnector(input.root);
+    const files = await connector.resolveFeatureFiles(input.widgetHint);
+    const runtimeSignals = [];
+    const supportFiles = new Set(files.supportFiles);
+    const candidates = featureCandidates(input.widgetHint);
+    for (const filePath of files.allFiles) {
+        const body = connector.read(filePath);
+        const lines = body.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('if ') || trimmed.startsWith('if(') || trimmed.includes('.toggleClass(')) {
+                runtimeSignals.push({
+                    kind: 'branch',
+                    name: trimmed.slice(0, 60),
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            if (trimmed.includes('fireEventBind(')) {
+                runtimeSignals.push({
+                    kind: 'event',
+                    name: trimmed.match(/fireEventBind\('([^']+)'/)?.[1] ?? trimmed,
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            const confEventName = trimmed.match(/\.on\('([^']+)'/)?.[1]
+                ?? trimmed.match(/listeners\s*:\s*\{/)?.[0];
+            if (confEventName && (trimmed.includes(".on('") || trimmed.includes('listeners'))) {
+                runtimeSignals.push({
+                    kind: 'event',
+                    name: confEventName,
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            const methodName = trimmed.match(/^([A-Za-z0-9_]+)\s*\(/)?.[1];
+            if (methodName && ['set', 'get', 'on'].some((prefix) => methodName.startsWith(prefix))) {
+                runtimeSignals.push({
+                    kind: 'method',
+                    name: methodName,
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            const assignedMethodName = trimmed.match(/(?:[A-Za-z0-9_.]+\.)?([A-Za-z0-9_]+)\s*=\s*function\b/)?.[1];
+            if (assignedMethodName && ['set', 'get', 'on'].some((prefix) => assignedMethodName.startsWith(prefix))) {
+                runtimeSignals.push({
+                    kind: 'method',
+                    name: assignedMethodName,
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            const confMethodName = trimmed.match(/^([A-Za-z0-9_]+)\s*:\s*function\b/)?.[1];
+            if (confMethodName) {
+                runtimeSignals.push({
+                    kind: 'method',
+                    name: confMethodName,
+                    detail: truncate(trimmed, 180),
+                    path: filePath,
+                });
+            }
+            if (supportFiles.has(filePath)) {
+                const exportedFunction = trimmed.match(/^(?:export\s+)?function\s+([A-Za-z0-9_]+)/)?.[1];
+                if (exportedFunction) {
+                    runtimeSignals.push({
+                        kind: 'method',
+                        name: exportedFunction,
+                        detail: truncate(trimmed, 180),
+                        path: filePath,
+                    });
+                }
+                const exportedConstant = trimmed.match(/^(?:export\s+)?const\s+([A-Z][A-Z0-9_]+)/)?.[1];
+                if (exportedConstant) {
+                    runtimeSignals.push({
+                        kind: 'constant',
+                        name: exportedConstant,
+                        detail: truncate(trimmed, 180),
+                        path: filePath,
+                    });
+                }
+            }
+        }
+    }
+    const orderedSignals = runtimeSignals.sort((left, right) => {
+        const leftScore = candidates.reduce((score, candidate) => score + scoreTextMatch(`${left.path}\n${left.name}\n${left.detail}`, candidate), 0);
+        const rightScore = candidates.reduce((score, candidate) => score + scoreTextMatch(`${right.path}\n${right.name}\n${right.detail}`, candidate), 0);
+        return rightScore - leftScore;
+    });
+    return {
+        widgetName: input.widgetHint,
+        runtimeSignals: orderedSignals,
+        warnings: files.allFiles.length === 0 ? [`No runtime files found for '${input.widgetHint}'.`] : [],
+    };
+}
+function featureCandidates(widgetHint) {
+    const candidates = widgetHint
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .split(/[\s_\-/]+/)
+        .map((part) => part.toLowerCase())
+        .filter(Boolean);
+    if (candidates.some((candidate) => candidate.includes('error'))) {
+        candidates.push('apperror', 'validate', 'critical', 'tabpanel', 'onfacadevalidate', 'onfacadeupdateerrors');
+    }
+    return candidates;
+}

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

@@ -0,0 +1,13 @@
+export declare function extractTestAssets(input: {
+    root: string;
+    featureHint: string;
+}): Promise<{
+    specs: import("../../connectors/autotests2Connector.js").TestSpecMatch[];
+    commands: import("../../connectors/autotests2Connector.js").CommandMatch[];
+    helpers: import("../../connectors/autotests2Connector.js").HelperMatch[];
+    selectors: {
+        path: string;
+        body: string;
+    }[];
+    warnings: string[];
+}>;

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

@@ -0,0 +1,17 @@
+import { Autotests2Connector } from '../../connectors/autotests2Connector.js';
+export async function extractTestAssets(input) {
+    const connector = new Autotests2Connector(input.root);
+    const [specs, commands, helpers, selectors] = await Promise.all([
+        connector.findSpecs(input.featureHint),
+        connector.findCommands(),
+        connector.findHelpers(input.featureHint),
+        connector.findSelectors(input.featureHint),
+    ]);
+    return {
+        specs,
+        commands,
+        helpers,
+        selectors,
+        warnings: specs.length === 0 ? [`No specs matched '${input.featureHint}'.`] : [],
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { AppContext } from '../appContext.js';
+export declare function refreshKnowledge(context: AppContext): Promise<{
+    documentsIndexed: number;
+    stats: {
+        attemptedDocuments: number;
+        uniqueDocuments: number;
+        autotestsDocuments: number;
+        caseplatformDocuments: number;
+        bySourceKind: Record<string, number>;
+    };
+    warnings: string[];
+}>;

package/dist/src/indexer/refreshPipeline.js

@@ -0,0 +1,156 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { syncDocumentsByRepoKinds } from '../knowledge/repositories.js';
+import { extractFrontendContract } from './extractors/frontendContractExtractor.js';
+import { SnapshotStore } from './snapshotStore.js';
+import { ensureDirectory } from '../utils/fileUtils.js';
+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 warnings = [];
+    if (fs.existsSync(context.config.repos.autotests2)) {
+        repoKindsToSync.push('autotests2');
+        const docs = context.autotests2.getAreaDocs();
+        const testAssets = {
+            specs: await context.autotests2.findSpecs(),
+            commands: await context.autotests2.findCommands(),
+            helpers: await context.autotests2.findHelpers(),
+            selectors: await context.autotests2.findSelectors(),
+            warnings: [],
+        };
+        snapshotStore.write('test-assets', testAssets);
+        for (const spec of testAssets.specs) {
+            documents.push(documentFrom({
+                sourceKind: 'spec',
+                repoKind: 'autotests2',
+                path: spec.path,
+                title: spec.title,
+                body: spec.body,
+                metadata: { score: spec.score },
+                updatedAt: now,
+            }));
+        }
+        for (const command of testAssets.commands) {
+            documents.push(documentFrom({
+                sourceKind: 'command',
+                repoKind: 'autotests2',
+                path: command.path,
+                title: command.name,
+                body: command.body,
+                metadata: {},
+                updatedAt: now,
+            }));
+        }
+        for (const helper of testAssets.helpers) {
+            documents.push(documentFrom({
+                sourceKind: 'helper',
+                repoKind: 'autotests2',
+                path: helper.path,
+                title: helper.name,
+                body: helper.body,
+                metadata: {},
+                updatedAt: now,
+            }));
+        }
+        for (const selector of testAssets.selectors) {
+            documents.push(documentFrom({
+                sourceKind: 'selector',
+                repoKind: 'autotests2',
+                path: selector.path,
+                title: path.basename(selector.path),
+                body: selector.body,
+                metadata: {},
+                updatedAt: now,
+            }));
+        }
+        for (const docEntry of [
+            { sourceKind: 'doc', path: docs.contextPath, title: 'context.md', body: docs.contextText, metadata: { kind: 'context' } },
+            { sourceKind: 'doc', path: docs.testingPath, title: 'testing.md', body: docs.testingText, metadata: { kind: 'testing' } },
+        ]) {
+            if (docEntry.body) {
+                documents.push(documentFrom({
+                    sourceKind: docEntry.sourceKind,
+                    repoKind: 'autotests2',
+                    path: docEntry.path,
+                    title: docEntry.title,
+                    body: docEntry.body,
+                    metadata: docEntry.metadata,
+                    updatedAt: now,
+                }));
+            }
+        }
+    }
+    else {
+        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',
+        });
+        snapshotStore.write('frontend-contract', frontendContract);
+        const caseplatformSources = await context.caseplatform.listIndexableSources();
+        snapshotStore.write('caseplatform-index-summary', buildSourceKindSummary(caseplatformSources.map((source) => source.sourceKind)));
+        for (const source of caseplatformSources) {
+            documents.push(documentFrom({
+                sourceKind: source.sourceKind,
+                repoKind: 'caseplatform-web',
+                path: source.path,
+                title: source.title,
+                body: source.body,
+                metadata: source.metadata,
+                updatedAt: now,
+            }));
+        }
+        warnings.push(...frontendContract.warnings);
+    }
+    else {
+        warnings.push(`Skipped caseplatform-web refresh because '${context.config.repos.caseplatformWeb}' is unavailable.`);
+    }
+    if (repoKindsToSync.length > 0) {
+        syncDocumentsByRepoKinds(context.database, documents, repoKindsToSync);
+    }
+    const uniqueDocuments = dedupeDocuments(documents);
+    const stats = {
+        attemptedDocuments: documents.length,
+        uniqueDocuments: uniqueDocuments.length,
+        autotestsDocuments: uniqueDocuments.filter((record) => record.repoKind === 'autotests2').length,
+        caseplatformDocuments: uniqueDocuments.filter((record) => record.repoKind === 'caseplatform-web').length,
+        bySourceKind: buildSourceKindSummary(uniqueDocuments.map((record) => record.sourceKind)),
+    };
+    return {
+        documentsIndexed: documents.length,
+        stats,
+        warnings,
+    };
+}
+function documentFrom(input) {
+    return {
+        id: crypto.createHash('sha1').update(`${input.sourceKind}:${input.path}`).digest('hex'),
+        sourceKind: input.sourceKind,
+        repoKind: input.repoKind,
+        path: input.path,
+        title: input.title,
+        body: input.body,
+        metadataJson: JSON.stringify(input.metadata),
+        updatedAt: input.updatedAt,
+    };
+}
+function dedupeDocuments(documents) {
+    const seen = new Map();
+    for (const document of documents) {
+        seen.set(document.id, document);
+    }
+    return [...seen.values()];
+}
+function buildSourceKindSummary(sourceKinds) {
+    return sourceKinds.reduce((summary, sourceKind) => {
+        summary[sourceKind] = (summary[sourceKind] ?? 0) + 1;
+        return summary;
+    }, {});
+}

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

@@ -0,0 +1,10 @@
+export declare class SnapshotStore {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    private snapshotPath;
+    read<T>(key: string): T | null;
+    write(key: string, value: unknown): {
+        changed: boolean;
+        hash: string;
+    };
+}

package/dist/src/indexer/snapshotStore.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { ensureDirectory, readJson, writeJson } from '../utils/fileUtils.js';
+export class SnapshotStore {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        ensureDirectory(this.rootDir);
+    }
+    snapshotPath(key) {
+        return path.join(this.rootDir, `${key}.json`);
+    }
+    read(key) {
+        const filePath = this.snapshotPath(key);
+        try {
+            return readJson(filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    write(key, value) {
+        const filePath = this.snapshotPath(key);
+        const serialized = JSON.stringify(value, null, 2);
+        const hash = crypto.createHash('sha1').update(serialized).digest('hex');
+        const manifest = this.read('manifest') ?? {};
+        const previous = manifest[key];
+        if (previous?.hash === hash) {
+            return {
+                changed: false,
+                hash,
+            };
+        }
+        writeJson(filePath, value);
+        manifest[key] = {
+            hash,
+            updatedAt: new Date().toISOString(),
+        };
+        writeJson(this.snapshotPath('manifest'), manifest);
+        return {
+            changed: true,
+            hash,
+        };
+    }
+}

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

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

package/dist/src/knowledge/database.js

@@ -0,0 +1,8 @@
+import Database from 'better-sqlite3';
+import { baseMigrations } from './migrations.js';
+export function createKnowledgeDatabase(filePath) {
+    const db = new Database(filePath);
+    db.pragma('journal_mode = WAL');
+    db.exec(baseMigrations);
+    return db;
+}

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

@@ -0,0 +1 @@
+export declare const baseMigrations = "\nCREATE TABLE IF NOT EXISTS documents (\n  id TEXT PRIMARY KEY,\n  source_kind TEXT NOT NULL,\n  repo_kind TEXT NOT NULL,\n  path TEXT NOT NULL,\n  title TEXT NOT NULL,\n  body TEXT NOT NULL,\n  metadata_json TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE VIRTUAL TABLE IF NOT EXISTS documents_fts USING fts5(\n  id UNINDEXED,\n  path,\n  title,\n  body,\n  tokenize = 'porter unicode61'\n);\n\nCREATE TABLE IF NOT EXISTS indexing_runs (\n  run_id TEXT PRIMARY KEY,\n  source_kind TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  metadata_json TEXT NOT NULL\n);\n";

package/dist/src/knowledge/migrations.js

@@ -0,0 +1,28 @@
+export const baseMigrations = `
+CREATE TABLE IF NOT EXISTS documents (
+  id TEXT PRIMARY KEY,
+  source_kind TEXT NOT NULL,
+  repo_kind TEXT NOT NULL,
+  path TEXT NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  metadata_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS documents_fts USING fts5(
+  id UNINDEXED,
+  path,
+  title,
+  body,
+  tokenize = 'porter unicode61'
+);
+
+CREATE TABLE IF NOT EXISTS indexing_runs (
+  run_id TEXT PRIMARY KEY,
+  source_kind TEXT NOT NULL,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL
+);
+`;

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

@@ -0,0 +1,28 @@
+import type { KnowledgeDatabase } from './database.js';
+export type KnowledgeDocument = {
+    id: string;
+    sourceKind: string;
+    repoKind: string;
+    path: string;
+    title: string;
+    body: string;
+    metadataJson: string;
+    updatedAt: string;
+};
+export declare function upsertDocuments(db: KnowledgeDatabase, documents: KnowledgeDocument[]): void;
+export declare function syncDocumentsByRepoKinds(db: KnowledgeDatabase, documents: KnowledgeDocument[], repoKinds: string[]): void;
+export declare function countDocuments(db: KnowledgeDatabase): number;
+type QueryOptions = {
+    limit?: number;
+    sourceKinds?: string[];
+    repoKind?: string;
+};
+export declare function queryDocuments(db: KnowledgeDatabase, query: string, options?: QueryOptions): Array<{
+    id: string;
+    path: string;
+    title: string;
+    body: string;
+    metadata_json: string;
+    rank: number;
+}>;
+export {};

package/dist/src/knowledge/repositories.js

@@ -0,0 +1,78 @@
+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)
+    ON CONFLICT(id) DO UPDATE SET
+      source_kind = excluded.source_kind,
+      repo_kind = excluded.repo_kind,
+      path = excluded.path,
+      title = excluded.title,
+      body = excluded.body,
+      metadata_json = excluded.metadata_json,
+      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);
+            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);
+                }
+            }
+        }
+    });
+    transaction();
+}
+export function countDocuments(db) {
+    const row = db.prepare('SELECT COUNT(*) AS count FROM documents').get();
+    return row.count;
+}
+export function queryDocuments(db, query, options = {}) {
+    const clauses = ['documents_fts MATCH ?'];
+    const params = [normalizeFtsQuery(query)];
+    if (options.sourceKinds?.length) {
+        clauses.push(`d.source_kind IN (${options.sourceKinds.map(() => '?').join(', ')})`);
+        params.push(...options.sourceKinds);
+    }
+    if (options.repoKind) {
+        clauses.push('d.repo_kind = ?');
+        params.push(options.repoKind);
+    }
+    params.push(options.limit ?? 25);
+    const statement = db.prepare(`
+    SELECT d.id, d.path, d.title, d.body, d.metadata_json, bm25(documents_fts) AS rank
+    FROM documents_fts
+    JOIN documents d ON d.id = documents_fts.id
+    WHERE ${clauses.join(' AND ')}
+    ORDER BY rank
+    LIMIT ?
+  `);
+    return statement.all(...params);
+}
+function normalizeFtsQuery(query) {
+    return query
+        .split(/[\s/\\_\-.]+/)
+        .map((token) => token.trim())
+        .filter(Boolean)
+        .map((token) => `"${token.replaceAll('"', '""')}"`)
+        .join(' OR ');
+}

package/dist/src/mcp/registerTools.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { AppContext } from '../appContext.js';
+import { toolOutputSchema } from '../contracts/toolOutput.js';
+export type ToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: z.ZodTypeAny;
+    outputSchema: typeof toolOutputSchema;
+    execute: (input: any, context: AppContext) => Promise<any>;
+};
+export declare function buildToolRegistry(): ToolDefinition[];