@williamthorsen/nmr 0.16.0 → 0.17.0

package/dist/esm/commands/sync-agent-files.js

@@ -1,64 +1,58 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readPackageVersion } from "@williamthorsen/nmr-core";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPackageVersion } from '@williamthorsen/nmr-core';
 const VERSION = readPackageVersion(import.meta.url);
-const PACKAGE_NAME = "@williamthorsen/nmr";
-const DESTINATION_RELATIVE_PATH = ".agents/nmr/AGENTS.md";
-const SOURCE_FILENAME = "AGENTS.md";
+const PACKAGE_NAME = '@williamthorsen/nmr';
+const DESTINATION_RELATIVE_PATH = '.agents/nmr/AGENTS.md';
+const SOURCE_FILENAME = 'AGENTS.md';
 const FRONTMATTER_REGEX = /^---\n((?:.*\n)*?)---\n/;
-function check(destinationDir) {
-  const destinationPath = getDestinationPath(destinationDir);
-  if (!existsSync(destinationPath)) {
-    return {
-      ok: false,
-      reason: `${DESTINATION_RELATIVE_PATH} is missing. Run \`nmr sync-agent-files\`.`
-    };
-  }
-  const expectedBody = stripFrontmatter(readFileSync(getSourcePath(), "utf8"));
-  const foundBody = stripFrontmatter(readFileSync(destinationPath, "utf8"));
-  if (foundBody !== expectedBody) {
-    return {
-      ok: false,
-      reason: `${DESTINATION_RELATIVE_PATH} content is out of date. Run \`nmr sync-agent-files\`.`
-    };
-  }
-  return { ok: true };
+export function check(destinationDir) {
+    const destinationPath = getDestinationPath(destinationDir);
+    if (!existsSync(destinationPath)) {
+        return {
+            ok: false,
+            reason: `${DESTINATION_RELATIVE_PATH} is missing. Run \`nmr sync-agent-files\`.`,
+        };
+    }
+    const expectedBody = stripFrontmatter(readFileSync(getSourcePath(), 'utf8'));
+    const foundBody = stripFrontmatter(readFileSync(destinationPath, 'utf8'));
+    if (foundBody !== expectedBody) {
+        return {
+            ok: false,
+            reason: `${DESTINATION_RELATIVE_PATH} content is out of date. Run \`nmr sync-agent-files\`.`,
+        };
+    }
+    return { ok: true };
 }
-function sync(destinationDir) {
-  const body = stripFrontmatter(readFileSync(getSourcePath(), "utf8"));
-  const packageSpecifier = buildPackageSpecifier();
-  const destinationPath = getDestinationPath(destinationDir);
-  if (existsSync(destinationPath) && stripFrontmatter(readFileSync(destinationPath, "utf8")) === body) {
-    return { path: destinationPath, packageSpecifier, changed: false };
-  }
-  const output = `---
-source: '${packageSpecifier}'
----
-${body}`;
-  mkdirSync(path.dirname(destinationPath), { recursive: true });
-  writeFileSync(destinationPath, output, "utf8");
-  return { path: destinationPath, packageSpecifier, changed: true };
+export function sync(destinationDir) {
+    const body = stripFrontmatter(readFileSync(getSourcePath(), 'utf8'));
+    const packageSpecifier = buildPackageSpecifier();
+    const destinationPath = getDestinationPath(destinationDir);
+    if (existsSync(destinationPath) && stripFrontmatter(readFileSync(destinationPath, 'utf8')) === body) {
+        return { path: destinationPath, packageSpecifier, changed: false };
+    }
+    const output = `---\nsource: '${packageSpecifier}'\n---\n${body}`;
+    mkdirSync(path.dirname(destinationPath), { recursive: true });
+    writeFileSync(destinationPath, output, 'utf8');
+    return { path: destinationPath, packageSpecifier, changed: true };
 }
 function buildPackageSpecifier() {
-  return `${PACKAGE_NAME}@${VERSION}`;
+    return `${PACKAGE_NAME}@${VERSION}`;
 }
 function getDestinationPath(destinationDir) {
-  return path.join(destinationDir, DESTINATION_RELATIVE_PATH);
+    return path.join(destinationDir, DESTINATION_RELATIVE_PATH);
 }
 function getSourcePath() {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
-  while (dir !== path.dirname(dir)) {
-    const candidate = path.join(dir, SOURCE_FILENAME);
-    if (existsSync(candidate)) return candidate;
-    dir = path.dirname(dir);
-  }
-  throw new Error(`Could not locate ${SOURCE_FILENAME} in any parent of ${fileURLToPath(import.meta.url)}`);
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    while (dir !== path.dirname(dir)) {
+        const candidate = path.join(dir, SOURCE_FILENAME);
+        if (existsSync(candidate))
+            return candidate;
+        dir = path.dirname(dir);
+    }
+    throw new Error(`Could not locate ${SOURCE_FILENAME} in any parent of ${fileURLToPath(import.meta.url)}`);
 }
 function stripFrontmatter(content) {
-  return content.replace(FRONTMATTER_REGEX, "");
+    return content.replace(FRONTMATTER_REGEX, '');
 }
-export {
-  check,
-  sync
-};

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

@@ -1,47 +1,40 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { parseDocument } from "yaml";
+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";
+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;
+    if (!packageManager) {
+        return null;
+    }
+    const match = /^pnpm@(.+)$/.exec(packageManager);
+    return match?.[1] ?? null;
 }
-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
-packageManager 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}
-${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(`\u2713 Updated ${outdatedNodes.length} pnpm-version occurrence(s) \u2192 ${pnpmVersion}`);
+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,
-  syncPnpmVersion
-};
+export { extractPnpmVersion };

