@vodmal/vdx-cli 0.25.0 → 0.27.0

package/src/publish.ts

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import type { AuditResult } from './audit.ts';
 import { stackForDir, type Ctx } from './facts.ts';
+import { at, dict, errorMessage, stderrOf, str } from './narrow.ts';
 
 export type BumpKind = 'patch' | 'minor' | 'major';
 
@@ -115,7 +116,7 @@ const runGit: GitRunner = (args, cwd) =>
  * since the last fetch; nothing is fetched.
  */
 export function planPush(projectRoot: string, enabled: boolean, git: GitRunner = runGit): PushPlan {
-  let upstream: string | null = null;
+  let upstream: string | null;
   try {
     upstream = git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], projectRoot).trim() || null;
   } catch {
@@ -144,10 +145,10 @@ function fetchPublishedVersion(packageName: string, npm: NpmRunner): string | nu
   try {
     const out = npm(['view', packageName, 'version']);
     return out.trim() || null;
-  } catch (e: any) {
-    const stderr = String(e?.stderr ?? e?.message ?? '');
+  } catch (e) {
+    const stderr = stderrOf(e);
     if (stderr.includes('E404') || stderr.includes('404 Not Found')) return null;
-    throw new Error(`npm view failed: ${stderr.split('\n')[0] ?? stderr}`);
+    throw new Error(`npm view failed: ${stderr.split('\n')[0] ?? stderr}`, { cause: e });
   }
 }
 
@@ -155,12 +156,10 @@ function fetchPublishedVersion(packageName: string, npm: NpmRunner): string | nu
  * The registry `npm publish` sends this package to, when it is not npm's
  * default: `publishConfig.registry`, else the scope's registry from npm config.
  */
