@williamthorsen/nmr 0.18.2 → 0.20.0

package/dist/esm/commands/taze.js

@@ -0,0 +1,32 @@
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { reportError } from '@williamthorsen/nmr-core';
+const TAZE_CLI_SPECIFIER = 'taze/cli';
+export function runTaze(args, options = {}) {
+    const stderr = options.stderr ?? process.stderr;
+    const resolveCliPath = options.resolveCliPath ?? resolveTazeCliPath;
+    const spawn = options.spawn ?? spawnNode;
+    let cliPath;
+    try {
+        cliPath = resolveCliPath();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        reportError(`Could not resolve '${TAZE_CLI_SPECIFIER}' from nmr's dependencies. Reinstall the workspace to restore it. (${detail})`, stderr);
+        return 1;
+    }
+    const outcome = spawn(process.execPath, [cliPath, ...args]);
+    if (outcome.error) {
+        reportError(`Failed to run taze: ${outcome.error.message}`, stderr);
+        return 1;
+    }
+    return outcome.status ?? 1;
+}
+export function resolveTazeCliPath() {
+    return fileURLToPath(import.meta.resolve(TAZE_CLI_SPECIFIER));
+}
+function spawnNode(nodePath, argv) {
+    const result = spawnSync(nodePath, argv, { stdio: 'inherit' });
+    return { status: result.status, error: result.error };
+}

package/dist/esm/context.d.ts

@@ -5,7 +5,5 @@ export interface ResolvedContext {
     packageDir?: string;
     config: NmrConfig;
 }
-export declare function findMonorepoRoot(startDir?: string): string;
-export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];
 export declare function findContainingPackageDir(dir: string, workspacePackageDirs: string[]): string | undefined;
 export declare function resolveContext(cwd?: string): Promise<ResolvedContext>;

package/dist/esm/context.js

@@ -1,71 +1,18 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { parse } from 'yaml';
 import { loadConfig } from "./config.js";
