@shahimat/harness 0.0.0-stage → 0.2.0

package/dist/checks/changelog.js

@@ -0,0 +1,88 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeEol } from '../frontmatter.js';
+export const CHANGELOG_PATH = 'CHANGELOG.md';
+const SEPARATOR = ' · ';
+const DAY_MS = 24 * 60 * 60 * 1000;
+function parseIsoDate(value) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (m === null)
+        return null;
+    const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    const time = Date.UTC(y, mo - 1, d);
+    const date = new Date(time);
+    if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo - 1 || date.getUTCDate() !== d)
+        return null;
+    return time;
+}
+/**
+ * Проверяет журнал решений. Формат записи:
+ * `- YYYY-MM-DD · [tag] суть · почему`. До первой записи — свободный
+ * текст (заголовок, пояснение), после — только записи и пустые строки.
+ */
+export function lintChangelog(text, options, now, file = CHANGELOG_PATH) {
+    const diags = [];
+    const latest = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()) + DAY_MS;
+    const tagHint = `[${options.tags.join('|')}]`;
+    let seenEntry = false;
+    let prev = null;
+    normalizeEol(text)
+        .split('\n')
+        .forEach((line, i) => {
+        const report = (message) => {
+            diags.push({ file, line: i + 1, message });
+        };
+        if (line.trim() === '')
+            return;
+        if (!line.startsWith('- ')) {
+            if (seenEntry)
+                report('после первой записи допустимы только записи и пустые строки');
+            return;
+        }
+        seenEntry = true;
+        // Символы, а не UTF-16 и не байты: кириллица не должна считаться вдвое.
+        const length = [...line].length;
+        if (length > options.maxLine)
+            report(`длина ${length} символов > ${options.maxLine}`);
+        const parts = line.slice(2).split(SEPARATOR);
+        if (parts.length !== 3) {
+            report(`ожидается «- YYYY-MM-DD · ${tagHint} суть · почему»: частей через « · » ${parts.length}, нужно 3`);
+            return;
+        }
+        const [date, what, why] = parts;
+        const time = parseIsoDate(date);
+        if (time === null) {
+            report(`дата «${date}» — не YYYY-MM-DD или такого дня нет`);
+        }
+        else {
+            if (time > latest)
+                report(`дата ${date} в будущем`);
+            if (prev !== null && time > prev.time)
+                report(`порядок: ${date} новее предыдущей записи ${prev.date}`);
+            prev = { time, date };
+        }
+        const tagged = /^\[([^\]]*)\] (.*\S.*)$/.exec(what);
+        if (tagged === null) {
+            report(`нет тега: суть начинается с ${tagHint}`);
+        }
+        else if (!options.tags.includes(tagged[1] ?? '')) {
+            report(`тег [${tagged[1] ?? ''}] не из списка ${tagHint}`);
+        }
+        if (why.trim() === '')
+            report('пустая часть «почему»');
+    });
+    return diags;
+}
+export async function checkChangelog(root, options, now) {
+    let text;
+    try {
+        text = await readFile(path.join(root, CHANGELOG_PATH), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [{ file: CHANGELOG_PATH, message: 'файл не найден' }];
+        }
+        throw error;
+    }
+    return lintChangelog(text, options, now);
+}

package/dist/checks/context-index.d.ts

@@ -0,0 +1,11 @@
+import type { Diagnostic } from '../diagnostics.ts';
+export declare const CONTEXT_INDEX_PATH = "context/index.yml";
+export interface ContextIndexResult {
+    /** Готовый текст `context/index.yml`. */
+    text: string;
+    diagnostics: Diagnostic[];
+}
+/** Собирает `context/index.yml` из слоёв документации. */
+export declare function buildContextIndex(root: string): Promise<ContextIndexResult>;
+/** Проверка для `harness check`: нарушения слоёв + индекс совпадает с собранным. */
+export declare function checkContextIndex(root: string): Promise<Diagnostic[]>;

package/dist/checks/context-index.js

