@shahimat/harness 0.0.0-stage → 0.1.0

package/dist/commands/report.js

@@ -0,0 +1,12 @@
+import { formatDiagnostic } from '../diagnostics.js';
+/** Печатает нарушения и возвращает код выхода. */
+export function report(label, diags) {
+    if (diags.length === 0) {
+        console.log(`${label}: ok`);
+        return 0;
+    }
+    for (const d of diags)
+        console.error(formatDiagnostic(d));
+    console.error(`${label}: нарушений ${diags.length}`);
+    return 1;
+}

package/dist/commands/types.d.ts

@@ -0,0 +1,8 @@
+export interface CommandArgs {
+    /** Абсолютный путь к корню проекта. */
+    root: string;
+    out?: string;
+    rawBase?: string;
+    /** Текущий момент; подменяется в тестах. */
+    now: Date;
+}

package/dist/commands/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import { type AdapterName } from './adapters/sync.ts';
+export declare const CONFIG_PATH = "context/harness.yml";
+export interface ChangelogOptions {
+    maxLine: number;
+    tags: string[];
+}
+export declare const DEFAULT_CHANGELOG: ChangelogOptions;
+export interface HarnessConfig {
+    version?: string;
+    adapters: AdapterName[];
+    /** Включённые проверки; ключ отсутствует — проверка выключена. */
+    checks: {
+        changelog?: ChangelogOptions;
+        'context-index'?: Record<string, never>;
+        adapters?: Record<string, never>;
+    };
+}
+export declare function parseConfig(text: string): HarnessConfig;
+/** Читает `context/harness.yml`; нет файла — `null`. */
+export declare function loadConfig(root: string): Promise<HarnessConfig | null>;

package/dist/config.js

