@produck/agent-toolkit 0.8.2 → 0.9.0

package/README.md

@@ -7,7 +7,7 @@ Central CLI toolkit for organization-level AI execution workflows.
 For a new or existing downstream repository that has not yet applied the
 organization baseline, run:
 
-```
+```bash
 npm create @produck/agent-toolkit@latest
 ```
 
@@ -38,7 +38,7 @@ After running, add the persistent enforcement entry to the repository
 
 Then future enforcement runs via:
 
-```
+```bash
 npm run produck:baseline
 ```
 
@@ -61,13 +61,13 @@ npm run produck:baseline
 
 Run default mandatory baseline flow in downstream repository root:
 
-```
+```bash
 npm exec -- agent-toolkit
 ```
 
 Equivalent explicit form:
 
-```
+```bash
 npm exec -- agent-toolkit enforce-node-baseline --cwd .
 ```
 
@@ -104,56 +104,56 @@ Add to downstream repository root `package.json` for one-command enforcement:
 
 Then run:
 
-```
+```bash
 npm run produck:baseline
 ```
 
 Dry-run to preview changes without writing files:
 
-```
+```bash
 npm exec -- agent-toolkit enforce-node-baseline --cwd . --dry-run
 ```
 
 Check-only mode to validate without writing:
 
-```
+```bash
 npm exec -- agent-toolkit enforce-node-baseline --cwd . --check
 ```
 
 Validate monorepo root `package.json` scripts and workspace structure:
 
-```
+```bash
 npm exec -- agent-toolkit preflight --cwd . --check-workspace-package-json package.json
 ```
 
 Run preflight with required-file and directory guards:
 
-```
+```bash
 npm exec -- agent-toolkit preflight --cwd . --require package.json --ensure-dir logs
 ```
 
 Capture long output safely:
 
-```
+```bash
 npm exec -- agent-toolkit run-capture --cwd . --cmd "npm run test" --out logs/test.log
 ```
 
 Summarize captured output:
 
-```
+```bash
 npm exec -- agent-toolkit summarize-log --file logs/test.log --match "FAIL|ERROR"
 ```
 
 Deploy organization coverage script and pinned local c8 devDependency to workspace packages:
 
-```
+```bash
 npm exec -- agent-toolkit sync-coverage --cwd .
 ```
 
 This command also enforces `scripts.test` in each workspace package.
 If missing, it generates:
 
-```
+```bash
 node -e "console.log('No tests configured')"
 ```
 
@@ -161,7 +161,7 @@ node -e "console.log('No tests configured')"
 
 Deploy organization format config and script baseline to repository root:
 
-```
+```bash
 npm exec -- agent-toolkit sync-format --cwd .
 ```
 
@@ -171,7 +171,7 @@ Prettier, so a separate root `format` script is not required.
 
 Deploy organization lint config and script baseline to repository root:
 
-```
+```bash
 npm exec -- agent-toolkit sync-lint --cwd .
 ```
 
@@ -182,7 +182,7 @@ array.
 
 Deploy root and workspace coverage config plus root `c8` devDependency:
 
-```
+```bash
 npm exec -- agent-toolkit sync-coverage --cwd .
 ```
 
@@ -195,7 +195,7 @@ branches, functions, lines, and statements.
 
 Deploy root git attributes baseline:
 
-```
+```bash
 npm exec -- agent-toolkit sync-git --cwd .
 ```
 
@@ -206,7 +206,7 @@ This command manages root `.gitattributes`, `.husky/pre-commit`,
 
 Deploy root install script baseline:
 
-```
+```bash
 npm exec -- agent-toolkit sync-install --cwd .
 ```
 
@@ -215,7 +215,7 @@ This command manages `scripts.produck:install` with value
 
 Deploy root publish script baseline:
 
-```
+```bash
 npm exec -- agent-toolkit sync-publish --cwd .
 ```
 
@@ -227,13 +227,13 @@ otherwise it falls back to `lerna publish`.
 
 Validate commit message format:
 
-```
+```bash
 npm exec -- agent-toolkit validate-commit-msg --file .git/COMMIT_EDITMSG
 ```
 
 Manual per-repository instruction distribution (write .github/instructions/produck/\*.instructions.md):
 