package/dist/esm/config.js

@@ -1,70 +1,72 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { createJiti } from "jiti";
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { createJiti } from 'jiti';
 import { isObject } from "./helpers/type-guards.js";
-const CONFIG_FILENAME = "nmr.config.ts";
-const CONFIG_DIR = ".config";
-function defineConfig(config) {
-  return config;
+const CONFIG_FILENAME = 'nmr.config.ts';
+const CONFIG_DIR = '.config';
+export function defineConfig(config) {
+    return config;
 }
 function isScriptRecord(value) {
-  if (!isObject(value)) return false;
-  for (const v of Object.values(value)) {
-    if (typeof v !== "string" && !Array.isArray(v)) return false;
-    if (Array.isArray(v) && v.some((item) => typeof item !== "string")) return false;
-  }
-  return true;
+    if (!isObject(value))
+        return false;
+    for (const v of Object.values(value)) {
+        if (typeof v !== 'string' && !Array.isArray(v))
+            return false;
+        if (Array.isArray(v) && v.some((item) => typeof item !== 'string'))
+            return false;
+    }
+    return true;
 }
 function validateScriptField(value, fieldName, configPath) {
-  if (!(fieldName in value) || value[fieldName] === void 0) {
-    return void 0;
-  }
-  if (!isScriptRecord(value[fieldName])) {
-    throw new Error(
-      `Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | string[]>`
-    );
-  }
-  return value[fieldName];
+    if (!(fieldName in value) || value[fieldName] === undefined) {
+        return undefined;
+    }
+    if (!isScriptRecord(value[fieldName])) {
+        throw new Error(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string | string[]>`);
+    }
+    return value[fieldName];
 }
 function isStringRecord(value) {
-  if (!isObject(value)) return false;
-  for (const v of Object.values(value)) {
-    if (typeof v !== "string") return false;
-  }
-  return true;
+    if (!isObject(value))
+        return false;
+    for (const v of Object.values(value)) {
+        if (typeof v !== 'string')
+            return false;
+    }
+    return true;
 }
 function validateStringRecordField(value, fieldName, configPath) {
-  if (!(fieldName in value) || value[fieldName] === void 0) {
-    return void 0;
-  }
-  if (!isStringRecord(value[fieldName])) {
-    throw new Error(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string>`);
-  }
-  return value[fieldName];
+    if (!(fieldName in value) || value[fieldName] === undefined) {
+        return undefined;
+    }
+    if (!isStringRecord(value[fieldName])) {
+        throw new Error(`Invalid nmr config at ${configPath}: \`${fieldName}\` must be a Record<string, string>`);
+    }
+    return value[fieldName];
 }
 function validateConfig(value, configPath) {
-  if (!isObject(value)) {
-    throw new Error(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
-  }
-  const config = {};
-  const devBin = validateStringRecordField(value, "devBin", configPath);
-  if (devBin) config.devBin = devBin;
-  const workspaceScripts = validateScriptField(value, "workspaceScripts", configPath);
-  if (workspaceScripts) config.workspaceScripts = workspaceScripts;
-  const rootScripts = validateScriptField(value, "rootScripts", configPath);
-  if (rootScripts) config.rootScripts = rootScripts;
-  return config;
+    if (!isObject(value)) {
+        throw new Error(`Invalid nmr config at ${configPath}: expected an object, got ${typeof value}`);
+    }
+    const config = {};
+    const devBin = validateStringRecordField(value, 'devBin', configPath);
+    if (devBin)
+        config.devBin = devBin;
+    const workspaceScripts = validateScriptField(value, 'workspaceScripts', configPath);
+    if (workspaceScripts)
+        config.workspaceScripts = workspaceScripts;
+    const rootScripts = validateScriptField(value, 'rootScripts', configPath);
+    if (rootScripts)
+        config.rootScripts = rootScripts;
+    return config;
 }
-async function loadConfig(monorepoRoot) {
-  const configPath = path.join(monorepoRoot, CONFIG_DIR, CONFIG_FILENAME);
-  if (!existsSync(configPath)) {
-    return {};
-  }
-  const jiti = createJiti(path.join(monorepoRoot, "package.json"));
-  const loaded = await jiti.import(configPath, { default: true });
-  return validateConfig(loaded, configPath);
+export async function loadConfig(monorepoRoot) {
+    const configPath = path.join(monorepoRoot, CONFIG_DIR, CONFIG_FILENAME);
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    const jiti = createJiti(path.join(monorepoRoot, 'package.json'));
+    const loaded = await jiti.import(configPath, { default: true });
+    return validateConfig(loaded, configPath);
 }
-export {
-  defineConfig,
-  loadConfig
-};

package/dist/esm/context.d.ts

@@ -1,4 +1,4 @@
-import type { NmrConfig } from './config.ts';
+import type { NmrConfig } from './config.js';
 export interface ResolvedContext {
     monorepoRoot: string;
     isRoot: boolean;

package/dist/esm/context.js

@@ -1,84 +1,82 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { parse } from "yaml";
+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";
-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");
+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;
     }
-    dir = parent;
-  }
 }
-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);
-          }
+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);
+            }
         }