@@ -0,0 +1,355 @@
+import { access, readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse, stringify } from 'yaml';
+import { normalizeEol, parseFrontmatter } from '../frontmatter.js';
+export const CONTEXT_INDEX_PATH = 'context/index.yml';
+const PROJECT_PATH = 'context/project.yml';
+const HEADER = '# generated by harness context index — do not edit manually\n';
+const LAYERS = {
+    entities: 'docs/entities',
+    behaviors: 'docs/behavior',
+    manuals: 'docs/manuals',
+    conventions: 'context/conventions',
+};
+const MODULES_DIR = 'context/modules';
+const RESERVED_SECTIONS = new Set(['description', 'entities', 'behaviors', 'manuals']);
+/** Первый заголовок `# …` после frontmatter (комментарии YAML не считаются). */
+function firstHeading(text) {
+    const lines = normalizeEol(text).split('\n');
+    let start = 0;
+    if (lines[0] === '---') {
+        const end = lines.indexOf('---', 1);
+        if (end !== -1)
+            start = end + 1;
+    }
+    const h1 = lines.slice(start).find((line) => line.startsWith('# '));
+    return h1 === undefined ? null : h1.slice(2).trim();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Файлы с расширением `ext` под `dir`, рекурсивно; пути от корня через `/`. */
+async function listFiles(root, dir, ext) {
+    let names;
+    try {
+        names = await readdir(path.join(root, dir), { recursive: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return names
+        .filter((name) => name.endsWith(ext))
+        .map((name) => `${dir}/${name.split(path.sep).join('/')}`)
+        .sort();
+}
+const baseName = (file, ext) => path.posix.basename(file, ext);
+/** Имя manual из ссылки: `x`, `x.md` или `docs/manuals/x.md` → `x`. */
+const manualName = (ref) => path.posix.basename(ref, '.md');
+class Collector {
+    diagnostics = [];
+    namespaces = new Map();
+    conventions = new Map();
+    /** `null` — project.yml нет, namespace не проверяются. */
+    declared = null;
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    report(file, message) {
+        this.diagnostics.push({ file, message });
+    }
+    async readYaml(file) {
+        let data;
+        try {
+            data = parse(await readFile(path.join(this.root, file), 'utf8'));
+        }
+        catch (error) {
+            this.report(file, `невалидный YAML: ${error.message.split('\n')[0]}`);
+            return null;
+        }
+        if (!isRecord(data)) {
+            this.report(file, 'корень должен быть объектом');
+            return null;
+        }
+        return data;
+    }
+    namespace(name) {
+        let ns = this.namespaces.get(name);
+        if (ns === undefined) {
+            ns = { entities: new Map(), behaviors: new Map(), manuals: new Map(), layers: new Map() };
+            this.namespaces.set(name, ns);
+        }
+        return ns;
+    }
+    /** Однострочный текст поля; нет или многострочный — нарушение и `null`. */
+    oneLine(file, data, field) {
+        const value = data[field];
+        if (typeof value !== 'string' || value.trim() === '') {
+            this.report(file, `нет поля ${field} (одна строка для индекса)`);
+            return null;
+        }
+        if (value.trim().includes('\n')) {
+            this.report(file, `${field} должно быть одной строкой`);
+            return null;
+        }
+        return value.trim();
+    }
+    checkId(file, data, field, ext) {
+        const expected = baseName(file, ext);
+        const id = data[field];
+        if (typeof id !== 'string' || id === '') {
+            this.report(file, `нет поля ${field}`);
+            return null;
+        }
+        if (id !== expected)
+            this.report(file, `${field} «${id}» не совпадает с именем файла «${expected}»`);
+        return id;
+    }
+    checkNamespace(file, data) {
+        const ns = data['namespace'];
+        if (typeof ns !== 'string' || ns === '') {
+            this.report(file, 'нет поля namespace');
+            return null;
+        }
+        if (this.declared !== null && !this.declared.has(ns)) {
+            this.report(file, `namespace «${ns}» не объявлен в ${PROJECT_PATH} → namespaces`);
+        }
+        return ns;
+    }
+    async loadProject() {
+        try {
+            await access(path.join(this.root, PROJECT_PATH));
+        }
+        catch {
+            this.report(PROJECT_PATH, 'файл не найден: namespace не проверяются');
+            return;
+        }
+        const data = await this.readYaml(PROJECT_PATH);
+        if (data === null)
+            return;
+        const namespaces = data['namespaces'];
+        if (!isRecord(namespaces)) {
+            this.report(PROJECT_PATH, 'нет раздела namespaces');
+            return;
+        }
+        this.declared = new Set(Object.keys(namespaces));
+        for (const [name, description] of Object.entries(namespaces)) {
+            const ns = this.namespace(name);
+            if (typeof description === 'string' && description.trim() !== '')
+                ns.description = description.trim();
+        }
+    }
+    async collect() {
+        await this.loadProject();
+        const manualRefs = new Map();
+        for (const file of await listFiles(this.root, LAYERS.entities, '.yml')) {
+            const data = await this.readYaml(file);
+            if (data === null)
+                continue;
+            const id = this.checkId(file, data, 'id', '.yml');
+            const ns = this.checkNamespace(file, data);
+            const summary = this.oneLine(file, data, 'summary');
+            if (id === null || ns === null)
+                continue;
+            this.namespace(ns).entities.set(id, summary);
+            const manuals = data['manuals'];
+            if (Array.isArray(manuals)) {
+                for (const ref of manuals) {
+                    if (typeof ref !== 'string')
+                        continue;
+                    const name = manualName(ref);
+                    manualRefs.set(name, (manualRefs.get(name) ?? new Set()).add(ns));
+                }
+            }
+        }
+        for (const file of await listFiles(this.root, LAYERS.behaviors, '.yml')) {
+            const data = await this.readYaml(file);
+            if (data === null)
+                continue;
+            const id = this.checkId(file, data, 'id', '.yml');
+            const ns = this.checkNamespace(file, data);
+            const title = this.oneLine(file, data, 'title');
+            if (id === null || ns === null)
+                continue;
+            this.namespace(ns).behaviors.set(id, title);
+        }
+        for (const file of await listFiles(this.root, LAYERS.conventions, '.yml')) {
+            const data = await this.readYaml(file);
+            if (data === null)
+                continue;
+            const key = this.checkId(file, data, 'key', '.yml');
+            const summary = this.oneLine(file, data, 'summary');
+            if (key === null)
+                continue;
+            if (this.conventions.has(key))
+                this.report(file, `key «${key}» уже занят другой convention`);
+            this.conventions.set(key, summary);
+        }
+        for (const file of await listFiles(this.root, LAYERS.manuals, '.md')) {
+            const name = baseName(file, '.md');
+            const title = firstHeading(await readFile(path.join(this.root, file), 'utf8'));
+            if (title === null)
+                this.report(file, 'нет заголовка «# …» (одна строка для индекса)');
+            const owners = manualRefs.get(name);
+            if (owners === undefined) {
+                this.report(file, 'manual не упомянут ни в одной entity (поле manuals) — namespace не определить');
+                continue;
+            }
+            for (const ns of owners)
+                this.namespace(ns).manuals.set(name, title);
+        }
+        for (const layer of await this.loadModuleLayers())
+            await this.collectLayer(layer);
+    }
+    /** Слои, которые модули объявили в `provides.index_layers`. */
+    async loadModuleLayers() {
+        const layers = [];
+        for (const manifest of await listFiles(this.root, MODULES_DIR, '.yml')) {
+            const data = await this.readYaml(manifest);
+            if (data === null)
+                continue;
+            const provides = data['provides'];
+            const declared = isRecord(provides) ? provides['index_layers'] : undefined;
+            if (declared === undefined || declared === null)
+                continue;
+            if (!Array.isArray(declared)) {
+                this.report(manifest, 'provides.index_layers должно быть списком');
+                continue;
+            }
+            for (const item of declared) {
+                const section = isRecord(item) ? item['section'] : undefined;
+                const dir = isRecord(item) ? item['dir'] : undefined;
+                if (typeof section !== 'string' || !/^[a-z][a-z0-9-]*$/.test(section) || RESERVED_SECTIONS.has(section)) {
+                    this.report(manifest, `index_layers: section «${String(section)}» — нужен kebab-case, не ${[...RESERVED_SECTIONS].join('/')}`);
+                    continue;
+                }
+                if (typeof dir !== 'string' || dir === '' || path.isAbsolute(dir) || dir.split('/').includes('..')) {
+                    this.report(manifest, `index_layers: dir «${String(dir)}» — нужен путь внутри проекта`);
+                    continue;
+                }
+                const format = (isRecord(item) ? item['format'] : undefined) ?? 'md';
+                if (format !== 'md' && format !== 'yml') {
+                    this.report(manifest, `index_layers: format «${String(format)}» — md или yml`);
+                    continue;
+                }
+                const taken = layers.find((l) => l.section === section);
+                if (taken !== undefined) {
+                    this.report(manifest, `index_layers: section «${section}» уже объявлена в ${taken.manifest}`);
+                    continue;
+                }
+                layers.push({ section, dir: dir.replace(/\/+$/, ''), format, manifest });
+            }
+        }
+        return layers;
+    }
+    /**
+     * Файл слоя модуля: `md` — frontmatter `id`, `namespace`, строка индекса —
+     * первый `# …`; `yml` — поля `id`, `namespace`, `summary`. `id` = путь
+     * внутри слоя без расширения, `/` → `-`.
+     */
+    async collectLayer(layer) {
+        const ext = layer.format === 'md' ? '.md' : '.yml';
+        for (const file of await listFiles(this.root, layer.dir, ext)) {
+            let data;
+            let title;
+            if (layer.format === 'yml') {
+                data = await this.readYaml(file);
+                if (data === null)
+                    continue;
+                title = this.oneLine(file, data, 'summary');
+            }
+            else {
+                const text = await readFile(path.join(this.root, file), 'utf8');
+                try {
+                    data = parseFrontmatter(text);
+                }
+                catch (error) {
+                    this.report(file, `невалидный frontmatter: ${error.message.split('\n')[0]}`);
+                    continue;
+                }
+                if (data === null) {
+                    this.report(file, 'нет frontmatter (id, namespace)');
+                    continue;
+                }
+                title = firstHeading(text);
+                if (title === null)
+                    this.report(file, 'нет заголовка «# …» (одна строка для индекса)');
+            }
+            const expected = file.slice(layer.dir.length + 1, -ext.length).split('/').join('-');
+            const id = data['id'];
+            if (typeof id !== 'string' || id === '') {
+                this.report(file, 'нет поля id');
+                continue;
+            }
+            if (id !== expected)
+                this.report(file, `id «${id}» не совпадает с путём «${expected}»`);
+            const ns = this.checkNamespace(file, data);
+            if (ns === null)
+                continue;
+            const sections = this.namespace(ns).layers;
+            const entries = sections.get(layer.section) ?? new Map();
+            if (entries.has(id))
+                this.report(file, `id «${id}» уже занят в слое ${layer.section}`);
+            entries.set(id, title);
+            sections.set(layer.section, entries);
+        }
+    }
+}
+const sorted = (map) => Object.fromEntries([...map.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+function render(collector) {
+    const namespaces = {};
+    // Порядок namespace — как в project.yml; необъявленные — следом по алфавиту.
+    const declared = [...collector.namespaces.keys()].filter((n) => collector.declared?.has(n));
+    const extra = [...collector.namespaces.keys()].filter((n) => !collector.declared?.has(n)).sort();
+    for (const name of [...declared, ...extra]) {
+        const ns = collector.namespaces.get(name);
+        if (ns === undefined)
+            continue;
+        const out = {};
+        if (ns.description !== undefined)
+            out['description'] = ns.description;
+        for (const section of ['entities', 'behaviors', 'manuals']) {
+            if (ns[section].size > 0)
+                out[section] = sorted(ns[section]);
+        }
+        for (const section of [...ns.layers.keys()].sort()) {
+            const entries = ns.layers.get(section);
+            if (entries !== undefined && entries.size > 0)
+                out[section] = sorted(entries);
+        }
+        namespaces[name] = out;
+    }
+    const doc = {};
+    if (collector.conventions.size > 0)
+        doc['conventions'] = sorted(collector.conventions);
+    if (Object.keys(namespaces).length > 0)
+        doc['namespaces'] = namespaces;
+    return HEADER + stringify(doc, { lineWidth: 0 });
+}
+/** Собирает `context/index.yml` из слоёв документации. */
+export async function buildContextIndex(root) {
+    const collector = new Collector(root);
+    await collector.collect();
+    return { text: render(collector), diagnostics: collector.diagnostics };
+}
+/** Проверка для `harness check`: нарушения слоёв + индекс совпадает с собранным. */
+export async function checkContextIndex(root) {
+    const { text, diagnostics } = await buildContextIndex(root);
+    let actual = null;
+    try {
+        actual = await readFile(path.join(root, CONTEXT_INDEX_PATH), 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (actual === null) {
+        diagnostics.push({ file: CONTEXT_INDEX_PATH, message: 'файл не найден: запусти harness context index' });
+    }
+    else if (normalizeEol(actual) !== text) {
+        diagnostics.push({ file: CONTEXT_INDEX_PATH, message: 'устарел: запусти harness context index' });
+    }
+    return diagnostics;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function main(argv: string[], now?: Date): Promise<number>;
+export declare function run(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { runAdapters } from './commands/adapters.js';
+import { runChangelog } from './commands/changelog.js';
+import { runCheck } from './commands/check.js';
+import { runContext } from './commands/context.js';
+import { runIndex } from './commands/prompt-index.js';
+import { UsageError } from './diagnostics.js';
+const USAGE = `Использование:
+  harness check [--root <dir>]
+  harness adapters sync [--root <dir>]
+  harness changelog lint [--root <dir>]
+  harness context index [--root <dir>]
+  harness index build --raw-base <url> [--root <dir>] [--out <file>]
+  harness index check --raw-base <url> [--root <dir>]
+
+Коды выхода: 0 — ok, 1 — найдены нарушения, 2 — ошибка вызова или конфигурации.`;
+export async function main(argv, now = new Date()) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            root: { type: 'string', default: '.' },
+            out: { type: 'string' },
+            'raw-base': { type: 'string' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    if (values.help) {
+        console.log(USAGE);
+        return 0;
+    }
+    const args = { root: path.resolve(values.root), now };
+    if (values.out !== undefined)
+        args.out = values.out;
+    if (values['raw-base'] !== undefined)
+        args.rawBase = values['raw-base'];
+    const [group, command] = positionals;
+    switch (group) {
+        case 'adapters':
+            return runAdapters(command, args);
+        case 'check':
+            return runCheck(args);
+        case 'changelog':
+            return runChangelog(command, args);
+        case 'context':
+            return runContext(command, args);
+        case 'index':
+            return runIndex(command, args);
+        default:
+            throw new UsageError(`неизвестная команда: ${positionals.join(' ') || '<пусто>'}`);
+    }
+}
+export async function run(argv) {
+    try {
+        return await main(argv);
+    }
+    catch (error) {
+        console.error(`ERROR: ${error instanceof Error ? error.message : String(error)}`);
+        if (error instanceof UsageError) {
+            console.error(USAGE);
+            return 2;
+        }
+        // parseArgs бросает TypeError с code ERR_PARSE_ARGS_* на неизвестных опциях.
+        return String(error.code).startsWith('ERR_PARSE_ARGS') ? 2 : 1;
+    }
+}

package/dist/commands/adapters.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArgs } from './types.ts';
+export declare function runAdapters(command: string | undefined, args: CommandArgs): Promise<number>;

package/dist/commands/adapters.js

@@ -0,0 +1,18 @@
+import { applyActions, computeSync } from '../adapters/sync.js';
+import { CONFIG_PATH, loadConfig } from '../config.js';
+import { UsageError } from '../diagnostics.js';
+import { report } from './report.js';
+export async function runAdapters(command, args) {
+    if (command !== 'sync')
+        throw new UsageError(`неизвестная команда: adapters ${command ?? ''}`.trimEnd());
+    const config = await loadConfig(args.root);
+    if (config === null)
+        throw new UsageError(`нет ${CONFIG_PATH}: список adapters берётся оттуда`);
+    const { actions, diagnostics } = await computeSync(args.root, config.adapters);
+    await applyActions(args.root, actions);
+    for (const action of actions)
+        console.error(`${action.op === 'write' ? 'wrote' : 'deleted'} ${action.path}`);
+    if (actions.length === 0)
+        console.error('adapters: без изменений');
+    return report('adapters', diagnostics);
+}

package/dist/commands/changelog.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArgs } from './types.ts';
+export declare function runChangelog(command: string | undefined, args: CommandArgs): Promise<number>;

package/dist/commands/changelog.js

@@ -0,0 +1,12 @@
+import { checkChangelog } from '../checks/changelog.js';
+import { DEFAULT_CHANGELOG, loadConfig } from '../config.js';
+import { UsageError } from '../diagnostics.js';
+import { report } from './report.js';
+export async function runChangelog(command, args) {
+    if (command !== 'lint')
+        throw new UsageError(`неизвестная команда: changelog ${command ?? ''}`.trimEnd());
+    // Работает и без harness.yml — со значениями по умолчанию.
+    const config = await loadConfig(args.root);
+    const options = config?.checks.changelog ?? DEFAULT_CHANGELOG;
+    return report('changelog', await checkChangelog(args.root, options, args.now));
+}

package/dist/commands/check.d.ts

@@ -0,0 +1,3 @@
+import type { CommandArgs } from './types.ts';
+/** Запускает все проверки, включённые в harness.yml. */
+export declare function runCheck(args: CommandArgs): Promise<number>;

package/dist/commands/check.js

@@ -0,0 +1,31 @@
+import { checkAdapters } from '../adapters/sync.js';
+import { checkChangelog } from '../checks/changelog.js';
+import { checkContextIndex } from '../checks/context-index.js';
+import { CONFIG_PATH, loadConfig } from '../config.js';
+import { UsageError } from '../diagnostics.js';
+import { report } from './report.js';
+/** Запускает все проверки, включённые в harness.yml. */
+export async function runCheck(args) {
+    const config = await loadConfig(args.root);
+    if (config === null)
+        throw new UsageError(`нет ${CONFIG_PATH}: harness в проекте не настроен`);
+    const ran = [];
+    const diags = [];
+    if (config.checks.changelog !== undefined) {
+        ran.push('changelog');
+        diags.push(...(await checkChangelog(args.root, config.checks.changelog, args.now)));
+    }
+    if (config.checks['context-index'] !== undefined) {
+        ran.push('context-index');
+        diags.push(...(await checkContextIndex(args.root)));
+    }
+    if (config.checks.adapters !== undefined) {
+        ran.push('adapters');
+        diags.push(...(await checkAdapters(args.root, config.adapters)));
+    }
+    if (ran.length === 0) {
+        console.log(`check: в ${CONFIG_PATH} не включено ни одной проверки`);
+        return 0;
+    }
+    return report(`check (${ran.join(', ')})`, diags);
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArgs } from './types.ts';
+export declare function runContext(command: string | undefined, args: CommandArgs): Promise<number>;

package/dist/commands/context.js

@@ -0,0 +1,16 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { buildContextIndex, CONTEXT_INDEX_PATH } from '../checks/context-index.js';
+import { UsageError } from '../diagnostics.js';
+import { report } from './report.js';
+export async function runContext(command, args) {
+    if (command !== 'index')
+        throw new UsageError(`неизвестная команда: context ${command ?? ''}`.trimEnd());
+    const { text, diagnostics } = await buildContextIndex(args.root);
+    // Пишем и при нарушениях: индекс с пробелами полезнее устаревшего.
+    const file = path.join(args.root, CONTEXT_INDEX_PATH);
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, text, 'utf8');
+    console.error(`wrote ${CONTEXT_INDEX_PATH}`);
+    return report('context index', diagnostics);
+}

package/dist/commands/prompt-index.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArgs } from './types.ts';
+export declare function runIndex(command: string | undefined, args: CommandArgs): Promise<number>;