@vodmal/vdx-cli 0.2.0

package/src/predicates.ts

@@ -0,0 +1,160 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {
+  Ctx,
+  fileExists,
+  readText,
+  readJson,
+  listAllTasks,
+  isPackagePresent,
+  expandPaths,
+  readTsconfig,
+  readStructured,
+  resolveConfigPath,
+} from './facts.ts';
+
+type Args = Record<string, any>;
+type PredicateFn = (args: Args, ctx: Ctx) => boolean;
+
+const warned = new Set<string>();
+function warnOnce(name: string) {
+  if (warned.has(name)) return;
+  warned.add(name);
+  process.stderr.write(`warning: predicate "${name}" not implemented in v0.1 — returning false\n`);
+}
+
+export const REGISTRY: Record<string, PredicateFn> = {
+  always_true: () => true,
+
+  has_task: (args, ctx) => listAllTasks(ctx).has(String(args.task)),
+
+  has_task_matching: (args, ctx) => {
+    try {
+      const re = new RegExp(String(args.pattern));
+      for (const t of listAllTasks(ctx)) if (re.test(t)) return true;
+    } catch {
+      return false;
+    }
+    return false;
+  },
+
+  has_file: (args, ctx) => fileExists(ctx, String(args.path)),
+
+  file_contains: (args, ctx) => {
+    const paths: string[] = Array.isArray(args.paths) ? args.paths : [String(args.path)];
+    const expanded = expandPaths(paths, ctx);
+    let re: RegExp;
+    try {
+      re = new RegExp(String(args.pattern));
+    } catch {
+      return false;
+    }
+    for (const p of expanded) {
+      const text = readText(ctx, p);
+      if (text !== null && re.test(text)) return true;
+    }
+    return false;
+  },
+
+  package_present: (args, ctx) => {
+    if (typeof args === 'string') return isPackagePresent(args, 'any', ctx);
+    return isPackagePresent(String(args.name), String(args.ecosystem ?? 'any'), ctx);
+  },
+
+  tsc_flag: (args, ctx) => {
+    const cfg = readTsconfig(ctx);
+    const co = cfg?.compilerOptions;
+    if (!co) return false;
+    const target = args.equals === undefined ? true : args.equals;
+    return co[String(args.name)] === target;
+  },
+
+  phpstan_level_at_least: (args, ctx) => {
+    const text =
+      readText(ctx, 'phpstan.neon') ||
+      readText(ctx, 'phpstan.dist.neon') ||
+      readText(ctx, 'phpstan.neon.dist');
+    if (!text) return false;
+    const m = text.match(/^\s*level:\s*(\d+|max)/m);
+    if (!m || !m[1]) return false;
+    const lvl = m[1] === 'max' ? 9 : parseInt(m[1], 10);
+    return lvl >= Number(args.n);
+  },
+
+  gh_workflow_blocks_pr: (args, ctx) => {
+    const dir = path.join(ctx.projectRoot, '.github', 'workflows');
+    if (!fs.existsSync(dir)) return false;
+    const wanted = args.check_name ? String(args.check_name) : null;
+    try {
+      for (const f of fs.readdirSync(dir)) {
+        if (!/\.ya?ml$/.test(f)) continue;
+        const text = readText(ctx, path.join('.github', 'workflows', f));
+        if (!text) continue;
+        if (!/on:[\s\S]*?(pull_request|pull-request)/.test(text)) continue;
+        if (wanted === null) return true;
+        if (text.includes(wanted)) return true;
+      }
+    } catch {
+      /* ignore */
+    }
+    return false;
+  },
+
+  git_hook_installed: (args, ctx) => {
+    const hook = String(args.hook);
+    if (fileExists(ctx, `.husky/${hook}`)) return true;
+    for (const f of ['.lefthook.yml', 'lefthook.yml']) {
+      const text = readText(ctx, f);
+      if (text && new RegExp(`^${hook}:`, 'm').test(text)) return true;
+    }
+    const composer = readJson(ctx, 'composer.json');
+    if (composer?.extra?.hooks?.[hook]) return true;
+    return false;
+  },
+
+  config_value: (args, ctx) => {
+    const filePath = String(args.path ?? '');
+    const jsonpath = String(args.jsonpath ?? '');
+    if (!filePath || !jsonpath) return false;
+    const data = readStructured(ctx, filePath);
+    if (data === null || data === undefined) return false;
+    const value = resolveConfigPath(data, jsonpath);
+
+    // Operator resolution: explicit `op`, otherwise infer from arg shape.
+    let op = args.op ? String(args.op) : null;
+    if (!op) {
+      if (args.equals !== undefined) op = 'equals';
+      else if (args.gte !== undefined) op = 'gte';
+      else if (args.pattern !== undefined) op = 'matches';
+      else op = 'present';
+    }
+
+    switch (op) {
+      case 'present':
+        return value !== undefined && value !== null;
+      case 'equals':
+        return value === args.equals;
+      case 'gte': {
+        const v = typeof value === 'number' ? value : Number(value);
+        const target = Number(args.gte);
+        if (Number.isNaN(v) || Number.isNaN(target)) return false;
+        return v >= target;
+      }
+      case 'matches': {
+        if (typeof value !== 'string') return false;
+        try {
+          return new RegExp(String(args.pattern)).test(value);
+        } catch {
+          return false;
+        }
+      }
+      default:
+        process.stderr.write(`warning: config_value: unknown op "${op}"\n`);
+        return false;
+    }
+  },
+  command_succeeds: () => {
+    warnOnce('command_succeeds');
+    return false;
+  },
+};