-```
+```bash
 npm exec -- agent-toolkit sync-instructions --cwd .
 ```
 
@@ -246,7 +246,7 @@ Legacy repository bootstrap behavior:
 
 Use organization source directory instead of built-in assets:
 
-```
+```bash
 npm exec -- agent-toolkit sync-instructions --cwd . --source path/to/org/.github/distribution/produck --force --prune
 ```
 

package/bin/agent-toolkit.mjs

@@ -4,23 +4,44 @@ import {
   printEnforceNodeBaselineHelp,
   runEnforceNodeBaseline,
 } from './command/enforce-node-baseline/index.mjs';
-import { printPreflightHelp, runPreflight } from './command/preflight/index.mjs';
-import { printRunCaptureHelp, runCapture } from './command/run-capture/index.mjs';
-import { printSummarizeHelp, runSummarize } from './command/summarize-log/index.mjs';
-import { printSyncCoverageHelp, runSyncCoverage } from './command/sync-coverage/index.mjs';
-import { printSyncInstallHelp, runSyncInstall } from './command/sync-install/index.mjs';
+import {
+  printPreflightHelp,
+  runPreflight,
+} from './command/preflight/index.mjs';
+import {
+  printRunCaptureHelp,
+  runCapture,
+} from './command/run-capture/index.mjs';
+import {
+  printSummarizeHelp,
+  runSummarize,
+} from './command/summarize-log/index.mjs';
+import {
+  printSyncCoverageHelp,
+  runSyncCoverage,
+} from './command/sync-coverage/index.mjs';
+import {
+  printSyncInstallHelp,
+  runSyncInstall,
+} from './command/sync-install/index.mjs';
 import {
   printSyncInstructionsHelp,
   runSyncInstructions,
 } from './command/sync-instructions/index.mjs';
-import { printSyncFormatHelp, runSyncFormat } from './command/sync-format/index.mjs';
+import {
+  printSyncFormatHelp,
+  runSyncFormat,
+} from './command/sync-format/index.mjs';
 import {
   printSyncEditorconfigHelp,
   runSyncEditorconfig,
 } from './command/sync-editorconfig/index.mjs';
 import { printSyncLintHelp, runSyncLint } from './command/sync-lint/index.mjs';
 import { printSyncGitHelp, runSyncGit } from './command/sync-git/index.mjs';