-import { isObject } from "./helpers/type-guards.js";
-export function findMonorepoRoot(startDir) {
-    let dir = path.resolve(startDir ?? process.cwd());
-    for (;;) {
-        if (existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            throw new Error('Could not find monorepo root: no pnpm-workspace.yaml found in any parent directory');
-        }
-        dir = parent;
-    }
-}
-export function getWorkspacePackageDirs(monorepoRoot) {
-    const workspaceFile = path.join(monorepoRoot, 'pnpm-workspace.yaml');
-    const content = readFileSync(workspaceFile, 'utf8');
-    const parsed = parse(content);
-    const packages = getPackagesFromParsedYaml(parsed);
-    if (!packages) {
-        return [];
-    }
-    const dirs = [];
-    for (const pattern of packages) {
-        if (pattern.endsWith('/*')) {
-            const prefix = pattern.slice(0, -2);
-            const prefixDir = path.resolve(monorepoRoot, prefix);
-            if (existsSync(prefixDir)) {
-                for (const entry of readdirSync(prefixDir)) {
-                    const fullPath = path.join(prefixDir, entry);
-                    if (statSync(fullPath).isDirectory() && existsSync(path.join(fullPath, 'package.json'))) {
-                        dirs.push(fullPath);
-                    }
-                }
-            }
-        }
-        else if (!pattern.includes('*')) {
-            const fullPath = path.resolve(monorepoRoot, pattern);
-            if (existsSync(fullPath) && existsSync(path.join(fullPath, 'package.json'))) {
-                dirs.push(fullPath);
-            }
-        }
-    }
-    return dirs;
-}
+import { findMonorepoRoot, getWorkspacePackageDirs } from "./workspace.js";
 export function findContainingPackageDir(dir, workspacePackageDirs) {
     const resolved = path.resolve(dir);
+    let nearest;
     for (const pkgDir of workspacePackageDirs) {
         const resolvedPkgDir = path.resolve(pkgDir);
-        if (resolved === resolvedPkgDir || resolved.startsWith(resolvedPkgDir + path.sep)) {
-            return resolvedPkgDir;
+        if (resolved !== resolvedPkgDir && !resolved.startsWith(resolvedPkgDir + path.sep))
+            continue;
+        if (nearest === undefined || resolvedPkgDir.length > nearest.length) {
+            nearest = resolvedPkgDir;
         }
     }
-    return undefined;
-}
-function getPackagesFromParsedYaml(parsed) {
-    if (!isObject(parsed))
-        return undefined;
-    const packages = parsed.packages;
-    if (!Array.isArray(packages))
-        return undefined;
-    if (!packages.every((p) => typeof p === 'string'))
-        return undefined;
-    return packages;
+    return nearest;
 }
 export async function resolveContext(cwd) {
     const resolvedCwd = path.resolve(cwd ?? process.cwd());
@@ -76,7 +23,7 @@ export async function resolveContext(cwd) {
     return {
         monorepoRoot,
         isRoot: packageDir === undefined,
-        ...(packageDir === undefined ? {} : { packageDir }),
+        ...(packageDir !== undefined && { packageDir }),
         config,
     };
 }

package/dist/esm/default-scripts.js

@@ -12,6 +12,7 @@ export const commonWorkspaceScripts = {
     'lint:check': 'eslint .',
     'lint:strict': 'strict-lint',
     typecheck: 'tsgo --noEmit',
+    upgrade: 'nmr-taze --include-locked',
     'view-coverage': 'open coverage/index.html',
 };
 export const integrationTestScripts = {
@@ -45,8 +46,6 @@ export const rootScripts = {
     lint: 'nmr root:lint && pnpm --recursive exec nmr lint',
     'lint:check': 'nmr root:lint:check && pnpm --recursive exec nmr lint:check',
     'lint:strict': 'nmr root:lint:strict && pnpm --recursive exec nmr lint:strict',
-    outdated: 'pnpm outdated --compatible --recursive',
-    'outdated:latest': 'pnpm outdated --recursive',
     'report-overrides': 'nmr-report-overrides',
     'root:check': ['root:typecheck', 'fmt:check', 'root:lint:check', 'root:test'],
     'root:lint': "eslint --fix --ignore-pattern 'packages/**' .",
@@ -54,12 +53,11 @@ export const rootScripts = {
     'root:lint:strict': "strict-lint --ignore-pattern 'packages/**' .",
     'root:test': 'vitest --config ./vitest.root.config.ts',
     'root:typecheck': 'tsgo --noEmit',
+    'root:upgrade': 'nmr-taze --include-locked',
     'sync-agent-files': 'nmr-sync-agent-files',
-    'sync-pnpm-version': 'nmr-sync-pnpm-version',
     test: 'nmr root:test && pnpm --recursive exec nmr test',
     'test:coverage': 'nmr root:test && pnpm --recursive exec nmr test:coverage',
     'test:watch': 'vitest --watch',
     typecheck: 'nmr root:typecheck && pnpm --recursive exec nmr typecheck',
-    update: 'pnpm update --recursive',
-    'update:latest': 'pnpm update --latest --recursive',
+    upgrade: 'nmr-report-overrides && nmr-taze --include-locked --recursive',
 };

package/dist/esm/help.js

@@ -1,5 +1,5 @@
 import { isHookName } from "./helpers/hook-name.js";
-import { buildRootRegistry, buildWorkspaceRegistry, describeScript, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
+import { buildRootRegistry, buildWorkspaceRegistry, describeScript, hasIntegrationTestConfig, isSelfReferential, readPackageJsonScripts, } from "./resolver.js";
 export function generateHelp(config, packageDir, useRoot) {
     const lines = [
         'Usage: nmr [flags] <command> [args...]',
@@ -7,15 +7,17 @@ export function generateHelp(config, packageDir, useRoot) {
         'Flags:',
         '  -F, --filter <pattern>   Run command in matching packages',
         '  -R, --recursive          Run command in all packages',
-        '  -w, --workspace-root     Run root command regardless of cwd',
+        '  -w, --workspace-root     Use root scripts, running at the monorepo root',
         '  -q, --quiet              Suppress output on success; show full output on failure',
         '  -?, --help               Show this help',
+        '  -V, --version            Show version number',
         '',
         'Workspace commands:',
     ];
     const overrides = packageDir === undefined ? {} : collectOverrides(packageDir);
     let hadOverride = false;
-    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config, false));
+    const useIntTests = !useRoot && packageDir !== undefined && hasIntegrationTestConfig(packageDir);
+    const workspaceRegistry = filterHooks(buildWorkspaceRegistry(config, useIntTests));
     const workspaceMarked = !useRoot ? applyOverrides(workspaceRegistry, overrides) : new Set();
     if (workspaceMarked.size > 0)
         hadOverride = true;
@@ -48,10 +50,11 @@ function collectOverrides(packageDir) {
 function applyOverrides(registry, overrides) {
     const marked = new Set();
     for (const [name, value] of Object.entries(overrides)) {
-        if (name in registry) {
-            registry[name] = value;
-            marked.add(name);
+        if (!(name in registry)) {
+            continue;
         }
+        registry[name] = value;
+        marked.add(name);
     }
     return marked;
 }

package/dist/esm/helpers/workspace-patterns.d.ts

@@ -0,0 +1 @@
+export declare function resolvePackageDirs(monorepoRoot: string, patterns: string[]): string[];

package/dist/esm/helpers/workspace-patterns.js

@@ -0,0 +1,29 @@
+import { globSync } from 'node:fs';
+import path from 'node:path';
+const MANIFEST = 'package.json';
+const ALWAYS_EXCLUDED = ['**/node_modules/**'];
+export function resolvePackageDirs(monorepoRoot, patterns) {
+    const included = [];
+    const excluded = [];
+    for (const pattern of patterns) {
+        if (pattern.trim() === '')
+            continue;
+        const isNegated = pattern.startsWith('!');
+        const target = isNegated ? excluded : included;
+        target.push(toManifestPattern(isNegated ? pattern.slice(1) : pattern));
+    }
+    if (included.length === 0) {
+        return [];
+    }
+    const options = {
+        cwd: monorepoRoot,
+        exclude: [...excluded, ...ALWAYS_EXCLUDED],
+        followSymlinks: true,
+    };
+    const matches = globSync(included, options);
+    const dirs = matches.map((match) => path.dirname(path.resolve(monorepoRoot, match)));
+    return [...new Set(dirs)].toSorted();
+}
+function toManifestPattern(pattern) {
+    return `${pattern.replace(/\/?$/, '')}/${MANIFEST}`;
+}

package/dist/esm/index.d.ts

@@ -1,3 +1,2 @@
 export type { NmrConfig } from './config.js';
 export { defineConfig } from './config.js';
-export type { ResolvedContext } from './context.js';

package/dist/esm/runCli.js

@@ -20,9 +20,9 @@ export async function runCli(options) {
     }
     const context = await resolveContext(cwd);
     const useRoot = parsed.workspaceRoot || context.isRoot;
-    const packageDir = useRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
+    const anchorDir = useRoot ? context.monorepoRoot : (context.packageDir ?? context.monorepoRoot);
     if (parsed.help || !parsed.command) {
-        stdout.write(`${generateHelp(context.config, packageDir, useRoot)}\n`);
+        stdout.write(`${generateHelp(context.config, anchorDir, useRoot)}\n`);
         return { exitCode: 0 };
     }
     const { command } = parsed;
@@ -41,8 +41,8 @@ export async function runCli(options) {
     }
     const registry = useRoot
         ? buildRootRegistry(context.config)
-        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(packageDir));
-    const resolved = resolveScript(command, registry, packageDir, parsed.workspaceRoot);
+        : buildWorkspaceRegistry(context.config, hasIntegrationTestConfig(anchorDir));
+    const resolved = resolveScript(command, registry, anchorDir, parsed.workspaceRoot);
     if (!resolved) {
         if (env.NMR_RUN_IF_PRESENT === '1') {
             return { exitCode: 0 };
@@ -50,20 +50,20 @@ export async function runCli(options) {
         reportError(`Unknown command: ${command}`, stderr);
         return { exitCode: 1 };
     }
-    const skipExitCode = handleSkipMessage(resolved.command, packageDir, parsed.quiet, stdout);
+    const skipExitCode = handleSkipMessage(resolved.command, anchorDir, parsed.quiet, stdout);
     if (skipExitCode !== undefined) {
         return { exitCode: skipExitCode };
     }
     if (resolved.source === 'package' && !parsed.quiet && registry[command] !== undefined) {
-        stdout.write(`📦 ${path.basename(packageDir)}: Using override script: ${resolved.command}\n`);
+        stdout.write(`📦 ${path.basename(anchorDir)}: Using override script: ${resolved.command}\n`);
     }
     const substitutedCommand = applyDevBin(resolved.command, context.config.devBin, context.monorepoRoot);
     const mainCommand = substitutedCommand + passthrough;
     const isHookInvocation = isHookName(command);
     const fullCommand = isHookInvocation
         ? mainCommand
-        : wrapWithHooks(command, mainCommand, registry, packageDir, parsed.workspaceRoot);
-    const exitCode = runCommand(fullCommand, cwd, runOptions);
+        : wrapWithHooks(command, mainCommand, registry, anchorDir, parsed.workspaceRoot);
+    const exitCode = runCommand(fullCommand, anchorDir, runOptions);
     return { exitCode };
 }
 function parseArgs(args) {
@@ -121,35 +121,35 @@ function parseArgs(args) {
     }
     return { ok: true, parsed };
 }
-function handleSkipMessage(resolvedCommand, packageDir, quiet, stdout) {
+function handleSkipMessage(resolvedCommand, anchorDir, quiet, stdout) {
     if (resolvedCommand === '') {
         if (!quiet) {
-            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is defined but empty. Skipping.\n`);
+            stdout.write(`⛔ ${path.basename(anchorDir)}: Override script is defined but empty. Skipping.\n`);
         }
         return 0;
     }
     if (resolvedCommand === ':') {
         if (!quiet) {
-            stdout.write(`⛔ ${path.basename(packageDir)}: Override script is a no-op. Skipping.\n`);
+            stdout.write(`⛔ ${path.basename(anchorDir)}: Override script is a no-op. Skipping.\n`);
         }
         return 0;
     }
     return undefined;
 }
-function wrapWithHooks(command, mainCommand, registry, packageDir, workspaceRoot) {
+function wrapWithHooks(command, mainCommand, registry, anchorDir, workspaceRoot) {
     const segments = [];
     const flag = workspaceRoot ? '-w ' : '';
-    if (hasRunnableHook(`${command}:pre`, registry, packageDir, workspaceRoot)) {
+    if (hasRunnableHook(`${command}:pre`, registry, anchorDir, workspaceRoot)) {
         segments.push(`nmr ${flag}${command}:pre`);
     }
     segments.push(mainCommand);
-    if (hasRunnableHook(`${command}:post`, registry, packageDir, workspaceRoot)) {
+    if (hasRunnableHook(`${command}:post`, registry, anchorDir, workspaceRoot)) {
         segments.push(`nmr ${flag}${command}:post`);
     }
     return segments.join(' && ');
 }
-function hasRunnableHook(hookName, registry, packageDir, workspaceRoot) {
-    const resolved = resolveScript(hookName, registry, packageDir, workspaceRoot);
+function hasRunnableHook(hookName, registry, anchorDir, workspaceRoot) {
+    const resolved = resolveScript(hookName, registry, anchorDir, workspaceRoot);
     if (!resolved)
         return false;
     return resolved.command !== '' && resolved.command !== ':';

package/dist/esm/taze.d.ts

@@ -0,0 +1,5 @@
+import type { CheckOptions } from 'taze';
+export type TazeConfig = {
+    [K in keyof CheckOptions]?: CheckOptions[K] | undefined;
+};
+export declare function defineConfig(config: TazeConfig): TazeConfig;

package/dist/esm/taze.js

@@ -0,0 +1,6 @@
+const SHARED_POLICY = {
+    maturityPeriod: 7,
+};
+export function defineConfig(config) {
+    return { ...SHARED_POLICY, ...config };
+}

package/dist/esm/workspace.d.ts

@@ -0,0 +1,2 @@
+export declare function findMonorepoRoot(startDir?: string): string;
+export declare function getWorkspacePackageDirs(monorepoRoot: string): string[];

package/dist/esm/workspace.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { isObject } from "./helpers/type-guards.js";
+import { resolvePackageDirs } from "./helpers/workspace-patterns.js";
+export function findMonorepoRoot(startDir) {
+    let dir = path.resolve(startDir ?? process.cwd());
+    for (;;) {
+        if (existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error('Could not find monorepo root: no pnpm-workspace.yaml found in any parent directory');
+        }
+        dir = parent;
+    }
+}
+export function getWorkspacePackageDirs(monorepoRoot) {
+    const workspaceFile = path.join(monorepoRoot, 'pnpm-workspace.yaml');
+    const content = readFileSync(workspaceFile, 'utf8');
+    const parsed = parse(content);
+    const packages = getPackagesFromParsedYaml(parsed);
+    if (!packages) {
+        return [];
+    }
+    return resolvePackageDirs(monorepoRoot, packages);
+}
+function getPackagesFromParsedYaml(parsed) {
+    if (!isObject(parsed))
+        return undefined;
+    const packages = parsed.packages;
+    if (!Array.isArray(packages))
+        return undefined;
+    if (!packages.every((p) => typeof p === 'string'))
+        return undefined;
+    return packages;
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@williamthorsen/nmr",
-  "version": "0.18.2",
+  "version": "0.20.0",
   "private": false,
-  "description": "Context-aware script runner for PNPM monorepos",
+  "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
     "monorepo",
     "pnpm",
@@ -30,9 +30,13 @@
       "types": "./dist/esm/scripts.d.ts",
       "default": "./dist/esm/scripts.js"
     },
-    "./tests": {
-      "types": "./dist/esm/tests/consistency.d.ts",
-      "default": "./dist/esm/tests/consistency.js"
+    "./taze": {
+      "types": "./dist/esm/taze.d.ts",
+      "default": "./dist/esm/taze.js"
+    },
+    "./workspace": {
+      "types": "./dist/esm/workspace.d.ts",
+      "default": "./dist/esm/workspace.js"
     }
   },
   "bin": {
@@ -42,7 +46,7 @@
     "nmr-compile": "bin/nmr-compile.js",
     "nmr-report-overrides": "bin/nmr-report-overrides.js",
     "nmr-sync-agent-files": "bin/nmr-sync-agent-files.js",
-    "nmr-sync-pnpm-version": "bin/nmr-sync-pnpm-version.js"
+    "nmr-taze": "bin/nmr-taze.js"
   },
   "files": [
     "AGENTS.md",
@@ -52,15 +56,15 @@
   "dependencies": {
     "glob": "13.0.6",
     "jiti": "2.7.0",
+    "taze": "19.15.1",
     "yaml": "2.9.0",
-    "zod": "4.4.3",
-    "@williamthorsen/nmr-core": "0.7.0"
-  },
-  "devDependencies": {
-    "@williamthorsen/toolbelt.strings": "3.1.4"
+    "@williamthorsen/nmr-core": "0.7.2"
   },
   "peerDependencies": {
-    "typescript": ">=5.7.0"
+    "typescript": ">=5.7.0 <7"
+  },
+  "engines": {
+    "node": ">=24.16.0"
   },
   "publishConfig": {
     "access": "public"

package/bin/nmr-sync-pnpm-version.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-try {
-  await import('../dist/esm/cli-sync-pnpm-version.js');
-} catch (error) {
-  if (error.code === 'ERR_MODULE_NOT_FOUND') {
-    process.stderr.write('nmr-sync-pnpm-version: build output not found — run `pnpm run build` first\n');
-  } else {
-    process.stderr.write(`nmr-sync-pnpm-version: failed to load: ${error.message}\n`);
-  }
-  process.exit(1);
-}

package/dist/esm/cli-sync-pnpm-version.js

@@ -1,11 +0,0 @@
-import { reportError } from '@williamthorsen/nmr-core';
-import { syncPnpmVersion } from "./commands/sync-pnpm-version.js";
-import { findMonorepoRoot } from "./context.js";
-try {
-    const monorepoRoot = findMonorepoRoot();
-    syncPnpmVersion(monorepoRoot);
-}
-catch (error) {
-    reportError(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-}

package/dist/esm/commands/sync-pnpm-version.d.ts

@@ -1,3 +0,0 @@
-declare function extractPnpmVersion(packageManager: string | undefined): string | null;
-export declare function syncPnpmVersion(monorepoRoot: string): void;
-export { extractPnpmVersion };

package/dist/esm/commands/sync-pnpm-version.js

@@ -1,40 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { parseDocument } from 'yaml';
-import { CodeQualityPnpmWorkflowSchema, getPnpmVersionNodes } from "../helpers/code-quality-pnpm-action.js";
-import { readPackageJson } from "../helpers/package-json.js";
-const WORKFLOW_RELATIVE_PATH = '.github/workflows/code-quality.yaml';
-function extractPnpmVersion(packageManager) {
-    if (!packageManager) {
-        return null;
-    }
-    const match = /^pnpm@(.+)$/.exec(packageManager);
-    return match?.[1] ?? null;
-}
-export function syncPnpmVersion(monorepoRoot) {
-    console.info('Synchronizing pnpm version in GitHub workflow...');
-    const pkg = readPackageJson(monorepoRoot);
-    const pnpmVersion = extractPnpmVersion(pkg.packageManager);
-    if (!pnpmVersion) {
-        throw new Error(`Could not extract pnpm version from package.json packageManager field\npackageManager field: ${pkg.packageManager ?? '(not set)'}`);
-    }
-    console.info(`Package.json pnpm version: ${pnpmVersion}`);
-    const workflowPath = path.join(monorepoRoot, WORKFLOW_RELATIVE_PATH);
-    const doc = parseDocument(readFileSync(workflowPath, 'utf8'));
-    const [parseError] = doc.errors;
-    if (parseError) {
-        throw new Error(`Failed to parse workflow file: ${workflowPath}\n${parseError.message}`);
-    }
-    CodeQualityPnpmWorkflowSchema.parse(doc.toJS());
-    const outdatedNodes = getPnpmVersionNodes(doc).filter((node) => String(node.value) !== pnpmVersion);
-    if (outdatedNodes.length === 0) {
-        console.info('Workflow pnpm version is already up to date');
-        return;
-    }
-    for (const node of outdatedNodes) {
-        node.value = pnpmVersion;
-    }
-    writeFileSync(workflowPath, doc.toString(), 'utf8');
-    console.info(`✓ Updated ${outdatedNodes.length} pnpm-version occurrence(s) → ${pnpmVersion}`);
-}
-export { extractPnpmVersion };

package/dist/esm/helpers/code-quality-pnpm-action.d.ts

@@ -1,13 +0,0 @@
-import { type Document, type Scalar } from 'yaml';
-import { z } from 'zod';
-export declare const CodeQualityPnpmWorkflowSchema: z.ZodObject<{
-    jobs: z.ZodObject<{
-        'code-quality': z.ZodObject<{
-            with: z.ZodObject<{
-                'pnpm-version': z.ZodString;
-            }, z.core.$loose>;
-        }, z.core.$loose>;
-    }, z.core.$loose>;
-}, z.core.$loose>;
-export type CodeQualityPnpmWorkflow = z.infer<typeof CodeQualityPnpmWorkflowSchema>;
-export declare function getPnpmVersionNodes(doc: Document): Scalar[];

package/dist/esm/helpers/code-quality-pnpm-action.js

@@ -1,22 +0,0 @@
-import { isScalar, visit } from 'yaml';
-import { z } from 'zod';
-export const CodeQualityPnpmWorkflowSchema = z.looseObject({
-    jobs: z.looseObject({
-        'code-quality': z.looseObject({
-            with: z.looseObject({
-                'pnpm-version': z.string(),
-            }),
-        }),
-    }),
-});
-export function getPnpmVersionNodes(doc) {
-    const nodes = [];
-    visit(doc, {
-        Pair(_, pair) {
-            if (isScalar(pair.key) && pair.key.value === 'pnpm-version' && isScalar(pair.value)) {
-                nodes.push(pair.value);
-            }
-        },
-    });
-    return nodes;
-}

package/dist/esm/tests/consistency.d.ts

@@ -1,7 +0,0 @@
-export { findMonorepoRoot } from '../context.js';
-export declare function checkPnpmVersionConsistency(monorepoRoot: string): void;
-export declare function checkNodeVersionConsistency(monorepoRoot: string): void;
-export declare function getPnpmVersionFromAction(monorepoRoot: string): Promise<string>;
-export declare function getPnpmVersionFromPackageJson(monorepoRoot: string): string;
-export declare function getNodeVersionFromAction(monorepoRoot: string): Promise<string>;
-export declare function runConsistencyChecks(): void;

package/dist/esm/tests/consistency.js

@@ -1,57 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { findMonorepoRoot } from "../context.js";
-export { findMonorepoRoot } from "../context.js";
-import { getRuntimeVersionFromAsdf } from "./helpers/get-runtime-version-from-asdf.js";
-import { getStringFromYamlFile } from "./helpers/get-string-from-yaml-file.js";
-import { getValueAtPathOrThrow } from "./helpers/get-value-at-path.js";
-const GITHUB_ACTION_FILE_PATH = '.github/workflows/code-quality.yaml';
-export function checkPnpmVersionConsistency(monorepoRoot) {
-    describe('pnpm version consistency', () => {
-        it('pnpm version is the same in GitHub action and package.json', async () => {
-            const actionVersion = await getPnpmVersionFromAction(monorepoRoot);
-            const packageJsonVersion = getPnpmVersionFromPackageJson(monorepoRoot);
-            expect(actionVersion).toBe(packageJsonVersion);
-        });
-    });
-}
-export function checkNodeVersionConsistency(monorepoRoot) {
-    describe('Node.js version consistency', () => {
-        it('version is the same in GitHub action and .tool-versions', async () => {
-            const toolVersion = await getRuntimeVersionFromAsdf('nodejs', monorepoRoot);
-            const actionVersion = await getNodeVersionFromAction(monorepoRoot);
-            expect(toolVersion).toBe(actionVersion);
-        });
-    });
-}
-export async function getPnpmVersionFromAction(monorepoRoot) {
-    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.pnpm-version', 'pnpm version');
-}
-export function getPnpmVersionFromPackageJson(monorepoRoot) {
-    const pkgPath = path.join(monorepoRoot, 'package.json');
-    const raw = fs.readFileSync(pkgPath, 'utf8');
-    const pkg = JSON.parse(raw);
-    const pm = getValueAtPathOrThrow(pkg, 'packageManager');
-    if (typeof pm !== 'string') {
-        throw new TypeError('"packageManager" field missing or not a string in package.json.');
-    }
-    const [name, version] = pm.split('@');
-    if (name !== 'pnpm') {
-        throw new Error('packageManager is not pnpm.');
-    }
-    if (!version) {
-        throw new Error('pnpm version missing in package.json.');
-    }
-    return version;
-}
-export async function getNodeVersionFromAction(monorepoRoot) {
-    const actionPath = path.join(monorepoRoot, GITHUB_ACTION_FILE_PATH);
-    return getStringFromYamlFile(actionPath, 'jobs.code-quality.with.node-version', 'Node.js version');
-}
-export function runConsistencyChecks() {
-    const monorepoRoot = findMonorepoRoot();
-    checkPnpmVersionConsistency(monorepoRoot);
-    checkNodeVersionConsistency(monorepoRoot);
-}

package/dist/esm/tests/helpers/get-runtime-version-from-asdf.d.ts

@@ -1 +0,0 @@
-export declare function getRuntimeVersionFromAsdf(runtime: string, monorepoRoot: string): Promise<string>;

package/dist/esm/tests/helpers/get-runtime-version-from-asdf.js

@@ -1,12 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import path from 'node:path';
-export async function getRuntimeVersionFromAsdf(runtime, monorepoRoot) {
-    const toolVersionsPath = path.join(monorepoRoot, '.tool-versions');
-    const toolVersions = await fs.promises.readFile(toolVersionsPath, { encoding: 'utf8' });
-    const versionLine = toolVersions.split('\n').find((line) => line.trim().startsWith(runtime));
-    assert.ok(versionLine, `${runtime} not found in .tool-versions`);
-    const [, version] = versionLine.trim().split(/\s+/);
-    assert.ok(version, `${runtime} version missing in .tool-versions`);
-    return version;
-}

package/dist/esm/tests/helpers/get-string-from-yaml-file.d.ts

@@ -1 +0,0 @@
-export declare function getStringFromYamlFile(filePath: string, keyPath: string, label: string): Promise<string>;