@oneentry/mcp-platform-server 0.1.0 → 0.1.3

package/dist/index.js

@@ -1,7 +1,3 @@
-/**
- * Публичный API пакета: всё, что нужно, чтобы встроить сервер в свой процесс
- * или собрать его иначе, чем это делает CLI.
- */
 export { loadConfig, parseFlags, normalizeBaseUrl, ConfigSchema } from './config/config.js';
 export { createServer, createSharedDeps } from './server.js';
 export { Session } from './session.js';
@@ -12,7 +8,10 @@ export { shapeResponse } from './api/shape.js';
 export { AuditLog } from './api/audit.js';
 export { TokenStore, AuthError } from './api/auth.js';
 export { KnowledgeIndex } from './knowledge/search.js';
-export { buildPack, loadSnapshot, resolveKnowledge } from './knowledge/loader.js';
+export { packFromFiles, resolveKnowledge, seedPack } from './knowledge/loader.js';
+export { fetchKnowledgeTree, readLocalTree } from './knowledge/github.js';
+export { readTar, readTarGz } from './knowledge/tar.js';
+export { buildCatalog } from './api/build-catalog.js';
+export { fetchSwagger } from './api/swagger-source.js';
 export { runStdio } from './transports/stdio.js';
 export { runHttp } from './transports/http.js';
-//# sourceMappingURL=index.js.map

package/dist/knowledge/chunk.d.ts

@@ -1,27 +1,13 @@
 import type { KnowledgeChunk, KnowledgeDoc } from './types.js';
-/**
- * Слаг заголовка в стиле GitHub: нижний регистр, пробелы в дефисы,
- * пунктуация выброшена. Кириллица сохраняется — документация в проекте русскоязычная.
- */
 export declare const slugify: (heading: string) => string;
 interface Section {
     title: string;
     lines: string[];
 }
-/**
- * Режет markdown по заголовкам `##` и `###`.
- * Преамбула до первого `##` становится разделом с пустым anchor — в ней обычно
- * лежит самое важное описание модуля, терять его нельзя.
- */
 export declare const splitSections: (markdown: string) => {
     docTitle: string;
     sections: Section[];
 };