-      }
-    } else if (!pattern.includes("*")) {
-      const fullPath = path.resolve(monorepoRoot, pattern);
-      if (existsSync(fullPath) && existsSync(path.join(fullPath, "package.json"))) {
-        dirs.push(fullPath);
-      }
     }
-  }
-  return dirs;
+    return dirs;
 }
-function findContainingPackageDir(dir, workspacePackageDirs) {
-  const resolved = path.resolve(dir);
-  for (const pkgDir of workspacePackageDirs) {
-    const resolvedPkgDir = path.resolve(pkgDir);
-    if (resolved === resolvedPkgDir || resolved.startsWith(resolvedPkgDir + path.sep)) {
-      return resolvedPkgDir;
+export function findContainingPackageDir(dir, workspacePackageDirs) {
+    const resolved = path.resolve(dir);
+    for (const pkgDir of workspacePackageDirs) {
+        const resolvedPkgDir = path.resolve(pkgDir);
+        if (resolved === resolvedPkgDir || resolved.startsWith(resolvedPkgDir + path.sep)) {
+            return resolvedPkgDir;
+        }
     }
-  }
-  return void 0;
+    return undefined;
 }
 function getPackagesFromParsedYaml(parsed) {
-  if (!isObject(parsed)) return void 0;
-  const packages = parsed.packages;
-  if (!Array.isArray(packages)) return void 0;
-  if (!packages.every((p) => typeof p === "string")) return void 0;
-  return packages;
+    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;
 }
-async function resolveContext(cwd) {
-  const resolvedCwd = path.resolve(cwd ?? process.cwd());
-  const monorepoRoot = findMonorepoRoot(resolvedCwd);
-  const config = await loadConfig(monorepoRoot);
-  const workspaceDirs = getWorkspacePackageDirs(monorepoRoot);
-  const packageDir = findContainingPackageDir(resolvedCwd, workspaceDirs);
-  return {
-    monorepoRoot,
-    isRoot: packageDir === void 0,
-    ...packageDir === void 0 ? {} : { packageDir },
-    config
-  };
+export async function resolveContext(cwd) {
+    const resolvedCwd = path.resolve(cwd ?? process.cwd());
+    const monorepoRoot = findMonorepoRoot(resolvedCwd);
+    const config = await loadConfig(monorepoRoot);
+    const workspaceDirs = getWorkspacePackageDirs(monorepoRoot);
+    const packageDir = findContainingPackageDir(resolvedCwd, workspaceDirs);
+    return {
+        monorepoRoot,
+        isRoot: packageDir === undefined,
+        ...(packageDir === undefined ? {} : { packageDir }),
+        config,
+    };
 }
-export {
-  findContainingPackageDir,
-  findMonorepoRoot,
-  getWorkspacePackageDirs,
-  resolveContext
-};

package/dist/esm/default-scripts.js

@@ -1,72 +1,67 @@
-const commonWorkspaceScripts = {
-  build: ["compile", "generate-typings"],
-  check: ["typecheck", "fmt:check", "lint:check", "test"],
-  "check:strict": ["typecheck", "fmt:check", "lint:strict", "test:coverage"],
-  clean: "pnpm exec rimraf dist/*",
-  compile: "nmr-compile",
-  fix: ["lint", "fmt"],
-  "fix:check": ["fmt:check", "lint:check"],
-  fmt: "prettier --list-different --write .",
-  "fmt:check": "prettier --check .",
-  "generate-typings": "tsc --project tsconfig.generate-typings.json",
-  lint: "eslint --fix .",
-  "lint:check": "eslint .",
-  "lint:strict": "strict-lint",
-  typecheck: "tsgo --noEmit",
-  "view-coverage": "open coverage/index.html"
+export const commonWorkspaceScripts = {
+    attw: 'attw --pack --profile esm-only',
+    build: ['compile'],
+    check: ['typecheck', 'fmt:check', 'lint:check', 'test'],
+    'check:strict': ['typecheck', 'fmt:check', 'lint:strict', 'test:coverage', 'attw'],
+    clean: 'pnpm exec rimraf dist/*',
+    compile: 'nmr-compile',
+    fix: ['lint', 'fmt'],
+    'fix:check': ['fmt:check', 'lint:check'],
+    fmt: 'prettier --list-different --write .',
+    'fmt:check': 'prettier --check .',
+    lint: 'eslint --fix .',
+    'lint:check': 'eslint .',
+    'lint:strict': 'strict-lint',
+    typecheck: 'tsgo --noEmit',
+    'view-coverage': 'open coverage/index.html',
 };
-const integrationTestScripts = {
-  test: "pnpm exec vitest --config=vitest.standalone.config.ts",
-  "test:all": "pnpm exec vitest",
-  "test:coverage": "pnpm exec vitest --config=vitest.standalone.config.ts --coverage",
-  "test:integration": "pnpm exec vitest --config=vitest.integration.config.ts",
-  "test:watch": "pnpm exec vitest --config=vitest.standalone.config.ts --watch"
+export const integrationTestScripts = {
+    test: 'pnpm exec vitest --config=vitest.standalone.config.ts',
+    'test:all': 'pnpm exec vitest',
+    'test:coverage': 'pnpm exec vitest --config=vitest.standalone.config.ts --coverage',
+    'test:integration': 'pnpm exec vitest --config=vitest.integration.config.ts',
+    'test:watch': 'pnpm exec vitest --config=vitest.standalone.config.ts --watch',
 };
-const standardTestScripts = {
-  test: "pnpm exec vitest",
-  "test:coverage": "pnpm exec vitest --coverage",
-  "test:watch": "pnpm exec vitest --watch"
+export const standardTestScripts = {
+    test: 'pnpm exec vitest',
+    'test:coverage': 'pnpm exec vitest --coverage',
+    'test:watch': 'pnpm exec vitest --watch',
 };
-const rootScripts = {
-  audit: ["audit:prod", "audit:dev"],
-  "audit:dev": "pnpm exec v11y --dev",
-  "audit:prod": "pnpm exec v11y --prod",
-  build: "pnpm --recursive exec nmr build",
-  check: ["typecheck", "fmt:check", "lint:check", "test"],
-  "check:agent-files": "nmr-sync-agent-files --check",
-  "check:strict": ["typecheck", "fmt:check", "lint:strict", "test:coverage", "check:agent-files"],
-  ci: ["build", "check:strict", "audit"],
-  clean: "pnpm --recursive exec nmr clean",
-  fix: ["lint", "fmt"],
-  "fix:check": ["fmt:check", "lint:check"],
-  fmt: `sh -c 'prettier --list-different --write "\${@:-.}"' --`,
-  "fmt:all": ["fmt", "fmt:sh"],
-  "fmt:check": `sh -c 'prettier --check "\${@:-.}"' --`,
-  "fmt:sh": "shfmt --write **/*.sh",
-  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/**' .",
-  "root:lint:check": "eslint --ignore-pattern 'packages/**' .",
-  "root:lint:strict": "strict-lint --ignore-pattern 'packages/**' .",
-  "root:test": "vitest --config ./vitest.root.config.ts",
-  "root:typecheck": "tsgo --noEmit",
-  "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"
-};
-export {
-  commonWorkspaceScripts,
-  integrationTestScripts,
-  rootScripts,
-  standardTestScripts
+export const rootScripts = {
+    attw: 'pnpm --recursive exec nmr attw',
+    audit: ['audit:prod', 'audit:dev'],
+    'audit:dev': 'pnpm exec v11y --dev',
+    'audit:prod': 'pnpm exec v11y --prod',
+    build: 'pnpm --recursive exec nmr build',
+    check: ['typecheck', 'fmt:check', 'lint:check', 'test'],
+    'check:agent-files': 'nmr-sync-agent-files --check',
+    'check:strict': ['typecheck', 'fmt:check', 'lint:strict', 'test:coverage', 'attw', 'check:agent-files'],
+    ci: ['build', 'check:strict', 'audit'],
+    clean: 'pnpm --recursive exec nmr clean',
+    fix: ['lint', 'fmt'],
+    'fix:check': ['fmt:check', 'lint:check'],
+    fmt: 'sh -c \'prettier --list-different --write "${@:-.}"\' --',
+    'fmt:all': ['fmt', 'fmt:sh'],
+    'fmt:check': 'sh -c \'prettier --check "${@:-.}"\' --',
+    'fmt:sh': 'shfmt --write **/*.sh',
+    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/**' .",
+    'root:lint:check': "eslint --ignore-pattern 'packages/**' .",
+    'root:lint:strict': "strict-lint --ignore-pattern 'packages/**' .",
+    'root:test': 'vitest --config ./vitest.root.config.ts',
+    'root:typecheck': 'tsgo --noEmit',
+    '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',
 };