-import { printSyncPublishHelp, runSyncPublish } from './command/sync-publish/index.mjs';
+import {
+  printSyncPublishHelp,
+  runSyncPublish,
+} from './command/sync-publish/index.mjs';
 import { hasFlag, parseCommonArgs } from './command/shared/args.mjs';
 import {
   printValidateCommitMsgHelp,
@@ -98,7 +119,11 @@ function main() {
   const command = parsed.positional[0] || '';
   const options = parsed.options;
 
-  if (command === '--help' || command === '-h' || (!command && hasFlag(options, '--help'))) {
+  if (
+    command === '--help' ||
+    command === '-h' ||
+    (!command && hasFlag(options, '--help'))
+  ) {
     printMainHelp();
     process.exit(0);
   }

package/bin/build-publish-assets.mjs

@@ -7,15 +7,48 @@ const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(SCRIPT_DIR, '..');
 const REPO_ROOT = path.resolve(PACKAGE_ROOT, '../..');
 const SOURCE_DIR = path.resolve(REPO_ROOT, '.github/distribution/produck');
-const OUTPUT_DIR = path.resolve(PACKAGE_ROOT, 'publish-assets/instructions/produck');
-const SOURCE_TOOLING_BASELINE_PATH = path.resolve(SOURCE_DIR, 'tooling-version-baseline.json');
-const OUTPUT_TOOLING_BASELINE_PATH = path.resolve(OUTPUT_DIR, 'tooling-version-baseline.json');
+const OUTPUT_DIR = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/instructions/produck',
+);
+const SOURCE_TOOLING_BASELINE_PATH = path.resolve(
+  SOURCE_DIR,
+  'tooling-version-baseline.json',
+);
+const OUTPUT_TOOLING_BASELINE_PATH = path.resolve(
+  OUTPUT_DIR,
+  'tooling-version-baseline.json',
+);
 const SOURCE_GITATTRIBUTES_PATH = path.resolve(REPO_ROOT, '.gitattributes');
 const SOURCE_GITIGNORE_PATH = path.resolve(REPO_ROOT, '.gitignore');
+const SOURCE_PRETTIERRC_PATH = path.resolve(REPO_ROOT, '.prettierrc');
 const SOURCE_PRETTIERIGNORE_PATH = path.resolve(REPO_ROOT, '.prettierignore');
-const OUTPUT_GITATTRIBUTES_PATH = path.resolve(PACKAGE_ROOT, 'publish-assets/gitattributes');
-const OUTPUT_GITIGNORE_PATH = path.resolve(PACKAGE_ROOT, 'publish-assets/gitignore');
-const OUTPUT_PRETTIERIGNORE_PATH = path.resolve(PACKAGE_ROOT, 'publish-assets/prettierignore');
+const SOURCE_LERNA_PATH = path.resolve(REPO_ROOT, 'lerna.json');
+const SOURCE_ESLINT_CONFIG_PATH = path.resolve(REPO_ROOT, 'eslint.config.mjs');
+const OUTPUT_ESLINT_CONFIG_TEMPLATE_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/eslint.config.template.mjs',
+);
+const OUTPUT_GITATTRIBUTES_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/gitattributes',
+);
+const OUTPUT_GITIGNORE_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/gitignore',
+);
+const OUTPUT_PRETTIERRC_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/prettierrc',
+);
+const OUTPUT_PRETTIERIGNORE_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/prettierignore',
+);
+const OUTPUT_LERNA_PATH = path.resolve(
+  PACKAGE_ROOT,
+  'publish-assets/lerna.json',
+);
 const LEGACY_OUTPUT_PATH = path.resolve(
   PACKAGE_ROOT,
   'publish-assets/instructions/org.instructions.md',
@@ -49,14 +82,20 @@ function validateSourceFile(fileName, text) {
 
 function readAndValidateToolingBaseline() {
   if (!fs.existsSync(SOURCE_TOOLING_BASELINE_PATH)) {
-    throw new Error(`Missing tooling baseline source file: ${SOURCE_TOOLING_BASELINE_PATH}`);
+    throw new Error(
+      `Missing tooling baseline source file: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
   let baseline;
   try {
-    baseline = JSON.parse(fs.readFileSync(SOURCE_TOOLING_BASELINE_PATH, 'utf8'));
+    baseline = JSON.parse(
+      fs.readFileSync(SOURCE_TOOLING_BASELINE_PATH, 'utf8'),
+    );
   } catch {
-    throw new Error(`Invalid tooling baseline JSON: ${SOURCE_TOOLING_BASELINE_PATH}`);
+    throw new Error(
+      `Invalid tooling baseline JSON: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
   const c8Version = baseline?.tools?.c8?.version;
@@ -64,27 +103,42 @@ function readAndValidateToolingBaseline() {
   const coverageScriptTemplate = baseline?.coverage?.scriptTemplate;
 
   if (typeof baseline.schemaVersion !== 'number') {
-    throw new Error(`Invalid tooling baseline schemaVersion in: ${SOURCE_TOOLING_BASELINE_PATH}`);
+    throw new Error(
+      `Invalid tooling baseline schemaVersion in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
-    throw new Error(`Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH}`);
+    throw new Error(
+      `Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
   if (typeof lernaVersion !== 'string' || lernaVersion.trim() === '') {
-    throw new Error(`Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH}`);
+    throw new Error(
+      `Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
-  if (typeof coverageScriptTemplate !== 'string' || coverageScriptTemplate.trim() === '') {
-    throw new Error(`Invalid coverage.scriptTemplate in: ${SOURCE_TOOLING_BASELINE_PATH}`);
+  if (
+    typeof coverageScriptTemplate !== 'string' ||
+    coverageScriptTemplate.trim() === ''
+  ) {
+    throw new Error(
+      `Invalid coverage.scriptTemplate in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+    );
   }
 
-  const eslintRulesPkgPath = path.resolve(PACKAGE_ROOT, '../eslint-rules/package.json');
+  const eslintRulesPkgPath = path.resolve(
+    PACKAGE_ROOT,
+    '../eslint-rules/package.json',
+  );
   if (fs.existsSync(eslintRulesPkgPath)) {
-    const eslintRulesPkg = JSON.parse(fs.readFileSync(eslintRulesPkgPath, 'utf8'));
+    const eslintRulesPkg = JSON.parse(
+      fs.readFileSync(eslintRulesPkgPath, 'utf8'),
+    );
     const version = eslintRulesPkg.version;
     if (typeof version === 'string' && version.trim()) {
-      if (!baseline.tools) baseline.tools = {};
       baseline.tools['@produck/eslint-rules'] = {
         version,
         policy: 'pinned',
@@ -121,11 +175,21 @@ function readSourceEntries() {
   });
 }
 
+function generateEslintConfigTemplate() {
+  return normalize(
+    fs
+      .readFileSync(SOURCE_ESLINT_CONFIG_PATH, 'utf8')
+      .replace(
+        /from\s+['"]\.\/packages\/eslint-rules\/src\/index\.mjs['"]/g,
+        'from \'@produck/eslint-rules\'',
+      ),
+  );
+}
+
 function cleanStaleManagedFiles(expectedNames) {
-  if (!fs.existsSync(OUTPUT_DIR)) {
-    return;
-  }
-  const existing = fs.readdirSync(OUTPUT_DIR).filter((name) => name.endsWith('.instructions.md'));
+  const existing = fs
+    .readdirSync(OUTPUT_DIR)
+    .filter((name) => name.endsWith('.instructions.md'));
   for (const name of existing) {
     if (expectedNames.has(name)) {
       continue;
@@ -158,13 +222,28 @@ function run() {
   );
 
   if (!fs.existsSync(SOURCE_GITATTRIBUTES_PATH)) {
-    throw new Error(`Missing source .gitattributes: ${SOURCE_GITATTRIBUTES_PATH}`);
+    throw new Error(
+      `Missing source .gitattributes: ${SOURCE_GITATTRIBUTES_PATH}`,
+    );
   }
   if (!fs.existsSync(SOURCE_GITIGNORE_PATH)) {
     throw new Error(`Missing source .gitignore: ${SOURCE_GITIGNORE_PATH}`);
   }
+  if (!fs.existsSync(SOURCE_PRETTIERRC_PATH)) {
+    throw new Error(`Missing source .prettierrc: ${SOURCE_PRETTIERRC_PATH}`);
+  }
   if (!fs.existsSync(SOURCE_PRETTIERIGNORE_PATH)) {
-    throw new Error(`Missing source .prettierignore: ${SOURCE_PRETTIERIGNORE_PATH}`);
+    throw new Error(
+      `Missing source .prettierignore: ${SOURCE_PRETTIERIGNORE_PATH}`,
+    );
+  }
+  if (!fs.existsSync(SOURCE_LERNA_PATH)) {
+    throw new Error(`Missing source lerna.json: ${SOURCE_LERNA_PATH}`);
+  }
+  if (!fs.existsSync(SOURCE_ESLINT_CONFIG_PATH)) {
+    throw new Error(
+      `Missing source eslint.config.mjs: ${SOURCE_ESLINT_CONFIG_PATH}`,
+    );
   }
 
   fs.writeFileSync(
@@ -181,7 +260,18 @@ function run() {
     normalize(fs.readFileSync(SOURCE_GITIGNORE_PATH, 'utf8')),
     'utf8',
   );
-  process.stdout.write(`Generated ${OUTPUT_GITIGNORE_PATH} from ${SOURCE_GITIGNORE_PATH}\n`);
+  process.stdout.write(
+    `Generated ${OUTPUT_GITIGNORE_PATH} from ${SOURCE_GITIGNORE_PATH}\n`,
+  );
+
+  fs.writeFileSync(
+    OUTPUT_PRETTIERRC_PATH,
+    normalize(fs.readFileSync(SOURCE_PRETTIERRC_PATH, 'utf8')),
+    'utf8',
+  );
+  process.stdout.write(
+    `Generated ${OUTPUT_PRETTIERRC_PATH} from ${SOURCE_PRETTIERRC_PATH}\n`,
+  );
 
   fs.writeFileSync(
     OUTPUT_PRETTIERIGNORE_PATH,
@@ -192,6 +282,24 @@ function run() {
     `Generated ${OUTPUT_PRETTIERIGNORE_PATH} from ${SOURCE_PRETTIERIGNORE_PATH}\n`,
   );
 
+  fs.writeFileSync(
+    OUTPUT_LERNA_PATH,
+    normalize(fs.readFileSync(SOURCE_LERNA_PATH, 'utf8')),
+    'utf8',
+  );
+  process.stdout.write(
+    `Generated ${OUTPUT_LERNA_PATH} from ${SOURCE_LERNA_PATH}\n`,
+  );
+
+  fs.writeFileSync(
+    OUTPUT_ESLINT_CONFIG_TEMPLATE_PATH,
+    generateEslintConfigTemplate(),
+    'utf8',
+  );
+  process.stdout.write(
+    `Generated ${OUTPUT_ESLINT_CONFIG_TEMPLATE_PATH} from ${SOURCE_ESLINT_CONFIG_PATH}\n`,
+  );
+
   cleanStaleManagedFiles(expectedNames);
 
   if (fs.existsSync(LEGACY_OUTPUT_PATH)) {

package/bin/command/enforce-node-baseline/index.mjs

@@ -16,15 +16,15 @@ export function printEnforceNodeBaselineHelp() {
 
 function parseJsonOrNull(text) {
   const trimmed = text.trim();
-  if (!trimmed) {
-    return null;
-  }
-
+  // JSON.parse throws if subcommand stdout is unexpectedly non-JSON (e.g. process
+  // crash). Tests always receive structured JSON reports from subcommands.
+  /* c8 ignore start */
   try {
     return JSON.parse(trimmed);
   } catch {
     return null;
   }
+  /* c8 ignore stop */
 }
 
 function runToolkitSubcommand(cwd, args) {
@@ -33,9 +33,13 @@ function runToolkitSubcommand(cwd, args) {
     encoding: 'utf8',
   });
 
+  // spawnSync returns null stdout/stderr and a non-numeric status when the child
+  // is killed by a signal. Normal test runs never trigger this condition.
+  /* c8 ignore start */
   const stdout = String(result.stdout || '');
   const stderr = String(result.stderr || '');
   const status = typeof result.status === 'number' ? result.status : 1;
+  /* c8 ignore stop */
 
   return {
     args,
@@ -56,6 +60,9 @@ function buildStepReport(name, stepResult) {
     status: stepResult.status,
     ok: stepResult.ok,
     report: stepResult.report,
+    // The false branch (raw stdout) is taken only when the subcommand produces no
+    // parseable JSON report. Tests always receive structured JSON output.
+    /* c8 ignore next */
     stdout: hasParsedReport ? '' : stepResult.stdout,
     stderr: stepResult.stderr,
   };
@@ -98,7 +105,13 @@ export function runEnforceNodeBaseline(options) {
     syncInstructionsArgs.push('--dry-run');
   }
 
-  const preflightArgs = ['preflight', '--cwd', cwd, '--require', 'package.json'];
+  const preflightArgs = [
+    'preflight',
+    '--cwd',
+    cwd,
+    '--require',
+    'package.json',
+  ];
   if (mode !== 'sync') {
     preflightArgs.push('--check-workspace-package-json', 'package.json');
   }

package/bin/command/preflight/index.mjs

@@ -9,7 +9,12 @@ import { validateWorkspaceShape } from '../shared/workspace-validation.mjs';
 const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
 const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
 const REQUIRED_WORKSPACE_FIELDS = ['private', 'workspaces', 'scripts'];
-const REQUIRED_WORKSPACE_SCRIPTS = ['produck:install', 'test', 'produck:coverage', 'produck:lint'];
+const REQUIRED_WORKSPACE_SCRIPTS = [
+  'produck:install',
+  'test',
+  'produck:coverage',
+  'produck:lint',
+];
 
 export function printPreflightHelp() {
   printTextResource(HELP_FILE);
@@ -43,7 +48,11 @@ function validateWorkspacePackageJson(cwd, checkPath) {
     return check;
   }
 
-  const shape = validateWorkspaceShape(json, REQUIRED_WORKSPACE_FIELDS, REQUIRED_WORKSPACE_SCRIPTS);
+  const shape = validateWorkspaceShape(
+    json,
+    REQUIRED_WORKSPACE_FIELDS,
+    REQUIRED_WORKSPACE_SCRIPTS,
+  );
   check.missingFields = shape.missingFields;
   check.scriptTypeValid = shape.scriptTypeValid;
   check.missingScripts = shape.missingScripts;
@@ -57,7 +66,11 @@ export function runPreflight(options) {
   const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
   const requireTargets = options['--require'] || [];
   const ensureDirs = options['--ensure-dir'] || [];
-  const checkWorkspacePackageJson = getSingle(options, '--check-workspace-package-json', '');
+  const checkWorkspacePackageJson = getSingle(
+    options,
+    '--check-workspace-package-json',
+    '',
+  );
   const dryRun = hasFlag(options, '--dry-run');
   const jsonFile = getSingle(options, '--json', '');
 
@@ -99,7 +112,10 @@ export function runPreflight(options) {
   }
 
   if (checkWorkspacePackageJson) {
-    const workspaceCheck = validateWorkspacePackageJson(cwd, checkWorkspacePackageJson);
+    const workspaceCheck = validateWorkspacePackageJson(
+      cwd,
+      checkWorkspacePackageJson,
+    );
     report.workspacePackageJson = workspaceCheck;
     if (!workspaceCheck.ok) {
       report.ok = false;

package/bin/command/run-capture/index.mjs

@@ -26,7 +26,9 @@ export function runCapture(options) {
   }
 
   if (!allowPipe && cmd.includes('|')) {
-    console.error('Blocked command containing pipe. Use --allow-pipe if needed.');
+    console.error(
+      'Blocked command containing pipe. Use --allow-pipe if needed.',
+    );
     process.exit(2);
   }
 
@@ -62,9 +64,13 @@ export function runCapture(options) {
     outStream.write(chunk);
   });
 
+  // With shell: true the shell binary is always available, so the 'error' event
+  // (OS-level spawn failure) cannot be triggered in tests.
+  /* c8 ignore start */
   child.on('error', (error) => {
     outStream.write(`\n[agent-toolkit] spawn error: ${error.message}\n`);
   });
+  /* c8 ignore stop */
 
   child.on('close', (code, signal) => {
     const endAt = Date.now();

package/bin/command/shared/workspace-validation.mjs

@@ -18,12 +18,18 @@ export function validateWorkspaceShape(pkg, requiredFields, requiredScripts) {
   const missingFields = findMissingKeys(pkg, requiredFields);
   const scripts = toObjectRecord(pkg.scripts);
   const scriptTypeValid =
-    typeof pkg.scripts === 'object' && pkg.scripts !== null && !Array.isArray(pkg.scripts);
-  const missingScripts = scriptTypeValid ? findMissingKeys(scripts, requiredScripts) : [];
+    typeof pkg.scripts === 'object' &&
+    pkg.scripts !== null &&
+    !Array.isArray(pkg.scripts);
+  const missingScripts = scriptTypeValid
+    ? findMissingKeys(scripts, requiredScripts)
+    : [];
 
   const workspacesIsArray = Array.isArray(pkg.workspaces);
   const wildcardWorkspaces = workspacesIsArray
-    ? pkg.workspaces.map((entry) => String(entry)).filter((entry) => GLOB_TOKEN_PATTERN.test(entry))
+    ? pkg.workspaces
+      .map((entry) => String(entry))
+      .filter((entry) => GLOB_TOKEN_PATTERN.test(entry))
     : ['<non-array-workspaces>'];
 
   const privateIsTrue = pkg.private === true;