@williamthorsen/nmr 0.19.0 → 0.21.0

package/dist/esm/vitest.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { defaultExclude, mergeConfig } from 'vitest/config';
+import { findMonorepoRoot, getWorkspacePackageDirs } from "./workspace.js";
+const APP_PATTERNS = ['**/__tests__/**/*.app.test.{ts,tsx}'];
+const INTEGRATION_PATTERNS = ['**/__tests__/**/*.int.test.{ts,tsx}'];
+const ALL_TEST_PATTERNS = ['**/__tests__/**/*.test.{ts,tsx}'];
+const COVERAGE_EXCLUDE = [
+    '**/__{mocks,tests}__/*',
+    '**/index.ts',
+    '**/mock*.{ts,tsx}',
+    '**/*.d.ts',
+    '**/*.types.ts',
+];
+const PACKAGE_COVERAGE_INCLUDE = ['**/src/**/*.{ts,tsx}'];
+export function defineVitestConfig(options = {}) {
+    return buildConfig(options, { coverageInclude: PACKAGE_COVERAGE_INCLUDE });
+}
+export function defineRootVitestConfig(options = {}) {
+    const monorepoRoot = findMonorepoRoot(options.startDir);
+    return buildConfig(options, {
+        coverageInclude: [],
+        projectExclude: getWorkspaceExcludePatterns(monorepoRoot),
+        projectRoot: monorepoRoot,
+    });
+}
+function buildConfig(options, { coverageInclude, projectExclude = [], projectRoot }) {
+    const config = {
+        test: {
+            coverage: {
+                enabled: false,
+                exclude: COVERAGE_EXCLUDE,
+                include: coverageInclude,
+                provider: 'v8',
+            },
+            passWithNoTests: true,
+            projects: buildProjects(options.project, projectExclude, projectRoot),
+            silent: 'passed-only',
+            watch: false,
+        },
+    };
+    return options.root ? mergeConfig(config, options.root) : config;
+}
+function buildProjects(overrides, extraExclude, projectRoot) {
+    const categories = [
+        { exclude: [], include: APP_PATTERNS, name: 'app' },
+        { exclude: [], include: INTEGRATION_PATTERNS, name: 'integration' },
+        { exclude: [...APP_PATTERNS, ...INTEGRATION_PATTERNS], include: ALL_TEST_PATTERNS, name: 'unit' },
+    ];
+    return categories.map(({ exclude, include, name }) => {
+        const project = {
+            extends: true,
+            ...(projectRoot !== undefined && { root: projectRoot }),
+            test: { exclude: [...defaultExclude, ...exclude, ...extraExclude], include, name },
+        };
+        return overrides ? mergeConfig(project, { test: overrides }) : project;
+    });
+}
+function getWorkspaceExcludePatterns(monorepoRoot) {
+    return getWorkspacePackageDirs(monorepoRoot)
+        .map((dir) => `${path.relative(monorepoRoot, dir).split(path.sep).join('/')}/**`)
+        .toSorted();
+}

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.19.0",
+  "version": "0.21.0",
   "private": false,
-  "description": "Context-aware script runner for PNPM monorepos",
+  "description": "Context-aware script runner for pnpm monorepos",
   "keywords": [
     "monorepo",
     "pnpm",
@@ -34,9 +34,13 @@
       "types": "./dist/esm/taze.d.ts",
       "default": "./dist/esm/taze.js"
     },
-    "./tests": {
-      "types": "./dist/esm/tests/consistency.d.ts",
-      "default": "./dist/esm/tests/consistency.js"
+    "./vitest": {
+      "types": "./dist/esm/vitest.d.ts",
+      "default": "./dist/esm/vitest.js"
+    },
+    "./workspace": {
+      "types": "./dist/esm/workspace.d.ts",
+      "default": "./dist/esm/workspace.js"
     }
   },
   "bin": {
@@ -44,9 +48,9 @@
     "nmr": "bin/nmr.js",
     "nmr-clean": "bin/nmr-clean.js",
     "nmr-compile": "bin/nmr-compile.js",
+    "nmr-fmt": "bin/nmr-fmt.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": [
@@ -57,19 +61,30 @@
   "dependencies": {
     "glob": "13.0.6",
     "jiti": "2.7.0",
-    "taze": "19.15.1",
+    "taze": "19.16.0",
     "yaml": "2.9.0",
-    "zod": "4.4.3",
-    "@williamthorsen/nmr-core": "0.7.1"
+    "@williamthorsen/nmr-core": "0.7.3"
   },
   "devDependencies": {
-    "@williamthorsen/toolbelt.strings": "3.1.6"
+    "prettier": "3.9.6",
+    "tinyglobby": "0.2.17",
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "typescript": ">=5.7.0 <7"
+    "prettier": ">=3.9.5 <4",
+    "typescript": ">=5.7.0 <7",
+    "vitest": ">=4.0.0 <5"
+  },
+  "peerDependenciesMeta": {
+    "prettier": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
   },
   "engines": {
-    "node": ">=24"
+    "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('@', 2);
-    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+/, 2);
-    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>;

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

@@ -1,12 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import { parse } from 'yaml';
-import { getValueAtPathOrThrow } from "./get-value-at-path.js";
-export async function getStringFromYamlFile(filePath, keyPath, label) {
-    const raw = await fs.promises.readFile(filePath, { encoding: 'utf8' });
-    const parsed = parse(raw);
-    assert.ok(parsed, `YAML content not found in ${filePath}`);
-    const value = getValueAtPathOrThrow(parsed, keyPath);
-    assert.ok(typeof value === 'string' && value.length > 0, `${label} not found at ${keyPath}`);
-    return value;
-}

package/dist/esm/tests/helpers/get-value-at-path.d.ts

@@ -1 +0,0 @@
-export declare function getValueAtPathOrThrow(obj: unknown, objPath: string): unknown;

package/dist/esm/tests/helpers/get-value-at-path.js

@@ -1,34 +0,0 @@
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function getValueAtPathOrThrow(obj, objPath) {
-    if (!isObject(obj)) {
-        throw new Error('Expected an object as root value.');
-    }
-    const keys = objPath.split('.');
-    let current = obj;
-    for (const key of keys) {
-        if (Array.isArray(current)) {
-            const index = Number(key);
-            if (Number.isNaN(index)) {
-                throw new TypeError(`Expected array index at segment "${key}" in path "${objPath}"`);
-            }
-            if (index >= 0 && index < current.length) {
-                current = current[index];
-            }
-            else {
-                throw new Error(`Array index out of bounds: "${key}" in path "${objPath}"`);
-            }
-        }
-        else if (isObject(current)) {
-            if (!(key in current)) {
-                throw new Error(`Missing key "${key}" in path "${objPath}"`);
-            }
-            current = current[key];
-        }
-        else {
-            throw new Error(`Unexpected non-object/non-array at segment "${key}" in path "${objPath}"`);
-        }
-    }
-    return current;
-}