@shahimat/harness 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# @shahimat/harness
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CLI для проектов на контракте
+[`agent-operational-contract-v3`](https://github.com/Shahimat/ai-prompts/blob/main/prompts/productivity/agent-operational-contract-v3.md):
+механические проверки и генерация, чтобы агент не держал их в памяти.
+
+Node ≥ 24. macOS, Linux, Windows.
+
+## Запуск
+
+```bash
+npx -y @shahimat/harness@<version> <команда> --root .
+```
+
+Версия проекта — `version` в `context/harness.yml`.
+
+## Команды
+
+- `harness check` — все проверки, включённые в `context/harness.yml`.
+- `harness changelog lint` — `CHANGELOG.md`: строка
+  `- YYYY-MM-DD · [tag] суть · почему` до 120 символов, тег из списка,
+  порядок дат.
+- `harness context index` — генерация `context/index.yml` из слоёв
+  документации (entities, behavior, manuals, conventions, слои модулей).
+- `harness adapters sync` — файлы под Claude Code и Codex из
+  `AGENTS.md` и `.agents/`: `CLAUDE.md`, копии skills, субагенты,
+  выключенная memory агента.
+- `harness index build | check --raw-base <url>` — индекс
+  `prompts/index.yml` репозитория промптов.
+
+Коды выхода: `0` — ok, `1` — нарушения, `2` — ошибка вызова или
+конфигурации.
+
+## `context/harness.yml`
+
+```yaml
+version: 0.1.0
+adapters: [claude-code, codex]
+checks:
+  changelog:
+    max_line: 120
+    tags: [arch, stack, dep, milestone]
+  context-index: {}
+  adapters: {}
+```
+
+## Лицензия
+
+MIT

package/dist/adapters/memory.d.ts

@@ -0,0 +1,25 @@
+import type { Diagnostic } from '../diagnostics.ts';
+import type { Action } from './sync.ts';
+/**
+ * Memory агента запрещена контрактом: адаптер выключает её настройкой
+ * инструмента в проекте.
+ */
+export declare const CLAUDE_SETTINGS = ".claude/settings.json";
+export declare const CODEX_CONFIG = ".codex/config.toml";
+export declare function codexConfig(): string;
+/**
+ * `.claude/settings.json` правится по ключу: файл общий с permissions и
+ * hooks проекта, остальное содержимое сохраняется.
+ */
+export declare function claudeMemory(root: string): Promise<{
+    actions: Action[];
+    diagnostics: Diagnostic[];
+}>;
+/**
+ * `.codex/config.toml`: нет файла или он наш — генерируем целиком; написан
+ * вручную — не трогаем, только проверяем ключи.
+ */
+export declare function codexMemory(root: string): Promise<{
+    actions: Action[];
+    diagnostics: Diagnostic[];
+}>;

package/dist/adapters/memory.js

@@ -0,0 +1,111 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { GENERATED_MARK } from './render.js';
+/**
+ * Memory агента запрещена контрактом: адаптер выключает её настройкой
+ * инструмента в проекте.
+ */
+export const CLAUDE_SETTINGS = '.claude/settings.json';
+export const CODEX_CONFIG = '.codex/config.toml';
+/** Ключи Codex, которые выключают memories: `таблица.ключ` → значение. */
+const CODEX_MEMORY_KEYS = ['features.memories', 'memories.use_memories', 'memories.generate_memories'];
+export function codexConfig() {
+    return [
+        `# ${GENERATED_MARK} — do not edit; memory агента запрещена контрактом`,
+        '[features]',
+        'memories = false',
+        '',
+        '[memories]',
+        'use_memories = false',
+        'generate_memories = false',
+        '',
+    ].join('\n');
+}
+async function readOrNull(abs) {
+    try {
+        return await readFile(abs, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+/**
+ * `.claude/settings.json` правится по ключу: файл общий с permissions и
+ * hooks проекта, остальное содержимое сохраняется.
+ */
+export async function claudeMemory(root) {
+    const current = await readOrNull(path.join(root, CLAUDE_SETTINGS));
+    const write = (data) => ({
+        op: 'write',
+        path: CLAUDE_SETTINGS,
+        content: Buffer.from(`${JSON.stringify(data, null, 2)}\n`, 'utf8'),
+    });
+    if (current === null)
+        return { actions: [write({ autoMemoryEnabled: false })], diagnostics: [] };
+    let data;
+    try {
+        data = JSON.parse(current);
+    }
+    catch (error) {
+        return {
+            actions: [],
+            diagnostics: [{ file: CLAUDE_SETTINGS, message: `невалидный JSON: ${error.message}` }],
+        };
+    }
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return { actions: [], diagnostics: [{ file: CLAUDE_SETTINGS, message: 'корень должен быть объектом' }] };
+    }
+    const settings = data;
+    if (settings['autoMemoryEnabled'] === false)
+        return { actions: [], diagnostics: [] };
+    return { actions: [write({ ...settings, autoMemoryEnabled: false })], diagnostics: [] };
+}
+/** Значения `таблица.ключ` из простого TOML: таблицы, пары, dotted-ключи. */
+function scanToml(text) {
+    const values = new Map();
+    let table = '';
+    for (const raw of text.replace(/\r\n?/g, '\n').split('\n')) {
+        const line = raw.replace(/\s+#.*$/, '').trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const header = /^\[([^\[\]]+)\]$/.exec(line);
+        if (header !== null) {
+            table = (header[1] ?? '').trim();
+            continue;
+        }
+        const pair = /^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/.exec(line);
+        if (pair === null)
+            continue;
+        const key = table === '' ? (pair[1] ?? '') : `${table}.${pair[1] ?? ''}`;
+        values.set(key, (pair[2] ?? '').trim());
+    }
+    return values;
+}
+/**
+ * `.codex/config.toml`: нет файла или он наш — генерируем целиком; написан
+ * вручную — не трогаем, только проверяем ключи.
+ */
+export async function codexMemory(root) {
+    const current = await readOrNull(path.join(root, CODEX_CONFIG));
+    const expected = codexConfig();
+    if (current === null || current.includes(GENERATED_MARK)) {
+        if (current === expected)
+            return { actions: [], diagnostics: [] };
+        return { actions: [{ op: 'write', path: CODEX_CONFIG, content: Buffer.from(expected, 'utf8') }], diagnostics: [] };
+    }
+    const values = scanToml(current);
+    const missing = CODEX_MEMORY_KEYS.filter((key) => values.get(key) !== 'false');
+    if (missing.length === 0)
+        return { actions: [], diagnostics: [] };
+    return {
+        actions: [],
+        diagnostics: [
+            {
+                file: CODEX_CONFIG,
+                message: `написан вручную, memory не выключена: добавь ${missing.map((k) => `${k} = false`).join(', ')}`,
+            },
+        ],
+    };
+}

package/dist/adapters/render.d.ts

@@ -0,0 +1,9 @@
+import type { AgentDef } from './source.ts';
+/** Метка сгенерированного файла: по ней sync отличает свои файлы от ручных. */
+export declare const GENERATED_MARK = "generated by harness adapters sync";
+/** Файл-метка внутри скопированного каталога skill. */
+export declare const SKILL_MARKER_FILE = ".harness-generated";
+export declare function claudeMd(): string;
+export declare function skillMarker(name: string): string;
+export declare function claudeAgent(agent: AgentDef): string;
+export declare function codexAgent(agent: AgentDef): string;

package/dist/adapters/render.js

@@ -0,0 +1,43 @@
+import { stringify } from 'yaml';
+/** Метка сгенерированного файла: по ней sync отличает свои файлы от ручных. */
+export const GENERATED_MARK = 'generated by harness adapters sync';
+/** Файл-метка внутри скопированного каталога skill. */
+export const SKILL_MARKER_FILE = '.harness-generated';
+export function claudeMd() {
+    return `<!-- ${GENERATED_MARK} — do not edit, правь AGENTS.md -->\n@AGENTS.md\n`;
+}
+export function skillMarker(name) {
+    return `${GENERATED_MARK} from .agents/skills/${name} — do not edit\n`;
+}
+export function claudeAgent(agent) {
+    const fields = { name: agent.name, description: agent.description };
+    // Claude Code ждёт tools строкой через запятую.
+    if (agent.tools.length > 0)
+        fields['tools'] = agent.tools.join(', ');
+    if (agent.skills.length > 0)
+        fields['skills'] = agent.skills;
+    const yaml = stringify(fields, { lineWidth: 0 });
+    return `---\n# ${GENERATED_MARK} from ${agent.source} — do not edit\n${yaml}---\n\n${agent.instructions}\n`;
+}
+/** Строка TOML в одну строку: экранирование JSON совместимо с basic string TOML. */
+const tomlString = (value) => JSON.stringify(value);
+/** Многострочная basic string TOML; `"""` внутри текста экранируется. */
+function tomlMultiline(value) {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"""/g, '""\\"')
+        // Управляющие символы, кроме перевода строки и табуляции, в TOML недопустимы.
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+    return `"""\n${escaped}\n"""`;
+}
+export function codexAgent(agent) {
+    // У Codex нет предзагрузки skills: явно просим загрузить их.
+    const preface = agent.skills.length > 0 ? `Перед работой загрузи skills: ${agent.skills.join(', ')}.\n\n` : '';
+    return [
+        `# ${GENERATED_MARK} from ${agent.source} — do not edit`,
+        `name = ${tomlString(agent.name)}`,
+        `description = ${tomlString(agent.description)}`,
+        `developer_instructions = ${tomlMultiline(preface + agent.instructions)}`,
+        '',
+    ].join('\n');
+}

package/dist/adapters/source.d.ts

@@ -0,0 +1,30 @@
+import type { Diagnostic } from '../diagnostics.ts';
+export declare const AGENTS_MD = "AGENTS.md";
+export declare const SKILLS_DIR = ".agents/skills";
+export declare const AGENTS_DIR = ".agents/agents";
+/** Файл skill: путь внутри каталога skill (через `/`) и содержимое. */
+export interface SkillFile {
+    rel: string;
+    content: Buffer;
+}
+export interface Skill {
+    name: string;
+    files: SkillFile[];
+}
+/** Субагент из `.agents/agents/<name>.md`. */
+export interface AgentDef {
+    name: string;
+    source: string;
+    description: string;
+    skills: string[];
+    tools: string[];
+    instructions: string;
+}
+export interface Sources {
+    hasAgentsMd: boolean;
+    skills: Skill[];
+    agents: AgentDef[];
+    diagnostics: Diagnostic[];
+}
+/** Читает канонические источники адаптеров. */
+export declare function readSources(root: string): Promise<Sources>;

package/dist/adapters/source.js

@@ -0,0 +1,114 @@
+import { access, readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeEol, parseFrontmatter } from '../frontmatter.js';
+export const AGENTS_MD = 'AGENTS.md';
+export const SKILLS_DIR = '.agents/skills';
+export const AGENTS_DIR = '.agents/agents';
+const AGENT_KEYS = ['name', 'description', 'skills', 'tools'];
+async function listDir(dir) {
+    try {
+        return (await readdir(dir)).sort();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function readSkill(root, name) {
+    const dir = path.join(root, SKILLS_DIR, name);
+    const entries = await readdir(dir, { recursive: true, withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const abs = path.join(entry.parentPath, entry.name);
+        files.push({ rel: path.relative(dir, abs).split(path.sep).join('/'), content: await readFile(abs) });
+    }
+    files.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+    return { name, files };
+}
+function stringList(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string' && v !== ''))
+        return null;
+    return value;
+}
+function parseAgent(file, text, report) {
+    let fm;
+    try {
+        fm = parseFrontmatter(text);
+    }
+    catch (error) {
+        report(`невалидный frontmatter: ${error.message.split('\n')[0]}`);
+        return null;
+    }
+    if (fm === null) {
+        report('нет frontmatter (--- name, description ---)');
+        return null;
+    }
+    const extra = Object.keys(fm).filter((k) => !AGENT_KEYS.includes(k));
+    if (extra.length > 0)
+        report(`неизвестные поля frontmatter: ${extra.join(', ')}`);
+    const expected = path.posix.basename(file, '.md');
+    const { name, description } = fm;
+    if (name !== expected)
+        report(`name «${String(name)}» не совпадает с именем файла «${expected}»`);
+    if (typeof description !== 'string' || description.trim() === '')
+        report('нет поля description');
+    const skills = stringList(fm['skills']);
+    if (skills === null)
+        report('skills должно быть списком строк');
+    const tools = stringList(fm['tools']);
+    if (tools === null)
+        report('tools должно быть списком строк');
+    const body = normalizeEol(text).split('\n');
+    const end = body.indexOf('---', 1);
+    const instructions = body.slice(end + 1).join('\n').trim();
+    if (instructions === '')
+        report('пустое тело: инструкции субагента');
+    if (name !== expected || typeof description !== 'string' || skills === null || tools === null)
+        return null;
+    if (description.trim() === '' || instructions === '')
+        return null;
+    return { name: expected, source: file, description: description.trim(), skills, tools, instructions };
+}
+/** Читает канонические источники адаптеров. */
+export async function readSources(root) {
+    const diagnostics = [];
+    const hasAgentsMd = await access(path.join(root, AGENTS_MD)).then(() => true, () => false);
+    const skills = [];
+    for (const name of await listDir(path.join(root, SKILLS_DIR))) {
+        const skill = await readSkill(root, name).catch((error) => {
+            if (error.code === 'ENOTDIR')
+                return null;
+            throw error;
+        });
+        if (skill === null)
+            continue;
+        if (!skill.files.some((f) => f.rel === 'SKILL.md')) {
+            diagnostics.push({ file: `${SKILLS_DIR}/${name}`, message: 'нет SKILL.md — не skill, пропущен' });
+            continue;
+        }
+        skills.push(skill);
+    }
+    const agents = [];
+    for (const entry of await listDir(path.join(root, AGENTS_DIR))) {
+        if (!entry.endsWith('.md'))
+            continue;
+        const file = `${AGENTS_DIR}/${entry}`;
+        const report = (message) => {
+            diagnostics.push({ file, message });
+        };
+        const agent = parseAgent(file, await readFile(path.join(root, file), 'utf8'), report);
+        if (agent === null)
+            continue;
+        for (const skill of agent.skills) {
+            if (!skills.some((s) => s.name === skill))
+                report(`skill «${skill}» не найден в ${SKILLS_DIR}`);
+        }
+        agents.push(agent);
+    }
+    return { hasAgentsMd, skills, agents, diagnostics };
+}

package/dist/adapters/sync.d.ts

@@ -0,0 +1,21 @@
+import type { Diagnostic } from '../diagnostics.ts';
+export declare const KNOWN_ADAPTERS: readonly ['claude-code', 'codex'];
+export type AdapterName = (typeof KNOWN_ADAPTERS)[number];
+export interface Action {
+    op: 'write' | 'delete';
+    /** Путь от корня проекта, через `/`. */
+    path: string;
+    content?: Buffer;
+}
+export interface SyncResult {
+    actions: Action[];
+    diagnostics: Diagnostic[];
+}
+/**
+ * Сравнивает план с диском. Файлы без метки harness не трогаются никогда:
+ * они попадают в нарушения, а не в действия.
+ */
+export declare function computeSync(root: string, adapters: readonly AdapterName[]): Promise<SyncResult>;
+export declare function applyActions(root: string, actions: Action[]): Promise<void>;
+/** Проверка для `harness check`: всё сгенерированное совпадает с источниками. */
+export declare function checkAdapters(root: string, adapters: readonly AdapterName[]): Promise<Diagnostic[]>;

package/dist/adapters/sync.js

@@ -0,0 +1,182 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { claudeMemory, CODEX_CONFIG, codexMemory } from './memory.js';
+import { claudeAgent, claudeMd, codexAgent, GENERATED_MARK, SKILL_MARKER_FILE, skillMarker } from './render.js';
+import { AGENTS_MD, readSources } from './source.js';
+export const KNOWN_ADAPTERS = ['claude-code', 'codex'];
+const CLAUDE_MD = 'CLAUDE.md';
+const CLAUDE_SKILLS = '.claude/skills';
+const CLAUDE_AGENTS = '.claude/agents';
+const CODEX_AGENTS = '.codex/agents';
+const text = (value) => Buffer.from(value, 'utf8');
+const isOurs = (content) => content.includes(GENERATED_MARK);
+async function readOrNull(abs) {
+    try {
+        return await readFile(abs);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'EISDIR')
+            return null;
+        throw error;
+    }
+}
+async function listFiles(abs) {
+    try {
+        const entries = await readdir(abs, { recursive: true, withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile())
+            .map((e) => path.relative(abs, path.join(e.parentPath, e.name)).split(path.sep).join('/'))
+            .sort();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function listNames(abs) {
+    try {
+        return (await readdir(abs)).sort();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function plan(root, adapters) {
+    const sources = await readSources(root);
+    const diagnostics = [...sources.diagnostics];
+    const units = [];
+    if (adapters.includes('claude-code')) {
+        if (sources.hasAgentsMd) {
+            units.push({ kind: 'file', path: CLAUDE_MD, content: text(claudeMd()) });
+        }
+        else {
+            diagnostics.push({ file: AGENTS_MD, message: 'файл не найден: CLAUDE.md не из чего генерировать' });
+        }
+        for (const skill of sources.skills) {
+            const files = new Map(skill.files.map((f) => [f.rel, f.content]));
+            files.set(SKILL_MARKER_FILE, text(skillMarker(skill.name)));
+            units.push({ kind: 'dir', path: `${CLAUDE_SKILLS}/${skill.name}`, files });
+        }
+        for (const agent of sources.agents) {
+            units.push({ kind: 'file', path: `${CLAUDE_AGENTS}/${agent.name}.md`, content: text(claudeAgent(agent)) });
+        }
+    }
+    if (adapters.includes('codex')) {
+        for (const agent of sources.agents) {
+            units.push({ kind: 'file', path: `${CODEX_AGENTS}/${agent.name}.toml`, content: text(codexAgent(agent)) });
+        }
+    }
+    return { units, diagnostics };
+}
+const conflict = (file) => ({
+    file,
+    message: 'существует и написан не harness — не трогаю; перенеси содержимое в источник (.agents/, AGENTS.md) и удали файл',
+});
+/** Сгенерированные файлы и каталоги на диске, которые не входят в план. */
+async function staleActions(root, planned) {
+    const actions = [];
+    const consider = async (rel) => {
+        if (planned.has(rel))
+            return;
+        const content = await readOrNull(path.join(root, rel));
+        if (content !== null && isOurs(content))
+            actions.push({ op: 'delete', path: rel });
+    };
+    await consider(CLAUDE_MD);
+    await consider(CODEX_CONFIG);
+    for (const name of await listNames(path.join(root, CLAUDE_AGENTS))) {
+        if (name.endsWith('.md'))
+            await consider(`${CLAUDE_AGENTS}/${name}`);
+    }
+    for (const name of await listNames(path.join(root, CODEX_AGENTS))) {
+        if (name.endsWith('.toml'))
+            await consider(`${CODEX_AGENTS}/${name}`);
+    }
+    for (const name of await listNames(path.join(root, CLAUDE_SKILLS))) {
+        const dir = `${CLAUDE_SKILLS}/${name}`;
+        if (planned.has(dir))
+            continue;
+        const marker = await readOrNull(path.join(root, dir, SKILL_MARKER_FILE));
+        if (marker !== null && isOurs(marker))
+            actions.push({ op: 'delete', path: dir });
+    }
+    return actions;
+}
+/**
+ * Сравнивает план с диском. Файлы без метки harness не трогаются никогда:
+ * они попадают в нарушения, а не в действия.
+ */
+export async function computeSync(root, adapters) {
+    const { units, diagnostics } = await plan(root, adapters);
+    const actions = [];
+    for (const unit of units) {
+        if (unit.kind === 'file') {
+            const current = await readOrNull(path.join(root, unit.path));
+            if (current === null)
+                actions.push({ op: 'write', path: unit.path, content: unit.content });
+            else if (!isOurs(current))
+                diagnostics.push(conflict(unit.path));
+            else if (!current.equals(unit.content))
+                actions.push({ op: 'write', path: unit.path, content: unit.content });
+            continue;
+        }
+        const existing = await listFiles(path.join(root, unit.path));
+        if (existing.length > 0) {
+            const marker = await readOrNull(path.join(root, unit.path, SKILL_MARKER_FILE));
+            if (marker === null || !isOurs(marker)) {
+                diagnostics.push(conflict(unit.path));
+                continue;
+            }
+        }
+        for (const [rel, content] of unit.files) {
+            const current = await readOrNull(path.join(root, unit.path, rel));
+            if (current === null || !current.equals(content)) {
+                actions.push({ op: 'write', path: `${unit.path}/${rel}`, content });
+            }
+        }
+        for (const rel of existing) {
+            if (!unit.files.has(rel))
+                actions.push({ op: 'delete', path: `${unit.path}/${rel}` });
+        }
+    }
+    // Memory агента запрещена контрактом — выключаем её настройкой инструмента.
+    const planned = new Set(units.map((u) => u.path));
+    for (const [adapter, apply] of [
+        ['claude-code', claudeMemory],
+        ['codex', codexMemory],
+    ]) {
+        if (!adapters.includes(adapter))
+            continue;
+        const memory = await apply(root);
+        actions.push(...memory.actions);
+        diagnostics.push(...memory.diagnostics);
+        if (adapter === 'codex')
+            planned.add(CODEX_CONFIG);
+    }
+    actions.push(...(await staleActions(root, planned)));
+    return { actions, diagnostics };
+}
+export async function applyActions(root, actions) {
+    for (const action of actions) {
+        const abs = path.join(root, action.path);
+        if (action.op === 'delete') {
+            await rm(abs, { recursive: true, force: true });
+            continue;
+        }
+        await mkdir(path.dirname(abs), { recursive: true });
+        await writeFile(abs, action.content ?? Buffer.alloc(0));
+    }
+}
+/** Проверка для `harness check`: всё сгенерированное совпадает с источниками. */
+export async function checkAdapters(root, adapters) {
+    const { actions, diagnostics } = await computeSync(root, adapters);
+    for (const action of actions) {
+        const what = action.op === 'write' ? 'отсутствует или устарел' : 'лишний';
+        diagnostics.push({ file: action.path, message: `${what}: запусти harness adapters sync` });
+    }
+    return diagnostics;
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from './cli.js';
+process.exitCode = await run(process.argv.slice(2));

package/dist/checks/changelog.d.ts

@@ -0,0 +1,10 @@
+import type { ChangelogOptions } from '../config.ts';
+import type { Diagnostic } from '../diagnostics.ts';
+export declare const CHANGELOG_PATH = "CHANGELOG.md";
+/**
+ * Проверяет журнал решений. Формат записи:
+ * `- YYYY-MM-DD · [tag] суть · почему`. До первой записи — свободный
+ * текст (заголовок, пояснение), после — только записи и пустые строки.
+ */
+export declare function lintChangelog(text: string, options: ChangelogOptions, now: Date, file?: string): Diagnostic[];
+export declare function checkChangelog(root: string, options: ChangelogOptions, now: Date): Promise<Diagnostic[]>;