-/**
- * Превращает один markdown-файл в документ + его разделы.
- * Anchor'ы дедуплицируются суффиксом, иначе два одинаковых `## Схема`
- * в одном файле стали бы неразличимы для cms_docs_read.
- */
 export declare const chunkDocument: (params: {
     docId: string;
     repo: KnowledgeChunk["repo"];
@@ -32,4 +18,3 @@ export declare const chunkDocument: (params: {
     chunks: KnowledgeChunk[];
 };
 export {};
-//# sourceMappingURL=chunk.d.ts.map

package/dist/knowledge/chunk.js

@@ -1,20 +1,10 @@
-/**
- * Слаг заголовка в стиле GitHub: нижний регистр, пробелы в дефисы,
- * пунктуация выброшена. Кириллица сохраняется — документация в проекте русскоязычная.
- */
 export const slugify = (heading) => heading
     .toLowerCase()
     .replace(/`|\*|_|\[|\]|\(|\)|:|,|\.|\/|\\|«|»|"|'|\?|!|;/g, '')
     .trim()
     .replace(/\s+/g, '-')
     .slice(0, 80);
-/** Строки внутри огороженных блоков кода не считаются заголовками. */
 const isFence = (line) => line.startsWith('```') || line.startsWith('~~~');
-/**
- * Режет markdown по заголовкам `##` и `###`.
- * Преамбула до первого `##` становится разделом с пустым anchor — в ней обычно
- * лежит самое важное описание модуля, терять его нельзя.
- */
 export const splitSections = (markdown) => {
     const lines = markdown.split('\n');
     let docTitle = '';
@@ -43,11 +33,6 @@ export const splitSections = (markdown) => {
         sections: sections.filter((s) => s.title !== '' || s.lines.join('').trim() !== ''),
     };
 };
-/**
- * Превращает один markdown-файл в документ + его разделы.
- * Anchor'ы дедуплицируются суффиксом, иначе два одинаковых `## Схема`
- * в одном файле стали бы неразличимы для cms_docs_read.
- */
 export const chunkDocument = (params) => {
     const { docTitle, sections } = splitSections(params.markdown);
     const seen = new Map();
@@ -84,4 +69,3 @@ export const chunkDocument = (params) => {
         chunks,
     };
 };
-//# sourceMappingURL=chunk.js.map

package/dist/knowledge/github.d.ts

@@ -0,0 +1,21 @@
+export interface KnowledgeSource {
+    repo: string;
+    ref: string;
+    cacheDir: string;
+    refreshTtlMs: number;
+    offline: boolean;
+    token?: string;
+    timeoutMs: number;
+}
+export interface KnowledgeFile {
+    path: string;
+    content: string;
+}
+export interface KnowledgeTree {
+    files: KnowledgeFile[];
+    sha: string;
+    source: 'github' | 'cache';
+}
+export declare const walkMarkdown: (root: string) => string[];
+export declare const fetchKnowledgeTree: (source: KnowledgeSource) => Promise<KnowledgeTree>;
+export declare const readLocalTree: (path: string) => KnowledgeFile[];

package/dist/knowledge/github.js

@@ -0,0 +1,174 @@
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { readTarGz } from './tar.js';
+const ROOT = 'knowledge';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const repoCacheDir = (source) => resolve(source.cacheDir, source.repo.replace('/', '--'));
+const stateFile = (source) => join(repoCacheDir(source), 'current.json');
+const readState = (source) => {
+    try {
+        const parsed = JSON.parse(readFileSync(stateFile(source), 'utf8'));
+        if (!isRecord(parsed) ||
+            typeof parsed['sha'] !== 'string' ||
+            typeof parsed['ref'] !== 'string' ||
+            typeof parsed['checkedAt'] !== 'number') {
+            return undefined;
+        }
+        return { ref: parsed['ref'], sha: parsed['sha'], checkedAt: parsed['checkedAt'] };
+    }
+    catch {
+        return undefined;
+    }
+};
+const writeState = (source, state) => {
+    mkdirSync(repoCacheDir(source), { recursive: true });
+    writeFileSync(stateFile(source), `${JSON.stringify(state)}\n`);
+};
+export const walkMarkdown = (root) => {
+    const out = [];
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(full);
+            }
+        }
+    };
+    visit(root);
+    return out.sort();
+};
+const exists = (path) => {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const readCached = (source, sha) => {
+    const dir = join(repoCacheDir(source), sha, ROOT);
+    if (!exists(dir)) {
+        return undefined;
+    }
+    return walkMarkdown(dir).map((file) => ({
+        path: relative(dir, file).split(sep).join('/'),
+        content: readFileSync(file, 'utf8'),
+    }));
+};
+const writeCache = (source, sha, files) => {
+    const base = repoCacheDir(source);
+    const target = join(base, sha, ROOT);
+    for (const file of files) {
+        const full = join(target, file.path);
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, file.content);
+    }
+    for (const entry of readdirSync(base, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name !== sha) {
+            rmSync(join(base, entry.name), { recursive: true, force: true });
+        }
+    }
+};
+const headers = (source, accept) => ({
+    accept,
+    'user-agent': 'oneentry-mcp-platform',
+    ...(source.token ? { authorization: `Bearer ${source.token}` } : {}),
+});
+const shaFailureHint = (status) => {
+    switch (status) {
+        case 403: {
+            return ' (rate limit — set ONEENTRY_GITHUB_TOKEN)';
+        }
+        case 404: {
+            return ' (no such repository or ref — check ONEENTRY_MCP_KNOWLEDGE_REPO, and set ONEENTRY_GITHUB_TOKEN if it is private)';
+        }
+        case 409: {
+            return ' (the repository is empty — it has no commits yet)';
+        }
+        default: {
+            return '';
+        }
+    }
+};
+const resolveSha = async (source) => {
+    const url = `https://api.github.com/repos/${source.repo}/commits/${encodeURIComponent(source.ref)}`;
+    const response = await fetch(url, {
+        headers: headers(source, 'application/vnd.github.sha'),
+        signal: AbortSignal.timeout(source.timeoutMs),
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub answered ${String(response.status)} for ${source.repo}@${source.ref}` +
+            shaFailureHint(response.status));
+    }
+    const sha = (await response.text()).trim();
+    if (!/^[0-9a-f]{7,40}$/.test(sha)) {
+        throw new Error(`GitHub returned an unexpected commit id for ${source.repo}@${source.ref}`);
+    }
+    return sha;
+};
+const selectDocs = (entries) => {
+    const prefix = `${ROOT}/`;
+    return entries
+        .filter((entry) => entry.path.startsWith(prefix) &&
+        entry.path.endsWith('.md') &&
+        !entry.path.split('/').includes('..'))
+        .map((entry) => ({ path: entry.path.slice(prefix.length), content: entry.content }));
+};
+const download = async (source, sha) => {
+    const url = `https://codeload.github.com/${source.repo}/tar.gz/${sha}`;
+    const response = await fetch(url, {
+        headers: headers(source, 'application/octet-stream'),
+        signal: AbortSignal.timeout(source.timeoutMs),
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub answered ${String(response.status)} for the ${source.repo} archive`);
+    }
+    const files = selectDocs(readTarGz(Buffer.from(await response.arrayBuffer())));
+    if (files.length === 0) {
+        throw new Error(`${source.repo}@${sha} has no ${ROOT}/**/*.md — wrong repository or layout?`);
+    }
+    return files;
+};
+export const fetchKnowledgeTree = async (source) => {
+    const state = readState(source);
+    const files = state && state.ref === source.ref ? readCached(source, state.sha) : undefined;
+    const cache = state && files ? { state, files } : undefined;
+    if (cache && (source.offline || Date.now() - cache.state.checkedAt < source.refreshTtlMs)) {
+        return { files: cache.files, sha: cache.state.sha, source: 'cache' };
+    }
+    if (source.offline) {
+        throw new Error(`offline: no cached copy of ${source.repo}@${source.ref}`);
+    }
+    let sha;
+    try {
+        sha = await resolveSha(source);
+    }
+    catch (error) {
+        if (cache) {
+            return { files: cache.files, sha: cache.state.sha, source: 'cache' };
+        }
+        throw error;
+    }
+    if (cache && cache.state.sha === sha) {
+        writeState(source, { ref: source.ref, sha, checkedAt: Date.now() });
+        return { files: cache.files, sha, source: 'cache' };
+    }
+    const downloaded = await download(source, sha);
+    writeCache(source, sha, downloaded);
+    writeState(source, { ref: source.ref, sha, checkedAt: Date.now() });
+    return { files: downloaded, sha, source: 'github' };
+};
+export const readLocalTree = (path) => {
+    const root = exists(join(path, ROOT)) ? join(path, ROOT) : path;
+    if (!exists(root)) {
+        throw new Error(`Knowledge path "${path}" does not exist`);
+    }
+    return walkMarkdown(root).map((file) => ({
+        path: relative(root, file).split(sep).join('/'),
+        content: readFileSync(file, 'utf8'),
+    }));
+};

package/dist/knowledge/loader.d.ts

@@ -1,27 +1,26 @@
-import type { KnowledgePack } from './types.js';
-/** Каталог со собственными знаниями пакета (operating-rules.md и т.п.). */
-export declare const ownKnowledgeDir: () => string;
-/** Каталог со собранными данными пакета (knowledge.json, catalog.json). */
+import { type KnowledgeFile } from './github.js';
+import type { KnowledgeOrigin, KnowledgePack } from './types.js';
+export interface KnowledgeConfig {
+    repo: string;
+    ref: string;
+    path?: string;
+    cacheDir: string;
+    refreshTtlMs: number;
+    offline: boolean;
+    token?: string;
+    timeoutMs: number;
+}
+export declare const seedDir: () => string;
 export declare const dataDir: () => string;
-/**
- * Собирает пакет знаний из чекаутов. Используется и сборкой снапшота,
- * и live-режимом, поэтому результат в обоих случаях идентичен по структуре.
- */
-export declare const buildPack: (params: {
-    backPath?: string;
-    frontPath?: string;
-    source: KnowledgePack["source"];
+export declare const docIdFromPath: (path: string) => string;
+export declare const packFromFiles: (params: {
+    files: readonly KnowledgeFile[];
+    source: KnowledgeOrigin;
     builtAt: string;
+    repo?: string;
+    ref?: string;
+    sha?: string;
+    warning?: string;
 }) => KnowledgePack;
-/** Читает собранный снапшот из data/knowledge.json. */
-export declare const loadSnapshot: () => KnowledgePack;
-/**
- * Выбирает источник знаний: живой чекаут, если он указан, иначе снапшот пакета.
- * Live-режим нужен, чтобы правка документации в dnk-back действовала сразу,
- * без переиздания npm-пакета.
- */
-export declare const resolveKnowledge: (params: {
-    backPath?: string;
-    frontPath?: string;
-}) => KnowledgePack;
-//# sourceMappingURL=loader.d.ts.map
+export declare const seedPack: (warning?: string) => KnowledgePack;
+export declare const resolveKnowledge: (config: KnowledgeConfig) => Promise<KnowledgePack>;

package/dist/knowledge/loader.js

@@ -1,125 +1,86 @@
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, relative, resolve, sep } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { chunkDocument } from './chunk.js';
-const BACK_SOURCES = [
-    { repo: 'back', subPath: '.claude/docs', docPrefix: 'back/docs' },
-    { repo: 'back', subPath: '.claude/tests', docPrefix: 'back/tests' },
-    { repo: 'back', subPath: '.claude/rules', docPrefix: 'back/rules' },
-    { repo: 'back', subPath: '.claude/fixes', docPrefix: 'back/fixes' },
-    { repo: 'back', subPath: '.claude/CLAUDE.md', docPrefix: 'back', singleFile: true },
-];
-const FRONT_SOURCES = [
-    { repo: 'front', subPath: '.claude/docs', docPrefix: 'front/docs' },
-    { repo: 'front', subPath: '.claude/rules', docPrefix: 'front/rules' },
-    { repo: 'front', subPath: '.claude/fixes', docPrefix: 'front/fixes' },
-];
-/** Рекурсивно собирает пути всех `*.md` внутри каталога. */
-const walkMarkdown = (root) => {
-    const out = [];
-    const visit = (dir) => {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                visit(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith('.md')) {
-                out.push(full);
-            }
-        }
-    };
-    visit(root);
-    return out.sort();
-};
-const exists = (path) => {
-    try {
-        statSync(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const collectSource = (repoRoot, spec) => {
-    const target = resolve(repoRoot, spec.subPath);
+import { fetchKnowledgeTree, readLocalTree } from './github.js';
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+export const seedDir = () => resolve(fileURLToPath(new URL('.', import.meta.url)), '../../knowledge');
+export const dataDir = () => resolve(fileURLToPath(new URL('.', import.meta.url)), '../../data');
+export const docIdFromPath = (path) => path.replace(/\.md$/, '').replace(/\/index$/, '');
+export const packFromFiles = (params) => {
     const docs = [];
     const chunks = [];
-    if (!exists(target)) {
-        return { docs, chunks };
-    }
-    const files = spec.singleFile ? [target] : walkMarkdown(target);
-    for (const file of files) {
-        const rel = spec.singleFile
-            ? file.split(sep).slice(-1).join('')
-            : relative(target, file);
-        const slug = rel.replace(/\.md$/, '').split(sep).join('/');
-        const docId = spec.docPrefix ? `${spec.docPrefix}/${slug}` : slug;
+    for (const file of [...params.files].sort((a, b) => a.path.localeCompare(b.path))) {
+        const docId = docIdFromPath(file.path);
         const result = chunkDocument({
             docId,
-            repo: spec.repo,
-            path: relative(repoRoot, file).split(sep).join('/'),
-            markdown: readFileSync(file, 'utf8'),
+            repo: docId.split('/')[0] ?? 'mcp',
+            path: `knowledge/${file.path}`,
+            markdown: file.content,
         });
         docs.push(result.doc);
         chunks.push(...result.chunks);
     }
-    return { docs, chunks };
+    return {
+        version: 1,
+        builtAt: params.builtAt,
+        source: params.source,
+        ...(params.repo ? { repo: params.repo } : {}),
+        ...(params.ref ? { ref: params.ref } : {}),
+        ...(params.sha ? { sha: params.sha } : {}),
+        ...(params.warning ? { warning: params.warning } : {}),
+        docs,
+        chunks,
+    };
 };
-/** Каталог со собственными знаниями пакета (operating-rules.md и т.п.). */
-export const ownKnowledgeDir = () => resolve(fileURLToPath(new URL('.', import.meta.url)), '../../knowledge');
-/** Каталог со собранными данными пакета (knowledge.json, catalog.json). */
-export const dataDir = () => resolve(fileURLToPath(new URL('.', import.meta.url)), '../../data');
-/**
- * Собирает пакет знаний из чекаутов. Используется и сборкой снапшота,
- * и live-режимом, поэтому результат в обоих случаях идентичен по структуре.
- */
-export const buildPack = (params) => {
-    const docs = [];
-    const chunks = [];
-    const own = collectSource(ownKnowledgeDir(), {
-        repo: 'mcp',
-        subPath: '.',
-        docPrefix: 'mcp',
-    });
-    docs.push(...own.docs);
-    chunks.push(...own.chunks);
-    const add = (root, specs) => {
-        if (!root) {
-            return;
+export const seedPack = (warning) => packFromFiles({
+    files: [
+        {
+            path: 'mcp/operating-rules.md',
+            content: readFileSync(resolve(seedDir(), 'operating-rules.md'), 'utf8'),
+        },
+    ],
+    source: 'seed',
+    builtAt: new Date().toISOString(),
+    ...(warning ? { warning } : {}),
+});
+export const resolveKnowledge = async (config) => {
+    const builtAt = new Date().toISOString();
+    if (config.path) {
+        try {
+            return packFromFiles({
+                files: readLocalTree(config.path),
+                source: 'local',
+                builtAt,
+                repo: config.path,
+            });
         }
-        for (const spec of specs) {
-            const result = collectSource(root, spec);
-            docs.push(...result.docs);
-            chunks.push(...result.chunks);
+        catch (error) {
+            throw new Error(`Local knowledge path "${config.path}" could not be read (${messageOf(error)}). ` +
+                'Fix the path, or unset it to read the knowledge repository from GitHub.');
         }
-    };
-    add(params.backPath, BACK_SOURCES);
-    add(params.frontPath, FRONT_SOURCES);
-    return { version: 1, builtAt: params.builtAt, source: params.source, docs, chunks };
-};
-/** Читает собранный снапшот из data/knowledge.json. */
-export const loadSnapshot = () => {
-    const file = resolve(dataDir(), 'knowledge.json');
-    const parsed = JSON.parse(readFileSync(file, 'utf8'));
-    if (parsed.version !== 1) {
-        throw new Error(`Unsupported knowledge pack version ${String(parsed.version)}`);
     }
-    return parsed;
-};
-/**
- * Выбирает источник знаний: живой чекаут, если он указан, иначе снапшот пакета.
- * Live-режим нужен, чтобы правка документации в dnk-back действовала сразу,
- * без переиздания npm-пакета.
- */
-export const resolveKnowledge = (params) => {
-    if (params.backPath) {
-        return buildPack({
-            backPath: params.backPath,
-            frontPath: params.frontPath,
-            source: 'live',
-            builtAt: new Date().toISOString(),
+    try {
+        const tree = await fetchKnowledgeTree({
+            repo: config.repo,
+            ref: config.ref,
+            cacheDir: config.cacheDir,
+            refreshTtlMs: config.refreshTtlMs,
+            offline: config.offline,
+            ...(config.token ? { token: config.token } : {}),
+            timeoutMs: config.timeoutMs,
         });
+        return packFromFiles({
+            files: tree.files,
+            source: tree.source,
+            builtAt,
+            repo: config.repo,
+            ref: config.ref,
+            sha: tree.sha,
+        });
+    }
+    catch (error) {
+        return seedPack(`Knowledge repository ${config.repo}@${config.ref} is unavailable (${messageOf(error)}). ` +
+            'Only the bundled operating rules are available — module reference docs will not be found.');
     }
-    return loadSnapshot();
 };
-//# sourceMappingURL=loader.js.map

package/dist/knowledge/search.d.ts

@@ -1,5 +1,4 @@
 import type { KnowledgeChunk, KnowledgeDoc, KnowledgePack } from './types.js';
-/** Найденный раздел с оценкой и вырезкой вокруг совпадения. */
 export interface KnowledgeHit {
     id: string;
     docId: string;
@@ -10,25 +9,15 @@ export interface KnowledgeHit {
     score: number;
     snippet: string;
 }
-/**
- * Поисковый индекс по разделам документации.
- * Хранит только идентификаторы в индексе, а тексты — в отдельной карте:
- * так `cms_docs_search` отдаёт вырезки, не поднимая в память дубли корпуса.
- */
+export declare const meaningfulQuery: (query: string) => string;
 export declare class KnowledgeIndex {
     private readonly mini;
     private readonly byId;
     private readonly byDocId;
     readonly pack: KnowledgePack;
     constructor(pack: KnowledgePack);
-    /** Разделы документа в порядке следования — для листания в cms_docs_read. */
     doc(docId: string): KnowledgeDoc | undefined;
     chunk(id: string): KnowledgeChunk | undefined;
     docs(): readonly KnowledgeDoc[];
-    /**
-     * Ищет разделы по запросу. Оценка minisearch домножается на веса источника и вида
-     * документа, поэтому правила эксплуатации всегда всплывают выше истории фиксов.
-     */
     search(query: string, limit?: number): KnowledgeHit[];
 }
-//# sourceMappingURL=search.d.ts.map

package/dist/knowledge/search.js

@@ -1,14 +1,24 @@
 import MiniSearch from 'minisearch';
-/**
- * Веса источников. `mcp` — собственные правила эксплуатации, они всегда должны
- * побеждать первичную документацию; `fixes` — история багов, полезна, но шумна,
- * поэтому опускается вниз, чтобы не вытеснять описание модуля.
- */
 const REPO_WEIGHT = { mcp: 1.6, back: 1, front: 0.9 };
-const KIND_WEIGHT = { docs: 1.15, tests: 1, rules: 1, fixes: 0.6 };
-const kindOf = (docId) => docId.split('/')[1] ?? 'docs';
+const KIND_WEIGHT = {
+    docs: 1.15,
+    tests: 1,
+    rules: 1,
+    fixes: 0.6,
+    specs: 0.6,
+};
+const kindOf = (docId) => {
+    const parts = docId.split('/');
+    if (parts[2] === 'specs') {
+        return 'specs';
+    }
+    return parts[1] ?? 'docs';
+};
 const SNIPPET_RADIUS = 180;
-/** Вырезка вокруг первого совпавшего терма; при отсутствии — начало раздела. */
+export const meaningfulQuery = (query) => {
+    const kept = query.split(/\s+/).filter((word) => word.replace(/[^\p{L}\p{N}]/gu, '').length > 2);
+    return kept.length > 0 ? kept.join(' ') : query;
+};
 const makeSnippet = (text, terms) => {
     const flat = text.replace(/\s+/g, ' ').trim();
     const lower = flat.toLowerCase();
@@ -26,11 +36,6 @@ const makeSnippet = (text, terms) => {
     const end = Math.min(flat.length, at + SNIPPET_RADIUS);
     return `${start > 0 ? '…' : ''}${flat.slice(start, end)}${end < flat.length ? '…' : ''}`;
 };
-/**
- * Поисковый индекс по разделам документации.
- * Хранит только идентификаторы в индексе, а тексты — в отдельной карте:
- * так `cms_docs_search` отдаёт вырезки, не поднимая в память дубли корпуса.
- */
 export class KnowledgeIndex {
     mini;
     byId;
@@ -53,7 +58,6 @@ export class KnowledgeIndex {
         });
         this.mini.addAll(pack.chunks);
     }
-    /** Разделы документа в порядке следования — для листания в cms_docs_read. */
     doc(docId) {
         return this.byDocId.get(docId);
     }
@@ -63,13 +67,9 @@ export class KnowledgeIndex {
     docs() {
         return this.pack.docs;
     }
-    /**
-     * Ищет разделы по запросу. Оценка minisearch домножается на веса источника и вида
-     * документа, поэтому правила эксплуатации всегда всплывают выше истории фиксов.
-     */
     search(query, limit = 8) {
         const terms = query.split(/\s+/).filter((t) => t.length > 1);
-        const raw = this.mini.search(query);
+        const raw = this.mini.search(meaningfulQuery(query));
         const hits = [];
         for (const result of raw) {
             const chunk = this.byId.get(String(result.id));
@@ -92,4 +92,3 @@ export class KnowledgeIndex {
         return hits.slice(0, limit);
     }
 }
-//# sourceMappingURL=search.js.map

package/dist/knowledge/tar.d.ts

@@ -0,0 +1,7 @@
+export interface TarEntry {
+    path: string;
+    content: string;
+}
+export declare const readTar: (buffer: Buffer) => TarEntry[];
+export declare const stripRoot: (entries: readonly TarEntry[]) => TarEntry[];
+export declare const readTarGz: (buffer: Buffer) => TarEntry[];