-export function publishRegistry(
-  pkg: { name?: string; publishConfig?: { registry?: string } },
-  npm: NpmRunner,
-): string | null {
-  if (pkg.publishConfig?.registry) return pkg.publishConfig.registry;
-  const scope = pkg.name?.match(/^(@[^/]+)\//)?.[1];
+export function publishRegistry(pkg: unknown, npm: NpmRunner): string | null {
+  const registry = str(at(pkg, 'publishConfig', 'registry'));
+  if (registry) return registry;
+  const scope = str(at(pkg, 'name'))?.match(/^(@[^/]+)\//)?.[1];
   if (!scope) return null;
   try {
     const value = npm(['config', 'get', `${scope}:registry`]).trim();
@@ -184,8 +183,8 @@ export function checkNpmAuth(registry: string | null, npm: NpmRunner): Preflight
     const who = npm(registry ? ['whoami', '--registry', registry] : ['whoami']).trim();
     if (who) return { name: 'npm-auth', ok: true, message: `OK (logged in to ${where} as ${who})` };
     return { name: 'npm-auth', ok: false, message: `npm whoami answered nothing for ${where}. Run: ${login}`, fix };
-  } catch (e: any) {
-    const stderr = String(e?.stderr ?? e?.message ?? '');
+  } catch (e) {
+    const stderr = stderrOf(e);
     if (/E401|ENEEDAUTH/.test(stderr)) {
       return {
         name: 'npm-auth',
@@ -268,9 +267,9 @@ export function planPublish(
     throw new Error(`vdx publish: package.json not found at ${pkgJsonPath}`);
   }
 
-  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-  const packageName: string = pkg.name ?? '(unnamed)';
-  const currentVersion: string = pkg.version ?? '0.0.0';
+  const pkg: unknown = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+  const packageName = str(at(pkg, 'name')) ?? '(unnamed)';
+  const currentVersion = str(at(pkg, 'version')) ?? '0.0.0';
   const newVersion = bumpSemver(currentVersion, opts.bump);
 
   const preflight: PreflightCheck[] = [];
@@ -312,8 +311,8 @@ export function planPublish(
   let registryError: string | null = null;
   try {
     published = fetchPublishedVersion(packageName, npm);
-  } catch (e: any) {
-    registryError = e?.message ?? String(e);
+  } catch (e) {
+    registryError = errorMessage(e);
   }
   if (registryError) {
     preflight.push({
@@ -384,7 +383,7 @@ export function preflightFixable(plan: PublishPlan): boolean {
 }
 
 /** Runs a command on this terminal (stdio inherited); throws on a non-zero exit. */
-export type CommandRunner = (cmd: string, args: string[], cwd: string) => void;
+type CommandRunner = (cmd: string, args: string[], cwd: string) => void;
 
 export interface PublishDeps {
   run: CommandRunner;
@@ -416,9 +415,10 @@ export function defaultPublishDeps(): PublishDeps {
 
 /** Set `version` in package-lock.json — the root and its own entry under `packages`. */
 export function bumpLockText(text: string, version: string): string {
-  const lock = JSON.parse(text);
-  lock.version = version;
-  if (lock.packages?.['']) lock.packages[''].version = version;
+  const lock = dict(JSON.parse(text)) ?? {};
+  lock['version'] = version;
+  const self = dict(at(lock, 'packages', ''));
+  if (self) self['version'] = version;
   return JSON.stringify(lock, null, 2) + '\n';
 }
 
@@ -502,8 +502,8 @@ export function executePublish(plan: PublishPlan, deps: PublishDeps = defaultPub
     fs.writeFileSync(file, next(text), 'utf8');
   };
   rewrite(plan.packageJsonPath, (text) => {
-    const pkg = JSON.parse(text);
-    pkg.version = plan.newVersion;
+    const pkg = dict(JSON.parse(text)) ?? {};
+    pkg['version'] = plan.newVersion;
     return JSON.stringify(pkg, null, 2) + '\n';
   });
   if (plan.lockPath) rewrite(plan.lockPath, (text) => bumpLockText(text, plan.newVersion));
@@ -521,11 +521,13 @@ export function executePublish(plan: PublishPlan, deps: PublishDeps = defaultPub
   for (const s of signals) process.on(s, holdOut);
   try {
     deps.run('npm', ['publish'], path.dirname(plan.packageJsonPath));
-  } catch (e: any) {
+  } catch (e) {
     for (const [file, text] of originals) fs.writeFileSync(file, text, 'utf8');
-    const what = e?.signal ? `interrupted (${e.signal})` : `failed (exit ${e?.status ?? '?'})`;
+    const signal = str(at(e, 'signal'));
+    const status = at(e, 'status');
+    const what = signal ? `interrupted (${signal})` : `failed (exit ${typeof status === 'number' ? status : '?'})`;
     deps.log(`✗ npm publish ${what}; reverted ${bumped.map((f) => path.basename(f)).join(' and ')}`);
-    throw new Error(`npm publish ${e?.signal ? 'interrupted' : 'failed'}`);
+    throw new Error(`npm publish ${signal ? 'interrupted' : 'failed'}`, { cause: e });
   } finally {
     for (const s of signals) process.off(s, holdOut);
   }

package/src/rubric.ts

@@ -4,20 +4,20 @@ import { COMBINATORS, predicateNames } from './evaluator.ts';
 import { REGISTRY, REMOVED_IN_0_3 } from './predicates.ts';
 
 export type LevelName = 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
-export type AxisClass = 'critical' | 'supporting';
-export type Storage = 'level' | 'flags';
+type AxisClass = 'critical' | 'supporting';
+type Storage = 'level' | 'flags';
 
 // Predicate структура динамическая — оставляем any для дешёвого парсинга
 // со сахаром. Валидация — отдельная история v0.2.
 export type Predicate = unknown;
 
-export interface Flag {
+interface Flag {
   id: string;
   weight: number;
   predicate: Predicate;
 }
 
-export interface StackImpl {
+interface StackImpl {
   flags?: Flag[];
   level_thresholds?: Partial<Record<LevelName, number>>;
 }
@@ -124,8 +124,8 @@ export function parseRubric(text: string, source: string): Rubric {
   }
   // нормализуем 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;
+    ax.default_target = ax.default_target ?? 'L4';
+    ax.storage = ax.storage ?? 'level';
   }
   if (compareSchema(schema, '0.3')! >= 0) {
     const bad = invalidPredicates(data);

package/src/run.ts

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as TOML from 'smol-toml';
+import { errorMessage } from './narrow.ts';
 
 export const LIFECYCLE_VERBS = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
 export type LifecycleVerb = (typeof LIFECYCLE_VERBS)[number];
@@ -21,8 +22,8 @@ export function resolveLifecycleVerb(projectRoot: string, verb: string): VerbRes
   let parsed: unknown;
   try {
     parsed = TOML.parse(fs.readFileSync(miseTomlPath, 'utf8'));
-  } catch (e: any) {
-    return { ok: false, reason: 'parse-error', detail: e?.message ?? String(e) };
+  } catch (e) {
+    return { ok: false, reason: 'parse-error', detail: errorMessage(e) };
   }
   const tasks = (parsed as { tasks?: Record<string, unknown> })?.tasks;
   if (!tasks || typeof tasks !== 'object' || !(verb in tasks)) {

package/src/vocabulary.ts

@@ -5,8 +5,9 @@
  * predicates (what a hook runs), so both read "the project's task" the same way.
  */
 import { listAllTasks, readJson, readToml, type Ctx } from './facts.ts';
+import { at, dict, list } from './narrow.ts';
 
-export const LIFECYCLE_VOCABULARY = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
+const LIFECYCLE_VOCABULARY = ['up', 'down', 'build', 'test', 'check', 'fix'] as const;
 
 /** npm-family options that take a value; their value is not the script name. */
 const VALUE_OPTIONS = new Set(['--prefix', '-C', '--dir', '-w', '--workspace', '--filter', '--cwd']);
@@ -97,13 +98,11 @@ export function isVocabularyTask(name: string, words: readonly string[] = ['test
 }
 
 /** Tasks a task's definition calls: composer `@refs`, `npm run X` inside a script, mise `depends`/`run`. */
-export function taskChildren(ctx: Ctx, name: string): string[] {
+function taskChildren(ctx: Ctx, name: string): string[] {
   const out: string[] = [];
-  const composer = readJson(ctx, 'composer.json');
-  const entry = composer?.scripts?.[name];
+  const entry = at(readJson(ctx, 'composer.json'), 'scripts', name);
   if (entry !== undefined) {
-    const list = Array.isArray(entry) ? entry : [entry];
-    for (const e of list) {
+    for (const e of Array.isArray(entry) ? (entry as unknown[]) : [entry]) {
       if (typeof e !== 'string') continue;
       if (e.startsWith('@')) {
         const [ref, ...rest] = e.slice(1).trim().split(/\s+/);
@@ -114,15 +113,12 @@ export function taskChildren(ctx: Ctx, name: string): string[] {
       }
     }
   }
-  const pkg = readJson(ctx, 'package.json');
-  const script = pkg?.scripts?.[name];
+  const script = at(readJson(ctx, 'package.json'), 'scripts', name);
   if (typeof script === 'string') out.push(...runnerCalls(script));
-  const mise = readToml(ctx, 'mise.toml');
-  const task = mise?.tasks?.[name];
-  if (task && typeof task === 'object') {
-    if (Array.isArray(task.depends))
-      out.push(...task.depends.filter((d: unknown): d is string => typeof d === 'string'));
-    const runs = Array.isArray(task.run) ? task.run : [task.run];
+  const task = dict(at(readToml(ctx, 'mise.toml'), 'tasks', name));
+  if (task) {
+    out.push(...list(task['depends']).filter((d): d is string => typeof d === 'string'));
+    const runs = Array.isArray(task['run']) ? (task['run'] as unknown[]) : [task['run']];
     for (const r of runs) if (typeof r === 'string') out.push(...runnerCalls(r));
   }
   const tasks = listAllTasks(ctx);