import * as fs from 'node:fs'; import * as path from 'node:path'; import type { Rubric, LevelName } from './rubric.ts'; import { findSubPackages, stackForDir, type Ctx } from './facts.ts'; import { evalPredicate } from './evaluator.ts'; import type { Override, VdxManifest } from './manifest.ts'; import { evalAxisDetailed, projectLevel, type AxisResult } from './scoring.ts'; import { cloneCheck } from './clone-checks.ts'; function levelToInt(L: LevelName): number { return parseInt(L.slice(1), 10); } export interface AuditResult { baseline: string; stack: string; achieved_level: LevelName; per_axis: Array; overrides: Override[]; expired_overrides: string[]; primary_subpackage?: string; } /** * Резолвит ctx для stack-specific осей (с `applies_to`). Источник subpackage: * 1. manifest.primary_subpackage (explicit) — если папка существует. * 2. findSubPackages() auto-detect — только у корня без своего манифеста стека: * ровно один subpackage совпадает с ctx.stack, или он в репо один. Корень со * своим манифестом — сам проект; папка рядом с манифестом — снимок, инструмент * или вендоренное дерево (vorobyev.name 2026-11-11: брался `legacy/`). * 3. fallback на root ctx. * * Возвращает `{ ctx, relPath }` где relPath — относительный путь либо null * (если subpackage не разрезолвился — будем использовать root). Файл, которого * нет в subpackage, ищется в корне (`fallbackRoot`): `.github/` и `.gitignore` * у репо одни. */ function resolveSubpackageCtx(ctx: Ctx, manifest: VdxManifest | null): { ctx: Ctx; relPath: string | null } { let relPath: string | null = null; let subpackageStack: string | null = null; if (manifest?.primary_subpackage) { const p = manifest.primary_subpackage; const abs = path.join(ctx.projectRoot, p); if (fs.existsSync(abs)) { relPath = p; subpackageStack = stackForDir(abs); } else { process.stderr.write(`warning: primary_subpackage "${p}" does not exist — falling back to root\n`); } } else if (stackForDir(ctx.projectRoot) === null) { const subs = findSubPackages(ctx.projectRoot); const matching = subs.filter((s) => s.stack === ctx.stack); if (matching.length === 1) { relPath = matching[0]!.relPath; subpackageStack = matching[0]!.stack; } else if (matching.length === 0 && subs.length === 1) { // O33: single sub-package with a stack different from ctx.stack — // adopt it so applies_to-axes for that stack can evaluate. relPath = subs[0]!.relPath; subpackageStack = subs[0]!.stack; } } if (!relPath) return { ctx, relPath: null }; return { ctx: { projectRoot: path.join(ctx.projectRoot, relPath), stack: subpackageStack ?? ctx.stack, cache: new Map(), fallbackRoot: ctx.projectRoot, }, relPath, }; } /** * Ctx осей без `applies_to`. Корень мета-репо (без своего манифеста стека) * дочитывает недостающие файлы из subpackage: `engines` в `cli/package.json` * — тоже про воспроизводимость всего репо. У корня со своим манифестом * подстановки нет. */ function rootAxisCtx(ctx: Ctx, subpackage: Ctx, relPath: string | null): Ctx { if (!relPath || stackForDir(ctx.projectRoot) !== null) return ctx; return { ...ctx, cache: new Map(), fallbackRoot: subpackage.projectRoot }; } export function audit( rubric: Rubric, ctx: Ctx, overrides: Override[], baselineRef: string, manifest: VdxManifest | null = null, ): AuditResult { const suppressed = new Set(); const overrideByAxis = new Map(); const expired: string[] = []; const today = new Date().toISOString().slice(0, 10); for (const ov of overrides) { overrideByAxis.set(ov.axis, ov); if (ov.suppress) suppressed.add(ov.axis); if (ov.until && ov.until < today) expired.push(ov.axis); } const { ctx: subpackageCtx, relPath: subpackagePath } = resolveSubpackageCtx(ctx, manifest); const rootCtx = rootAxisCtx(ctx, subpackageCtx, subpackagePath); const perAxis: AuditResult['per_axis'] = []; for (const axis of rubric.axes) { if (suppressed.has(axis.id)) { perAxis.push({ axis_id: axis.id, class: axis.class, achieved: 'L0', target: axis.default_target, drift_kind: 'aligned', suppressed: true, }); continue; } const evalCtx = axis.applies_to ? subpackageCtx : rootCtx; if (axis.applies_to && !axis.applies_to.includes(evalCtx.stack)) { perAxis.push({ axis_id: axis.id, class: axis.class, achieved: 'L0', target: axis.default_target, drift_kind: 'excluded', }); continue; } if (axis.applies_when && !evalPredicate(axis.applies_when, evalCtx)) { perAxis.push({ axis_id: axis.id, class: axis.class, achieved: 'L0', target: axis.default_target, drift_kind: 'excluded', }); continue; } const { achieved, not_required, unknown, not_met } = evalAxisDetailed(axis, evalCtx); const ov = overrideByAxis.get(axis.id); const target = (ov?.target as LevelName) ?? axis.default_target; const drift: 'aligned' | 'gap' | 'over' = levelToInt(achieved) === levelToInt(target) ? 'aligned' : levelToInt(achieved) < levelToInt(target) ? 'gap' : 'over'; const entry: AuditResult['per_axis'][number] = { axis_id: axis.id, class: axis.class, achieved, target, drift_kind: drift, }; if (ov?.target) entry.override_target = ov.target as LevelName; if (not_required) entry.not_required = not_required; if (unknown) entry.unknown = unknown; if (not_met) entry.not_met = not_met; if (axis.clone_check) { const c = cloneCheck(axis.clone_check, ctx.projectRoot); if (c && c.status !== 'ok') entry.note = c.remedy ? `${c.message} → ${c.remedy}` : c.message; } perAxis.push(entry); } const overall = projectLevel(perAxis, rubric, suppressed); const result: AuditResult = { baseline: baselineRef, stack: ctx.stack, achieved_level: overall, per_axis: perAxis, overrides, expired_overrides: expired, }; if (subpackagePath) result.primary_subpackage = subpackagePath; return result; }