@williamthorsen/nmr 0.22.0 → 0.24.0

package/dist/esm/check-cache.d.ts

@@ -0,0 +1,76 @@
+import type { Writable } from 'node:stream';
+import type { CheckCacheConfig, NmrConfig } from './types.js';
+export interface CheckCacheEntry {
+    key: string;
+    treeHash: string;
+    headSha: string;
+    commandString: string;
+    nmrVersion: string;
+    nodeVersion: string;
+    durationMs: number;
+    recordedAt: string;
+    buildDigests: Record<string, string>;
+}
+export interface BuildOutputState {
+    missing: string[];
+    digests: Record<string, string>;
+}
+export interface RuntimeIdentity {
+    arch: string;
+    nodeVersion: string;
+    platform: string;
+}
+export interface TreeSnapshot {
+    hash: string;
+    headSha: string;
+}
+export declare const CURRENT_RUNTIME: RuntimeIdentity;
+export declare const DEBUG_ENV_VAR = "NMR_DEBUG";
+export declare const DEFAULT_CACHEABLE_COMMANDS: string[];
+export declare const NO_CACHE_ENV_VAR = "NMR_NO_CACHE";
+export declare const TREE_SNAPSHOT_ENV_VAR = "NMR_TREE_SNAPSHOT";
+export declare function computeCacheKey(options: {
+    anchorDir: string;
+    command: string;
+    commandString: string;
+    env: NodeJS.ProcessEnv;
+    monorepoRoot: string;
+    nmrVersion: string;
+    runtime?: RuntimeIdentity;
+    snapshot: TreeSnapshot;
+}): {
+    ok: true;
+    key: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function encodeTreeSnapshot(snapshot: TreeSnapshot): string;
+export declare function findStaleBuildOutput(recorded: Record<string, string>, current: Record<string, string>): string | undefined;
+export declare function formatMisplacedNoCacheWarning(command: string): string;
+export declare function formatSkipLine(command: string, entry: CheckCacheEntry, now: number): string;
+export declare function readBuildOutputState(monorepoRoot: string, config: NmrConfig): Promise<BuildOutputState>;
+export declare function readCheckCacheEntry(options: {
+    anchorDir: string;
+    command: string;
+    monorepoRoot: string;
+}): Promise<CheckCacheEntry | undefined>;
+export declare function removeCheckCache(scopeDir: string): Promise<void>;
+export declare function resolveCacheableCommands(checkCache: CheckCacheConfig | undefined): Set<string>;
+export declare function resolveTreeSnapshot(options: {
+    monorepoRoot: string;
+    env: NodeJS.ProcessEnv;
+}): {
+    ok: true;
+    snapshot: TreeSnapshot;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function writeCheckCacheEntry(options: {
+    anchorDir: string;
+    command: string;
+    entry: CheckCacheEntry;
+    monorepoRoot: string;
+}): Promise<void>;
+export declare function writeDebugNote(message: string, env: NodeJS.ProcessEnv, stderr: Writable): void;

package/dist/esm/check-cache.js

@@ -0,0 +1,236 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { hashWorkingTree, readHeadSha, readJsonCacheEntry, removeCacheDir, resolveCacheEntryPath, writeCacheEntry, } from '@williamthorsen/nmr-core';
+import { hasBuildOutput, readBuildDigest } from "./commands/build-output.js";
+import { loadWorkspaceConfig } from "./config.js";
+import { isObject, isStringRecord } from "./helpers/type-guards.js";
+import { getDefaultWorkspaceScripts } from "./resolve-scripts.js";
+import { buildWorkspaceRegistry, resolveScript } from "./resolver.js";
+import { getWorkspacePackageDirs } from "./workspace.js";
+export const CURRENT_RUNTIME = {
+    arch: process.arch,
+    nodeVersion: process.version,
+    platform: process.platform,
+};
+export const DEBUG_ENV_VAR = 'NMR_DEBUG';
+export const DEFAULT_CACHEABLE_COMMANDS = [
+    'check',
+    'check:agent-files',
+    'check:strict',
+    'ci',
+    'fix:check',
+    'fmt:check',
+    'lint:check',
+    'lint:strict',
+    'root:check',
+    'root:lint:check',
+    'root:lint:strict',
+    'root:test',
+    'root:test:tool',
+    'root:test:unit',
+    'root:typecheck',
+    'test',
+    'test:coverage',
+    'test:tool',
+    'test:unit',
+    'typecheck',
+];
+export const NO_CACHE_ENV_VAR = 'NMR_NO_CACHE';
+export const TREE_SNAPSHOT_ENV_VAR = 'NMR_TREE_SNAPSHOT';
+const BUILT_IN_COMPILE = 'nmr-compile';
+const CACHE_TOOL = 'nmr-check';
+const INSTALL_FINGERPRINT_FILES = [
+    path.join('node_modules', '.modules.yaml'),
+    path.join('node_modules', '.pnpm', 'lock.yaml'),
+];
+const KEY_FORMAT = 'nmr-check-cache-v1';
+const KEYED_ENV_VARS = ['LANG', 'LC_ALL', 'NODE_OPTIONS', 'TZ'];
+const UNSAFE_SLUG_CHARACTERS = /[^\w.-]+/g;
+export function computeCacheKey(options) {
+    const fingerprint = resolveInstallFingerprint(options.monorepoRoot);
+    if (!fingerprint.ok) {
+        return fingerprint;
+    }
+    const runtime = options.runtime ?? CURRENT_RUNTIME;
+    const scope = path.relative(options.monorepoRoot, options.anchorDir);
+    const parts = [
+        KEY_FORMAT,
+        options.snapshot.hash,
+        scope === '' ? '.' : scope,
+        options.command,
+        options.commandString,
+        options.nmrVersion,
+        runtime.nodeVersion,
+        runtime.platform,
+        runtime.arch,
+        fingerprint.fingerprint,
+    ];
+    for (const name of KEYED_ENV_VARS) {
+        const value = options.env[name];
+        parts.push(name, value === undefined ? 'unset' : 'set', value ?? '');
+    }
+    const hash = createHash('sha256');
+    for (const part of parts) {
+        hash.update(part);
+        hash.update('\0');
+    }
+    return { ok: true, key: hash.digest('hex') };
+}
+export function encodeTreeSnapshot(snapshot) {
+    return `${snapshot.hash} ${snapshot.headSha}`;
+}
+export function findStaleBuildOutput(recorded, current) {
+    const names = [...new Set([...Object.keys(recorded), ...Object.keys(current)])].toSorted();
+    return names.find((name) => recorded[name] !== current[name]);
+}
+export function formatMisplacedNoCacheWarning(command) {
+    return (`⚠️ --no-cache after the command name is passed to \`${command}\`, not read by nmr. ` +
+        `Did you mean \`nmr --no-cache ${command}\`?`);
+}
+export function formatSkipLine(command, entry, now) {
+    const age = formatDuration(Math.max(0, now - Date.parse(entry.recordedAt)));
+    const saved = formatDuration(entry.durationMs);
+    return `⏭️ ${command}: passed ${age} ago on this tree (saved ~${saved}). Re-run with --no-cache.`;
+}
+export async function readBuildOutputState(monorepoRoot, config) {
+    const state = { missing: [], digests: {} };
+    let packageDirs;
+    try {
+        packageDirs = getWorkspacePackageDirs(monorepoRoot);
+    }
+    catch {
+        return state;
+    }
+    const registry = buildWorkspaceRegistry(config);
+    if (JSON.stringify(registry.build) !== JSON.stringify(getDefaultWorkspaceScripts().build)) {
+        return state;
+    }
+    for (const packageDir of packageDirs) {
+        if (!isProbeSubject(packageDir, registry)) {
+            continue;
+        }
+        const { build } = await loadWorkspaceConfig(packageDir);
+        const options = build?.extraIgnorePatterns === undefined ? {} : { extraIgnorePatterns: build.extraIgnorePatterns };
+        const name = path.relative(monorepoRoot, packageDir);
+        if (await hasBuildOutput(packageDir, options)) {
+            state.digests[name] = (await readBuildDigest(packageDir)) ?? '';
+        }
+        else {
+            state.missing.push(name);
+        }
+    }
+    return state;
+}
+export async function readCheckCacheEntry(options) {
+    return readJsonCacheEntry(resolveEntryPath(options), isCheckCacheEntry);
+}
+export async function removeCheckCache(scopeDir) {
+    await removeCacheDir({ tool: CACHE_TOOL, scopeDir });
+}
+export function resolveCacheableCommands(checkCache) {
+    const commands = new Set([...DEFAULT_CACHEABLE_COMMANDS, ...(checkCache?.extraCommands ?? [])]);
+    for (const excluded of checkCache?.excludeCommands ?? []) {
+        commands.delete(excluded);
+    }
+    return commands;
+}
+export function resolveTreeSnapshot(options) {
+    const inherited = decodeTreeSnapshot(options.env[TREE_SNAPSHOT_ENV_VAR]);
+    if (inherited !== undefined && readHeadSha(options.monorepoRoot) === inherited.headSha) {
+        return { ok: true, snapshot: inherited };
+    }
+    const hashed = hashWorkingTree(options.monorepoRoot);
+    if (!hashed.ok) {
+        return hashed;
+    }
+    let physicalRoot;
+    try {
+        physicalRoot = realpathSync(options.monorepoRoot);
+    }
+    catch {
+        return { ok: false, reason: `could not resolve ${options.monorepoRoot}` };
+    }
+    if (hashed.toplevel !== physicalRoot) {
+        return { ok: false, reason: `the monorepo root is not the git toplevel (${hashed.toplevel})` };
+    }
+    return { ok: true, snapshot: { hash: hashed.hash, headSha: hashed.headSha } };
+}
+export async function writeCheckCacheEntry(options) {
+    await writeCacheEntry(resolveEntryPath(options), JSON.stringify(options.entry, undefined, 2));
+}
+export function writeDebugNote(message, env, stderr) {
+    if (env[DEBUG_ENV_VAR] === '1') {
+        stderr.write(`nmr check-cache: ${message}\n`);
+    }
+}
+const MILLISECONDS_PER_SECOND = 1000;
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_HOUR = 60;
+function decodeTreeSnapshot(encoded) {
+    if (encoded === undefined) {
+        return undefined;
+    }
+    const [hash, headSha] = encoded.split(' ', 2);
+    if (hash === undefined || headSha === undefined || hash === '' || headSha === '') {
+        return undefined;
+    }
+    return { hash, headSha };
+}
+function formatDuration(milliseconds) {
+    const seconds = Math.round(milliseconds / MILLISECONDS_PER_SECOND);
+    if (seconds < SECONDS_PER_MINUTE) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.round(seconds / SECONDS_PER_MINUTE);
+    if (minutes < MINUTES_PER_HOUR) {
+        return `${minutes}m`;
+    }
+    return `${Math.round(minutes / MINUTES_PER_HOUR)}h`;
+}
+function isCheckCacheEntry(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    const stringFields = ['key', 'treeHash', 'headSha', 'commandString', 'nmrVersion', 'nodeVersion', 'recordedAt'];
+    if (stringFields.some((field) => typeof value[field] !== 'string')) {
+        return false;
+    }
+    return (typeof value.durationMs === 'number' &&
+        Number.isFinite(value.durationMs) &&
+        !Number.isNaN(Date.parse(String(value.recordedAt))) &&
+        isStringRecord(value.buildDigests));
+}
+function isProbeSubject(packageDir, registry) {
+    const build = resolveScript('build', registry, packageDir, false);
+    if (build === undefined || build.source === 'package') {
+        return false;
+    }
+    const compile = resolveScript('compile', registry, packageDir, false);
+    return compile !== undefined && compile.command === BUILT_IN_COMPILE;
+}
+function resolveEntryPath(options) {
+    const anchorDir = path.resolve(options.anchorDir);
+    const ref = {
+        tool: CACHE_TOOL,
+        scopeDir: options.monorepoRoot,
+        slug: `${path.basename(anchorDir)}-${options.command.replaceAll(UNSAFE_SLUG_CHARACTERS, '-')}`,
+        extension: '.json',
+        discriminators: [anchorDir, options.command],
+    };
+    return resolveCacheEntryPath(ref);
+}
+function resolveInstallFingerprint(monorepoRoot) {
+    const hash = createHash('sha256');
+    for (const relativePath of INSTALL_FINGERPRINT_FILES) {
+        try {
+            hash.update(readFileSync(path.join(monorepoRoot, relativePath)));
+        }
+        catch {
+            return { ok: false, reason: `no install fingerprint: ${relativePath} is unreadable` };
+        }
+        hash.update('\0');
+    }
+    return { ok: true, fingerprint: hash.digest('hex') };
+}

package/dist/esm/cli-build.js

@@ -1,8 +1,14 @@
+import { reportError } from '@williamthorsen/nmr-core';
 import { buildPackage } from "./commands/build.js";
+import { loadWorkspaceConfig } from "./config.js";
 try {
-    await buildPackage(process.cwd());
+    const packageDir = process.cwd();
+    const { build } = await loadWorkspaceConfig(packageDir);
+    await buildPackage(packageDir, {
+        ...(build?.extraIgnorePatterns !== undefined && { extraIgnorePatterns: build.extraIgnorePatterns }),
+    });
 }
 catch (error) {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    reportError(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;
 }

package/dist/esm/commands/build-output.d.ts

@@ -0,0 +1,13 @@
+export interface BuildOptions {
+    entryGlobs?: string[];
+    extraIgnorePatterns?: string[];
+    ignorePatterns?: string[];
+    outdir?: string;
+}
+export declare const DEFAULT_ENTRY_GLOBS: string[];
+export declare const DEFAULT_IGNORE_PATTERNS: string[];
+export declare const DEFAULT_OUTDIR = "dist/esm/";
+export declare function hasBuildOutput(packageDir: string, options?: BuildOptions): Promise<boolean>;
+export declare function hasExpectedBuildOutput(packageDir: string, outdir: string, entryPoints: string[]): boolean;
+export declare function readBuildDigest(packageDir: string): Promise<string | undefined>;
+export declare function resolveBuildCachePath(packageDir: string): string;

package/dist/esm/commands/build-output.js

@@ -0,0 +1,36 @@
+import { existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { readCacheEntry, resolveCacheEntryPath } from '@williamthorsen/nmr-core';
+import { glob } from 'glob';
+export const DEFAULT_ENTRY_GLOBS = ['src/**/*.ts'];
+export const DEFAULT_IGNORE_PATTERNS = ['**/__fixtures__/**', '**/__mocks__/**', '**/__tests__/**', '**/test-utils/**'];
+export const DEFAULT_OUTDIR = 'dist/esm/';
+const BUILD_CACHE_TOOL = 'nmr-compile';
+export async function hasBuildOutput(packageDir, options = {}) {
+    const outdir = options.outdir ?? DEFAULT_OUTDIR;
+    const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
+        cwd: packageDir,
+        ignore: [...(options.ignorePatterns ?? DEFAULT_IGNORE_PATTERNS), ...(options.extraIgnorePatterns ?? [])],
+    });
+    return hasExpectedBuildOutput(packageDir, outdir, entryPoints);
+}
+export function hasExpectedBuildOutput(packageDir, outdir, entryPoints) {
+    const emitsOutput = entryPoints.some((entry) => !entry.endsWith('.d.ts'));
+    if (!emitsOutput) {
+        return true;
+    }
+    const outputDir = path.resolve(packageDir, outdir);
+    return existsSync(outputDir) && readdirSync(outputDir).length > 0;
+}
+export async function readBuildDigest(packageDir) {
+    return readCacheEntry(resolveBuildCachePath(packageDir));
+}
+export function resolveBuildCachePath(packageDir) {
+    const absolutePackageDir = path.resolve(packageDir);
+    return resolveCacheEntryPath({
+        tool: BUILD_CACHE_TOOL,
+        scopeDir: absolutePackageDir,
+        slug: path.basename(absolutePackageDir),
+        extension: '.hash',
+    });
+}

package/dist/esm/commands/build.d.ts

@@ -1,9 +1,4 @@
-export interface BuildOptions {
-    entryGlobs?: string[];
-    ignore?: string[];
-    outdir?: string;
-}
+import type { BuildOptions } from './build-output.js';
 export declare function buildPackage(packageDir: string, options?: BuildOptions): Promise<void>;
 export declare function computeBuildHash(packageDir: string, files: string[], emitConfig: object, compilerVersion: string): Promise<string>;
 export declare function resolveTsconfigChain(packageDir: string, configFileName?: string): string[];
-export declare function resolveBuildCachePath(packageDir: string): string;

package/dist/esm/commands/build.js

@@ -1,14 +1,14 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
 import path from 'node:path';
+import { readCacheEntry, writeCacheEntry } from '@williamthorsen/nmr-core';
 import { glob } from 'glob';
 import * as ts from 'typescript';
+import { resolveConfigPath } from "../config.js";
+import { DEFAULT_ENTRY_GLOBS, DEFAULT_IGNORE_PATTERNS, DEFAULT_OUTDIR, hasExpectedBuildOutput, resolveBuildCachePath, } from "./build-output.js";
 const PACKAGE_ICON = '📦';
 const SKIPPED_ICON = '⏭️';
-const DEFAULT_ENTRY_GLOBS = ['src/**/*.ts'];
-const DEFAULT_IGNORE = ['**/__tests__/**'];
-const DEFAULT_OUTDIR = 'dist/esm/';
 const SOURCE_ROOT = 'src';
 const MINIMUM_TYPESCRIPT_MAJOR = 5;
 const MINIMUM_TYPESCRIPT_MINOR = 7;
@@ -18,22 +18,28 @@ export async function buildPackage(packageDir, options = {}) {
     assertSupportedTypeScript();
     const cachePath = resolveBuildCachePath(packageDir);
     const outdir = options.outdir ?? DEFAULT_OUTDIR;
+    resolveEmitDir(packageDir, outdir);
     const emitConfig = { outdir, declaration: true, rewriteRelativeImportExtensions: true };
     const entryPoints = await glob(options.entryGlobs ?? DEFAULT_ENTRY_GLOBS, {
         cwd: packageDir,
-        ignore: options.ignore ?? DEFAULT_IGNORE,
+        ignore: [...(options.ignorePatterns ?? DEFAULT_IGNORE_PATTERNS), ...(options.extraIgnorePatterns ?? [])],
     });
-    const dependencies = ['package.json', ...resolveTsconfigChain(packageDir)];
+    const configPath = resolveConfigPath(packageDir);
+    const dependencies = [
+        'package.json',
+        ...(existsSync(configPath) ? [path.relative(packageDir, configPath)] : []),
+        ...resolveTsconfigChain(packageDir),
+    ];
     const { changed, currentHash } = await detectBuildChanges(packageDir, [...entryPoints, ...dependencies], emitConfig, ts.version, cachePath, hasExpectedBuildOutput(packageDir, outdir, entryPoints));
     if (!changed) {
         return;
     }
-    emitPackage(packageDir, entryPoints, outdir);
-    await writeBuildCache(cachePath, currentHash);
+    await emitPackage(packageDir, entryPoints, outdir);
+    await writeCacheEntry(cachePath, currentHash);
 }
 export async function computeBuildHash(packageDir, files, emitConfig, compilerVersion) {
     const hash = createHash('sha256');
-    for (const file of [...files].sort()) {
+    for (const file of files.toSorted()) {
         hash.update(file);
         hash.update('\0');
         hash.update(await readFile(path.join(packageDir, file)));
@@ -67,11 +73,12 @@ export function resolveTsconfigChain(packageDir, configFileName = 'tsconfig.json
     walk(path.resolve(packageDir, configFileName));
     return resolvedChain.map((absolute) => path.relative(packageDir, absolute));
 }
-function emitPackage(packageDir, entryPoints, outdir) {
+async function emitPackage(packageDir, entryPoints, outdir) {
     const compilerOptions = synthesizeCompilerOptions(packageDir, outdir);
     const rootNames = entryPoints.map((entry) => path.resolve(packageDir, entry));
     const sourceRoot = path.resolve(packageDir, SOURCE_ROOT);
     const program = ts.createProgram(rootNames, compilerOptions);
+    await rm(resolveEmitDir(packageDir, outdir), { force: true, recursive: true });
     const emittedFiles = [];
     const emitResult = program.emit(undefined, (fileName, text, writeByteOrderMark) => {
         ts.sys.writeFile(fileName, text, writeByteOrderMark);
@@ -84,6 +91,15 @@ function emitPackage(packageDir, entryPoints, outdir) {
         rewriteOutputSpecifiers(file, compilerOptions, sourceRoot);
     }
 }
+function resolveEmitDir(packageDir, outdir) {
+    const resolved = path.resolve(packageDir, outdir);
+    const relative = path.relative(packageDir, resolved);
+    if (relative === '' || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`nmr-compile: refusing to build into '${outdir}', which does not resolve inside the package. ` +
+            'The build wipes its output directory before each emit, so the directory must sit below the package root.');
+    }
+    return resolved;
+}
 function synthesizeCompilerOptions(packageDir, outdir) {
     const configPath = path.join(packageDir, 'tsconfig.json');
     const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
@@ -190,28 +206,9 @@ function getModuleSpecifier(node) {
     }
     return undefined;
 }
-export function resolveBuildCachePath(packageDir) {
-    const absolutePackageDir = path.resolve(packageDir);
-    const home = findNearestNodeModulesHost(absolutePackageDir) ?? absolutePackageDir;
-    const digest = createHash('sha256').update(absolutePackageDir).digest('hex').slice(0, 8);
-    const key = `${path.basename(absolutePackageDir)}-${digest}.hash`;
-    return path.join(home, 'node_modules', '.cache', 'nmr-compile', key);
-}
-function findNearestNodeModulesHost(startDir) {
-    let current = startDir;
-    let parent = path.dirname(current);
-    while (!existsSync(path.join(current, 'node_modules'))) {
-        if (parent === current) {
-            return undefined;
-        }
-        current = parent;
-        parent = path.dirname(current);
-    }
-    return current;
-}
 async function detectBuildChanges(packageDir, files, emitConfig, compilerVersion, cachePath, outputPresent) {
     const packageName = path.basename(packageDir);
-    const previousHash = existsSync(cachePath) ? readFileSync(cachePath, 'utf8') : undefined;
+    const previousHash = await readCacheEntry(cachePath);
     const currentHash = await computeBuildHash(packageDir, files, emitConfig, compilerVersion);
     if (previousHash === currentHash) {
         if (outputPresent) {
@@ -224,18 +221,6 @@ async function detectBuildChanges(packageDir, files, emitConfig, compilerVersion
     console.info(`${PACKAGE_ICON} ${packageName}: Changes detected.`);
     return { changed: true, currentHash };
 }
-function hasExpectedBuildOutput(packageDir, outdir, entryPoints) {
-    const emitsOutput = entryPoints.some((entry) => !entry.endsWith('.d.ts'));
-    if (!emitsOutput) {
-        return true;
-    }
-    const outputDir = path.resolve(packageDir, outdir);
-    return existsSync(outputDir) && readdirSync(outputDir).length > 0;
-}
-async function writeBuildCache(cachePath, hash) {
-    await mkdir(path.dirname(cachePath), { recursive: true });
-    await writeFile(cachePath, hash);
-}
 function assertSupportedTypeScript() {
     const [majorPart, minorPart] = ts.versionMajorMinor.split('.', 2);
     const major = majorPart === undefined ? 0 : Number(majorPart);

package/dist/esm/commands/clean.js

@@ -1,11 +1,12 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
-import { loadConfig } from "../config.js";
+import { removeCheckCache } from "../check-cache.js";
+import { loadRootConfig } from "../config.js";
 import { findContainingPackageDir } from "../context.js";
 import { applyDevBin, buildWorkspaceRegistry, resolveScript } from "../resolver.js";
 import { runCommand } from "../runner.js";
 import { findMonorepoRoot, getWorkspacePackageDirs } from "../workspace.js";
-import { resolveBuildCachePath } from "./build.js";
+import { resolveBuildCachePath } from "./build-output.js";
 const CLEAN_ICON = '🧹';
 const CLEAN_COMMAND = 'clean';
 const BUILT_IN_CLEAN = 'nmr-clean';
@@ -21,9 +22,11 @@ export async function runClean(cwd = process.cwd()) {
         monorepoRoot = findMonorepoRoot(cwd);
     }
     catch {
+        await clearCheckCache(cwd);
         await cleanPackage(cwd);
         return;
     }
+    await clearCheckCache(monorepoRoot);
     const workspacePackageDirs = getWorkspacePackageDirs(monorepoRoot);
     const packageDir = findContainingPackageDir(cwd, workspacePackageDirs);
     if (packageDir !== undefined) {
@@ -32,8 +35,12 @@ export async function runClean(cwd = process.cwd()) {
     }
     await sweepWorkspace(monorepoRoot, workspacePackageDirs);
 }
+async function clearCheckCache(scopeDir) {
+    await removeCheckCache(scopeDir);
+    console.info(`${CLEAN_ICON} Removed all recorded check results.`);
+}
 async function sweepWorkspace(monorepoRoot, workspacePackageDirs) {
-    const config = await loadConfig(monorepoRoot);
+    const config = await loadRootConfig(monorepoRoot);
     const registry = buildWorkspaceRegistry(config);
     for (const packageDir of workspacePackageDirs) {
         const resolved = resolveScript(CLEAN_COMMAND, registry, packageDir, false);

package/dist/esm/config.d.ts

@@ -1,7 +1,5 @@
-export interface NmrConfig {
-    devBin?: Record<string, string>;
-    workspaceScripts?: Record<string, string | string[]>;
-    rootScripts?: Record<string, string | string[]>;
-}
-export declare function defineConfig(config: NmrConfig): NmrConfig;
-export declare function loadConfig(monorepoRoot: string): Promise<NmrConfig>;
+import type { NmrConfig } from './types.js';
+export declare function resolveConfigPath(baseDir: string): string;
+export declare function loadConfig(baseDir: string): Promise<NmrConfig>;
+export declare function loadRootConfig(monorepoRoot: string): Promise<NmrConfig>;
+export declare function loadWorkspaceConfig(packageDir: string): Promise<NmrConfig>;