@@ -0,0 +1,101 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { KNOWN_ADAPTERS } from './adapters/sync.js';
+import { UsageError } from './diagnostics.js';
+export const CONFIG_PATH = 'context/harness.yml';
+export const DEFAULT_CHANGELOG = {
+    maxLine: 120,
+    tags: ['arch', 'stack', 'dep', 'milestone'],
+};
+const TOP_LEVEL_KEYS = ['version', 'adapters', 'checks', 'worktrees', 'rules'];
+const KNOWN_CHECKS = ['changelog', 'context-index', 'adapters'];
+function fail(message) {
+    throw new UsageError(`${CONFIG_PATH}: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unknownKeys(obj, known, where) {
+    const extra = Object.keys(obj).filter((k) => !known.includes(k));
+    if (extra.length > 0)
+        fail(`неизвестные ключи в ${where}: ${extra.join(', ')}`);
+}
+function stringList(value, where) {
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string' && v !== '')) {
+        fail(`${where} должно быть списком непустых строк`);
+    }
+    return value;
+}
+function parseChangelog(value) {
+    if (value === null || value === undefined)
+        return { ...DEFAULT_CHANGELOG };
+    if (!isRecord(value))
+        fail('checks.changelog должно быть объектом');
+    unknownKeys(value, ['max_line', 'tags'], 'checks.changelog');
+    const maxLine = value['max_line'] ?? DEFAULT_CHANGELOG.maxLine;
+    if (typeof maxLine !== 'number' || !Number.isInteger(maxLine) || maxLine <= 0) {
+        fail('checks.changelog.max_line должно быть целым числом > 0');
+    }
+    const tags = value['tags'] === undefined ? DEFAULT_CHANGELOG.tags : stringList(value['tags'], 'checks.changelog.tags');
+    if (tags.length === 0)
+        fail('checks.changelog.tags не может быть пустым');
+    return { maxLine, tags: [...tags] };
+}
+export function parseConfig(text) {
+    let data;
+    try {
+        data = parse(text);
+    }
+    catch (error) {
+        fail(`невалидный YAML: ${error.message.split('\n')[0]}`);
+    }
+    if (data === null || data === undefined)
+        data = {};
+    if (!isRecord(data))
+        fail('корень должен быть объектом');
+    unknownKeys(data, TOP_LEVEL_KEYS, 'корне');
+    const config = { adapters: [], checks: {} };
+    const version = data['version'];
+    if (version !== undefined) {
+        if (typeof version !== 'string' || version === '')
+            fail('version должно быть строкой');
+        config.version = version;
+    }
+    if (data['adapters'] !== undefined) {
+        const adapters = stringList(data['adapters'], 'adapters');
+        const unknown = adapters.filter((a) => !KNOWN_ADAPTERS.includes(a));
+        if (unknown.length > 0)
+            fail(`неизвестные adapters: ${unknown.join(', ')} (есть: ${KNOWN_ADAPTERS.join(', ')})`);
+        config.adapters = adapters;
+    }
+    const checks = data['checks'] ?? {};
+    if (!isRecord(checks))
+        fail('checks должно быть объектом');
+    unknownKeys(checks, KNOWN_CHECKS, 'checks');
+    if ('changelog' in checks)
+        config.checks.changelog = parseChangelog(checks['changelog']);
+    for (const name of ['context-index', 'adapters']) {
+        if (!(name in checks))
+            continue;
+        const options = checks[name] ?? {};
+        if (!isRecord(options))
+            fail(`checks.${name} должно быть объектом`);
+        unknownKeys(options, [], `checks.${name}`);
+        config.checks[name] = {};
+    }
+    return config;
+}
+/** Читает `context/harness.yml`; нет файла — `null`. */
+export async function loadConfig(root) {
+    let text;
+    try {
+        text = await readFile(path.join(root, CONFIG_PATH), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    return parseConfig(text);
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,12 @@
+/** Найденное проверкой нарушение. */
+export interface Diagnostic {
+    /** Путь от корня проекта, через `/`. */
+    file: string;
+    /** Номер строки с 1; нет — нарушение относится к файлу целиком. */
+    line?: number;
+    message: string;
+}
+export declare function formatDiagnostic(d: Diagnostic): string;
+/** Ошибка вызова или конфигурации: код выхода 2, а не 1. */
+export declare class UsageError extends Error {
+}

package/dist/diagnostics.js

@@ -0,0 +1,6 @@
+export function formatDiagnostic(d) {
+    return d.line === undefined ? `${d.file}: ${d.message}` : `${d.file}:${d.line}: ${d.message}`;
+}
+/** Ошибка вызова или конфигурации: код выхода 2, а не 1. */
+export class UsageError extends Error {
+}

package/dist/frontmatter.d.ts

@@ -0,0 +1,8 @@
+export type Frontmatter = Record<string, unknown>;
+/** Приводит переводы строк к LF: результат не зависит от core.autocrlf. */
+export declare function normalizeEol(text: string): string;
+/**
+ * Достаёт YAML-frontmatter: блок между `---` в первой строке и следующей
+ * строкой `---`. Нет блока — `null`. Невалидный YAML — исключение.
+ */
+export declare function parseFrontmatter(text: string): Frontmatter | null;

package/dist/frontmatter.js

@@ -0,0 +1,24 @@
+import { parse } from 'yaml';
+/** Приводит переводы строк к LF: результат не зависит от core.autocrlf. */
+export function normalizeEol(text) {
+    return text.replace(/\r\n?/g, '\n');
+}
+/**
+ * Достаёт YAML-frontmatter: блок между `---` в первой строке и следующей
+ * строкой `---`. Нет блока — `null`. Невалидный YAML — исключение.
+ */
+export function parseFrontmatter(text) {
+    const lines = normalizeEol(text).split('\n');
+    if (lines[0] !== '---')
+        return null;
+    const end = lines.indexOf('---', 1);
+    if (end === -1)
+        return null;
+    const data = parse(lines.slice(1, end).join('\n'));
+    if (data === null || data === undefined)
+        return {};
+    if (typeof data !== 'object' || Array.isArray(data)) {
+        throw new Error('frontmatter должен быть YAML-объектом');
+    }
+    return data;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { normalizeEol, parseFrontmatter, type Frontmatter } from './frontmatter.ts';
+export { collectEntries, diffIndex, INDEX_PATH, renderIndex, sha256, stripTimestamp, type CollectResult, type FeatureInfo, type IndexDiff, type IndexEntry, type RenderOptions, } from './prompt-index.ts';
+export { checkChangelog, lintChangelog, CHANGELOG_PATH } from './checks/changelog.ts';
+export { CONFIG_PATH, DEFAULT_CHANGELOG, loadConfig, parseConfig, type ChangelogOptions, type HarnessConfig, } from './config.ts';
+export { formatDiagnostic, UsageError, type Diagnostic } from './diagnostics.ts';
+export { buildContextIndex, checkContextIndex, CONTEXT_INDEX_PATH, type ContextIndexResult } from './checks/context-index.ts';
+export { applyActions, checkAdapters, computeSync, KNOWN_ADAPTERS, type Action, type AdapterName, type SyncResult, } from './adapters/sync.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { normalizeEol, parseFrontmatter } from './frontmatter.js';
+export { collectEntries, diffIndex, INDEX_PATH, renderIndex, sha256, stripTimestamp, } from './prompt-index.js';
+export { checkChangelog, lintChangelog, CHANGELOG_PATH } from './checks/changelog.js';
+export { CONFIG_PATH, DEFAULT_CHANGELOG, loadConfig, parseConfig, } from './config.js';
+export { formatDiagnostic, UsageError } from './diagnostics.js';
+export { buildContextIndex, checkContextIndex, CONTEXT_INDEX_PATH } from './checks/context-index.js';
+export { applyActions, checkAdapters, computeSync, KNOWN_ADAPTERS, } from './adapters/sync.js';

package/dist/prompt-index.d.ts

@@ -0,0 +1,47 @@
+export declare const INDEX_PATH = "prompts/index.yml";
+export interface IndexEntry {
+    kind: string;
+    key: string;
+    /** Путь от корня репозитория, всегда через `/`. */
+    path: string;
+    sha256: string;
+    applicableTo: string[];
+    patterns: string[];
+    title?: string;
+    /** Блок `feature` модуля-возможности — то, что нужно для чеклиста. */
+    feature?: FeatureInfo;
+    /** Файлы skill: `path` от корня репозитория и SHA-256 каждого. */
+    files?: {
+        path: string;
+        sha256: string;
+    }[];
+}
+export interface FeatureInfo {
+    summary: string;
+    default: boolean;
+    requires: string[];
+    conflicts: string[];
+}
+export interface CollectResult {
+    entries: IndexEntry[];
+    /** Файлы без `key` / `kind` во frontmatter (README и т.п.). */
+    skipped: string[];
+}
+/** SHA-256 от содержимого с LF, чтобы хэш совпадал на любой ОС. */
+export declare function sha256(content: string): string;
+export declare function collectEntries(root: string): Promise<CollectResult>;
+export interface RenderOptions {
+    /** Префикс raw-URL без завершающего `/`. */
+    rawBase: string;
+    generatedAt: Date;
+}
+export declare function renderIndex(entries: IndexEntry[], options: RenderOptions): string;
+/** Убирает строку `generated_at`: она меняется на каждой сборке. */
+export declare function stripTimestamp(index: string): string;
+export interface IndexDiff {
+    line: number;
+    expected: string | undefined;
+    actual: string | undefined;
+}
+/** Построчное сравнение без учёта `generated_at`; пустой массив — индексы совпадают. */
+export declare function diffIndex(expected: string, actual: string): IndexDiff[];

package/dist/prompt-index.js

@@ -0,0 +1,260 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { stringify } from 'yaml';
+import { normalizeEol, parseFrontmatter } from './frontmatter.js';
+export const INDEX_PATH = 'prompts/index.yml';
+const SOURCE_DIRS = ['prompts', 'patterns'];
+const HEADER = '# generated by harness index build — do not edit manually';
+const SKILLS_DIR = 'skills';
+const AGENTS_DIR = 'agents';
+const GROUPS = [
+    { kind: 'contract', label: 'contracts' },
+    { kind: 'pattern', label: 'patterns' },
+    { kind: 'module', label: 'modules' },
+    { kind: 'skill', label: 'skills' },
+    { kind: 'agent', label: 'agents' },
+    { kind: 'prompt', label: 'prompts' },
+];
+/** Поля `feature` во frontmatter; `asks` читается из самого модуля, в индекс не идёт. */
+const FEATURE_KEYS = ['summary', 'default', 'requires', 'conflicts', 'asks'];
+/** SHA-256 от содержимого с LF, чтобы хэш совпадал на любой ОС. */
+export function sha256(content) {
+    return createHash('sha256').update(normalizeEol(content), 'utf8').digest('hex');
+}
+function stringList(value, field, file) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+        throw new Error(`${file}: поле ${field} должно быть списком строк`);
+    }
+    return value;
+}
+function oneLine(value, field, file) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || value.trim() === '' || value.trim().includes('\n')) {
+        throw new Error(`${file}: поле ${field} должно быть непустой строкой в одну строку`);
+    }
+    return value.trim();
+}
+function parseFeature(value, kind, file) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (kind !== 'module')
+        throw new Error(`${file}: feature допустим только у kind: module`);
+    if (typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${file}: feature должно быть объектом`);
+    const feature = value;
+    const extra = Object.keys(feature).filter((k) => !FEATURE_KEYS.includes(k));
+    if (extra.length > 0)
+        throw new Error(`${file}: неизвестные поля feature: ${extra.join(', ')}`);
+    const summary = oneLine(feature['summary'], 'feature.summary', file);
+    if (summary === undefined)
+        throw new Error(`${file}: нет feature.summary`);
+    if (typeof feature['default'] !== 'boolean')
+        throw new Error(`${file}: feature.default должно быть true или false`);
+    return {
+        summary,
+        default: feature['default'],
+        requires: stringList(feature['requires'], 'feature.requires', file),
+        conflicts: stringList(feature['conflicts'], 'feature.conflicts', file),
+    };
+}
+/** requires / conflicts ссылаются только на модули из индекса и не на себя. */
+function checkFeatureRefs(entries) {
+    const modules = new Set(entries.filter((e) => e.kind === 'module').map((e) => e.key));
+    for (const e of entries) {
+        if (e.feature === undefined)
+            continue;
+        for (const field of ['requires', 'conflicts']) {
+            for (const ref of e.feature[field]) {
+                if (ref === e.key)
+                    throw new Error(`${e.path}: feature.${field} ссылается на сам модуль`);
+                if (!modules.has(ref))
+                    throw new Error(`${e.path}: feature.${field}: модуля «${ref}» нет в индексе`);
+            }
+        }
+    }
+}
+function compareBytes(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+async function listMarkdown(root) {
+    const files = [];
+    for (const dir of SOURCE_DIRS) {
+        let names;
+        try {
+            names = await readdir(path.join(root, dir), { recursive: true });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        for (const name of names) {
+            if (name.endsWith('.md'))
+                files.push(`${dir}/${name.split(path.sep).join('/')}`);
+        }
+    }
+    return files.sort(compareBytes);
+}
+export async function collectEntries(root) {
+    const entries = [];
+    const skipped = [];
+    for (const file of await listMarkdown(root)) {
+        const content = await readFile(path.join(root, file), 'utf8');
+        let fm;
+        try {
+            fm = parseFrontmatter(content);
+        }
+        catch (error) {
+            throw new Error(`${file}: ${error.message}`, { cause: error });
+        }
+        const key = fm?.['key'];
+        const kind = fm?.['kind'];
+        if (typeof key !== 'string' || key === '' || typeof kind !== 'string' || kind === '') {
+            skipped.push(file);
+            continue;
+        }
+        const entry = {
+            kind,
+            key,
+            path: file,
+            sha256: sha256(content),
+            applicableTo: stringList(fm?.['applicable_to'], 'applicable_to', file),
+            patterns: stringList(fm?.['patterns'], 'patterns', file),
+        };
+        const title = oneLine(fm?.['title'], 'title', file);
+        if (title !== undefined)
+            entry.title = title;
+        const feature = parseFeature(fm?.['feature'], kind, file);
+        if (feature !== undefined)
+            entry.feature = feature;
+        entries.push(entry);
+    }
+    entries.push(...(await collectSkills(root)), ...(await collectAgents(root)));
+    checkFeatureRefs(entries);
+    return { entries, skipped };
+}
+async function listNames(abs) {
+    try {
+        return (await readdir(abs)).sort(compareBytes);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+/** name во frontmatter совпадает с именем; description — однострочный title записи. */
+function nameAndTitle(content, expected, file) {
+    let fm;
+    try {
+        fm = parseFrontmatter(content);
+    }
+    catch (error) {
+        throw new Error(`${file}: ${error.message}`, { cause: error });
+    }
+    if (fm?.['name'] !== expected)
+        throw new Error(`${file}: name должно совпадать с именем «${expected}»`);
+    const title = oneLine(fm['description'], 'description', file);
+    if (title === undefined)
+        throw new Error(`${file}: нет description`);
+    return title;
+}
+/**
+ * Skill — каталог `skills/<name>/` с `SKILL.md` по стандарту Agent Skills.
+ * SHA-256 skill — от строк `<sha256 файла>  <путь внутри skill>`, по одной
+ * на файл, в порядке путей: меняется при правке любого файла.
+ */
+async function collectSkills(root) {
+    const entries = [];
+    for (const name of await listNames(path.join(root, SKILLS_DIR))) {
+        const dir = `${SKILLS_DIR}/${name}`;
+        const rels = (await readdir(path.join(root, dir), { recursive: true, withFileTypes: true }))
+            .filter((e) => e.isFile())
+            .map((e) => path.relative(path.join(root, dir), path.join(e.parentPath, e.name)).split(path.sep).join('/'))
+            .sort(compareBytes);
+        if (!rels.includes('SKILL.md'))
+            throw new Error(`${dir}: нет SKILL.md`);
+        const files = [];
+        let title = '';
+        for (const rel of rels) {
+            const content = await readFile(path.join(root, dir, rel), 'utf8');
+            if (rel === 'SKILL.md')
+                title = nameAndTitle(content, name, `${dir}/SKILL.md`);
+            files.push({ path: `${dir}/${rel}`, sha256: sha256(content) });
+        }
+        const manifest = files.map((f, i) => `${f.sha256}  ${rels[i] ?? ''}\n`).join('');
+        entries.push({ kind: 'skill', key: name, path: dir, sha256: sha256(manifest), applicableTo: [], patterns: [], title, files });
+    }
+    return entries;
+}
+/** Субагент — `agents/<name>.md`: frontmatter name, description, skills, tools + инструкция. */
+async function collectAgents(root) {
+    const entries = [];
+    for (const entry of await listNames(path.join(root, AGENTS_DIR))) {
+        if (!entry.endsWith('.md'))
+            continue;
+        const file = `${AGENTS_DIR}/${entry}`;
+        const content = await readFile(path.join(root, file), 'utf8');
+        const title = nameAndTitle(content, entry.slice(0, -3), file);
+        entries.push({ kind: 'agent', key: entry.slice(0, -3), path: file, sha256: sha256(content), applicableTo: [], patterns: [], title });
+    }
+    return entries;
+}
+const flowList = (items) => `[${items.join(', ')}]`;
+/** Скаляр через YAML-сериализатор: кавычки появятся, только если без них YAML сломается. */
+const scalar = (value) => stringify(value, { lineWidth: 0 }).trimEnd();
+export function renderIndex(entries, options) {
+    const timestamp = options.generatedAt.toISOString().replace(/\.\d{3}Z$/, 'Z');
+    const lines = [HEADER, `generated_at: ${timestamp}`];
+    for (const group of GROUPS) {
+        const items = entries.filter((e) => e.kind === group.kind);
+        lines.push('');
+        if (items.length === 0) {
+            lines.push(`${group.label}: []`);
+            continue;
+        }
+        lines.push(`${group.label}:`);
+        for (const e of items) {
+            lines.push(`  - key: ${e.key}`, ...(e.title === undefined ? [] : [`    title: ${scalar(e.title)}`]), `    path: ${e.path}`, 
+            // У skill raw нет: это каталог, raw — у каждого файла.
+            ...(e.files === undefined ? [`    raw: ${options.rawBase}/${e.path}`] : []), `    sha256: ${e.sha256}`);
+            if (e.files !== undefined) {
+                lines.push('    files:');
+                for (const f of e.files) {
+                    lines.push(`      - path: ${f.path}`, `        raw: ${options.rawBase}/${f.path}`, `        sha256: ${f.sha256}`);
+                }
+            }
+            if (e.patterns.length > 0)
+                lines.push(`    patterns: ${flowList(e.patterns)}`);
+            if (e.kind === 'module' && e.applicableTo.length > 0) {
+                lines.push(`    applicable_to: ${flowList(e.applicableTo)}`);
+            }
+            if (e.feature !== undefined) {
+                lines.push('    feature:', `      summary: ${scalar(e.feature.summary)}`, `      default: ${scalar(e.feature.default)}`, `      requires: ${flowList(e.feature.requires)}`, `      conflicts: ${flowList(e.feature.conflicts)}`);
+            }
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+/** Убирает строку `generated_at`: она меняется на каждой сборке. */
+export function stripTimestamp(index) {
+    return normalizeEol(index)
+        .split('\n')
+        .filter((line) => !line.startsWith('generated_at:'))
+        .join('\n');
+}
+/** Построчное сравнение без учёта `generated_at`; пустой массив — индексы совпадают. */
+export function diffIndex(expected, actual) {
+    const exp = stripTimestamp(expected).split('\n');
+    const act = stripTimestamp(actual).split('\n');
+    const diffs = [];
+    for (let i = 0; i < Math.max(exp.length, act.length); i++) {
+        if (exp[i] !== act[i])
+            diffs.push({ line: i + 1, expected: exp[i], actual: act[i] });
+    }
+    return diffs;
+}

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@shahimat/harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Harness для проектов на контрактах ai-prompts: генераторы и проверки",
+  "license": "MIT",
+  "author": "Gevorg Nakhapetyan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Shahimat/ai-prompts.git",
+    "directory": "harness/packages/harness"
+  },
+  "homepage": "https://github.com/Shahimat/ai-prompts/tree/main/harness/packages/harness#readme",
+  "bugs": {
+    "url": "https://github.com/Shahimat/ai-prompts/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "agents-md",
+    "claude-code",
+    "codex",
+    "docs-as-code",
+    "changelog",
+    "lint"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "harness": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json && node -e \"require('node:fs').chmodSync('dist/bin.js', 0o755)\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.2",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}