package/src/report.ts

@@ -0,0 +1,49 @@
+import type { AuditResult } from './audit.ts';
+
+const SYMBOL: Record<string, string> = {
+  aligned: '✅',
+  gap: '⚠️ ',
+  over: '🔵',
+  excluded: '➖',
+};
+
+export function reportMarkdown(r: AuditResult): string {
+  const lines: string[] = [];
+  lines.push(`# vdx audit report`);
+  lines.push('');
+  lines.push(`- **Baseline**: \`${r.baseline}\``);
+  lines.push(`- **Stack**: \`${r.stack}\``);
+  lines.push(`- **Achieved level**: **${r.achieved_level}**`);
+  lines.push('');
+  lines.push(`## Axes`);
+  lines.push('');
+  lines.push(`| Axis | Class | Achieved | Target | Drift |`);
+  lines.push(`|------|:-----:|:--------:|:------:|:------|`);
+  for (const a of r.per_axis) {
+    const cls = a.class === 'critical' ? '**C**' : 's';
+    const drift = a.suppressed ? '— suppressed —' : `${SYMBOL[a.drift_kind] ?? ''} ${a.drift_kind}`;
+    lines.push(`| \`${a.axis_id}\` | ${cls} | ${a.achieved} | ${a.target} | ${drift} |`);
+  }
+
+  if (r.overrides.length > 0) {
+    lines.push('');
+    lines.push(`## Overrides`);
+    for (const o of r.overrides) {
+      const kind = o.suppress ? 'suppress' : `target=${o.target}`;
+      const until = o.until ? `, until ${o.until}` : '';
+      lines.push(`- \`${o.axis}\` — ${kind}, reason: ${o.reason}${until}`);
+    }
+  }
+
+  if (r.expired_overrides.length > 0) {
+    lines.push('');
+    lines.push(`## ⚠️  Expired overrides`);
+    for (const x of r.expired_overrides) lines.push(`- \`${x}\``);
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+export function reportJson(r: AuditResult): string {
+  return JSON.stringify(r, null, 2);
+}

package/src/rubric.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import YAML from 'js-yaml';
+
+export type LevelName = 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
+export type AxisClass = 'critical' | 'supporting';
+export type Storage = 'level' | 'flags';
+
+// Predicate структура динамическая — оставляем any для дешёвого парсинга
+// со сахаром. Валидация — отдельная история v0.2.
+export type Predicate = unknown;
+
+export interface Flag {
+  id: string;
+  weight: number;
+  predicate: Predicate;
+}
+
+export interface StackImpl {
+  flags?: Flag[];
+  level_thresholds?: Partial<Record<LevelName, number>>;
+}
+
+export interface Axis {
+  id: string;
+  class: AxisClass;
+  description?: string;
+  storage: Storage;
+  default_target: LevelName;
+  fact_sources?: string[];
+  levels?: Partial<Record<LevelName, { requires: Predicate }>>;
+  stack_implementations?: Record<string, StackImpl>;
+  applies_to?: string[];
+}
+
+export interface Rubric {
+  schema_version: string;
+  metadata: {
+    name: string;
+    version: string;
+    owner?: string;
+    description?: string;
+    homepage?: string;
+  };
+  scoring: {
+    formula: string;
+    supporting_threshold: number;
+  };
+  levels: Record<LevelName, { name: string; description: string }>;
+  axes: Axis[];
+}
+
+export function loadRubric(yamlPath: string): Rubric {
+  const text = fs.readFileSync(yamlPath, 'utf8');
+  const data = YAML.load(text) as Rubric;
+  if (!data || !data.schema_version || !data.axes) {
+    throw new Error(`Invalid rubric at ${yamlPath}: missing schema_version or axes`);
+  }
+  // нормализуем default_target (если кто-то напишет "L4" со spaces)
+  for (const ax of data.axes) {
+    ax.default_target = (ax.default_target ?? 'L4') as LevelName;
+    ax.storage = (ax.storage ?? 'level') as Storage;
+  }
+  return data;
+}

package/src/scoring.ts

@@ -0,0 +1,79 @@
+import type { Axis, LevelName, Rubric } from './rubric.ts';
+import type { Ctx } from './facts.ts';
+import { evalPredicate } from './evaluator.ts';
+
+const LEVELS: LevelName[] = ['L1', 'L2', 'L3', 'L4'];
+
+function levelToInt(L: LevelName): number {
+  return parseInt(L.slice(1), 10);
+}
+
+export interface AxisResult {
+  axis_id: string;
+  class: 'critical' | 'supporting';
+  achieved: LevelName;
+  target: LevelName;
+  drift_kind: 'aligned' | 'gap' | 'over' | 'excluded';
+}
+
+export function evalAxis(axis: Axis, ctx: Ctx): LevelName {
+  if (axis.storage === 'flags') return evalAxisFlags(axis, ctx);
+  return evalAxisLevels(axis, ctx);
+}
+
+function evalAxisLevels(axis: Axis, ctx: Ctx): LevelName {
+  let achieved: LevelName = 'L0';
+  for (const L of LEVELS) {
+    const lvl = axis.levels?.[L];
+    if (!lvl) break;
+    if (evalPredicate(lvl.requires, ctx)) {
+      achieved = L;
+    } else {
+      break; // delta-style: discontinuity → stop ascent
+    }
+  }
+  return achieved;
+}
+
+function evalAxisFlags(axis: Axis, ctx: Ctx): LevelName {
+  const impl = axis.stack_implementations?.[ctx.stack];
+  if (!impl?.flags || !impl.level_thresholds) return 'L0';
+  let implemented = 0;
+  let total = 0;
+  for (const f of impl.flags) {
+    total += f.weight;
+    if (evalPredicate(f.predicate, ctx)) implemented += f.weight;
+  }
+  const ratio = total === 0 ? 0 : implemented / total;
+  let achieved: LevelName = 'L0';
+  for (const L of LEVELS) {
+    const th = impl.level_thresholds[L];
+    if (th === undefined) continue;
+    if (ratio >= th) achieved = L;
+    else break;
+  }
+  return achieved;
+}
+
+export function projectLevel(
+  results: AxisResult[],
+  rubric: Rubric,
+  suppressed: Set<string>,
+): LevelName {
+  const supportingThreshold = rubric.scoring.supporting_threshold ?? 0.8;
+  const visible = results.filter(
+    (r) => !suppressed.has(r.axis_id) && r.drift_kind !== 'excluded',
+  );
+  const critical = visible.filter((r) => r.class === 'critical');
+  const supporting = visible.filter((r) => r.class === 'supporting');
+
+  for (const L of [...LEVELS].reverse()) {
+    const Lint = levelToInt(L);
+    const critOk = critical.every((r) => levelToInt(r.achieved) >= Lint);
+    if (!critOk) continue;
+    if (supporting.length === 0) return L;
+    const supRatio = supporting.filter((r) => levelToInt(r.achieved) >= Lint).length / supporting.length;
+    if (supRatio >= supportingThreshold) return L;
+  }
+  return 'L0';
+}