@produck/agent-toolkit 0.8.2 → 0.9.0

package/bin/command/sync-coverage/index.mjs

@@ -10,8 +10,14 @@ const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
 const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
 const REPO_ROOT = path.resolve(PACKAGE_ROOT, '../..');
 const TOOLING_BASELINE_CANDIDATE_PATHS = [
-  path.resolve(REPO_ROOT, '.github/distribution/produck/tooling-version-baseline.json'),
-  path.resolve(PACKAGE_ROOT, 'publish-assets/instructions/produck/tooling-version-baseline.json'),
+  path.resolve(
+    REPO_ROOT,
+    '.github/distribution/produck/tooling-version-baseline.json',
+  ),
+  path.resolve(
+    PACKAGE_ROOT,
+    'publish-assets/instructions/produck/tooling-version-baseline.json',
+  ),
 ];
 const GLOB_TOKEN_PATTERN = /[*?{}[\]]/;
 const REQUIRED_ROOT_COVERAGE_SCRIPT_KEY = 'produck:coverage';
@@ -19,23 +25,13 @@ const REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE =
   'c8 --config .c8rc.json npm run test --workspaces --if-present';
 const REQUIRED_COVERAGE_SCRIPT_KEY = 'produck:coverage';
 const REQUIRED_TEST_SCRIPT_KEY = 'test';
-const DEFAULT_TEST_SCRIPT_VALUE = 'node -e "console.log(\'No tests configured\')"';
+const DEFAULT_TEST_SCRIPT_VALUE =
+  'node -e "console.log(\'No tests configured\')"';
 const REQUIRED_C8_CONFIG_FILE = '.c8rc.json';
-const REQUIRED_C8_CONFIG_CONTENT = `${JSON.stringify(
-  {
-    'check-coverage': true,
-    all: true,
-    branches: 99.5,
-    exclude: ['**/node_modules/**', '**/coverage/**', '**/dist/**', '**/build/**', '**/out/**'],
-    functions: 99.5,
-    include: ['src/**', 'extension/**'],
-    reporter: ['lcov', 'html', 'text-summary'],
-    statements: 99.5,
-    lines: 99.5,
-  },
-  null,
-  2,
-)}\n`;
+const REQUIRED_C8_CONFIG_TEMPLATE_FILE = path.resolve(
+  COMMAND_DIR,
+  'required-c8-config.json',
+);
 
 export function printSyncCoverageHelp() {
   printTextResource(HELP_FILE);
@@ -51,12 +47,16 @@ function parseJsonFile(filePath, label) {
 }
 
 function loadToolingBaseline() {
-  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find((candidatePath) => {
-    return fs.existsSync(candidatePath);
-  });
+  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
+    (candidatePath) => {
+      return fs.existsSync(candidatePath);
+    },
+  );
 
   if (!toolingBaselinePath) {
-    console.error('Tooling baseline file does not exist in expected locations:');
+    console.error(
+      'Tooling baseline file does not exist in expected locations:',
+    );
     for (const candidatePath of TOOLING_BASELINE_CANDIDATE_PATHS) {
       console.error(`- ${candidatePath}`);
     }
@@ -65,7 +65,9 @@ function loadToolingBaseline() {
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
   if (typeof baseline.schemaVersion !== 'number') {
-    console.error(`Tooling baseline schemaVersion must be a number: ${toolingBaselinePath}`);
+    console.error(
+      `Tooling baseline schemaVersion must be a number: ${toolingBaselinePath}`,
+    );
     process.exit(2);
   }
 
@@ -109,6 +111,21 @@ function readFileIfExists(filePath) {
   return fs.readFileSync(filePath, 'utf8');
 }
 
+function loadRequiredC8ConfigContent() {
+  if (!fs.existsSync(REQUIRED_C8_CONFIG_TEMPLATE_FILE)) {
+    console.error(
+      `Required c8 config template does not exist: ${REQUIRED_C8_CONFIG_TEMPLATE_FILE}`,
+    );
+    process.exit(2);
+  }
+
+  const template = parseJsonFile(
+    REQUIRED_C8_CONFIG_TEMPLATE_FILE,
+    'Required c8 config template',
+  );
+  return `${JSON.stringify(template, null, 2)}\n`;
+}
+
 function resolveWorkspacePaths(cwd, options) {
   const manual = getMulti(options, '--workspace');
   if (manual.length > 0) {
@@ -116,11 +133,10 @@ function resolveWorkspacePaths(cwd, options) {
   }
 
   const rootPackageJsonPath = path.resolve(cwd, 'package.json');
-  if (!fs.existsSync(rootPackageJsonPath)) {
-    return [];
-  }
-
-  const rootPackageJson = parseJsonFile(rootPackageJsonPath, 'Root package.json');
+  const rootPackageJson = parseJsonFile(
+    rootPackageJsonPath,
+    'Root package.json',
+  );
   if (!Array.isArray(rootPackageJson.workspaces)) {
     return [];
   }
@@ -132,20 +148,29 @@ function resolveWorkspacePaths(cwd, options) {
 
   const hasGlob = workspaces.some((entry) => GLOB_TOKEN_PATTERN.test(entry));
   if (hasGlob) {
-    console.error('Root package.json `workspaces` must use explicit paths without glob tokens');
+    console.error(
+      'Root package.json `workspaces` must use explicit paths without glob tokens',
+    );
     process.exit(2);
   }
 
   return workspaces;
 }
 
-function syncRootCoverage(cwd, mode, requiredC8Version) {
+function syncRootCoverage(
+  cwd,
+  mode,
+  requiredC8Version,
+  requiredC8ConfigContent,
+) {
   const rootPackageJsonPath = path.resolve(cwd, 'package.json');
   const c8ConfigPath = path.resolve(cwd, REQUIRED_C8_CONFIG_FILE);
   const currentC8ConfigContent = readFileIfExists(c8ConfigPath);
   const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
   const scripts =
-    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+    pkg.scripts &&
+    typeof pkg.scripts === 'object' &&
+    !Array.isArray(pkg.scripts)
       ? { ...pkg.scripts }
       : {};
   const devDependencies =
@@ -162,20 +187,27 @@ function syncRootCoverage(cwd, mode, requiredC8Version) {
     typeof devDependencies.c8 === 'string' ? devDependencies.c8 : null;
   const matchesRequiredRootCoverageBefore =
     previousRootCoverageScript === REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE;
-  const matchesRequiredC8DevDependencyBefore = previousC8DevDependency === requiredC8Version;
-  const matchesRequiredC8ConfigBefore = currentC8ConfigContent === REQUIRED_C8_CONFIG_CONTENT;
+  const matchesRequiredC8DevDependencyBefore =
+    previousC8DevDependency === requiredC8Version;
+  const matchesRequiredC8ConfigBefore =
+    currentC8ConfigContent === requiredC8ConfigContent;
   const requiresUpdate =
     !matchesRequiredRootCoverageBefore ||
     !matchesRequiredC8DevDependencyBefore ||
     !matchesRequiredC8ConfigBefore;
 
   if (mode === 'sync' && requiresUpdate) {
-    scripts[REQUIRED_ROOT_COVERAGE_SCRIPT_KEY] = REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE;
+    scripts[REQUIRED_ROOT_COVERAGE_SCRIPT_KEY] =
+      REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE;
     pkg.scripts = scripts;
     devDependencies.c8 = requiredC8Version;
     pkg.devDependencies = devDependencies;
-    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
-    fs.writeFileSync(c8ConfigPath, REQUIRED_C8_CONFIG_CONTENT, 'utf8');
+    fs.writeFileSync(
+      rootPackageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
+    fs.writeFileSync(c8ConfigPath, requiredC8ConfigContent, 'utf8');
   }
 
   return {
@@ -184,7 +216,7 @@ function syncRootCoverage(cwd, mode, requiredC8Version) {
       rootCoverageScriptKey: REQUIRED_ROOT_COVERAGE_SCRIPT_KEY,
       rootCoverageScriptValue: REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE,
       c8ConfigFile: REQUIRED_C8_CONFIG_FILE,
-      c8ConfigContent: REQUIRED_C8_CONFIG_CONTENT,
+      c8ConfigContent: requiredC8ConfigContent,
       c8DevDependency: requiredC8Version,
     },
     status: {
@@ -192,11 +224,17 @@ function syncRootCoverage(cwd, mode, requiredC8Version) {
       matchesRequiredC8DevDependencyBefore,
       matchesRequiredC8ConfigBefore,
       matchesRequiredRootCoverageAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredRootCoverageBefore,
+        requiresUpdate && mode === 'sync'
+          ? true
+          : matchesRequiredRootCoverageBefore,
       matchesRequiredC8DevDependencyAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredC8DevDependencyBefore,
+        requiresUpdate && mode === 'sync'
+          ? true
+          : matchesRequiredC8DevDependencyBefore,
       matchesRequiredC8ConfigAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredC8ConfigBefore,
+        requiresUpdate && mode === 'sync'
+          ? true
+          : matchesRequiredC8ConfigBefore,
       updated: requiresUpdate && mode === 'sync',
     },
   };
@@ -250,7 +288,9 @@ function reconcileCoverageScript(
   }
 
   const scripts =
-    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+    pkg.scripts &&
+    typeof pkg.scripts === 'object' &&
+    !Array.isArray(pkg.scripts)
       ? { ...pkg.scripts }
       : {};
   const devDependencies =
@@ -274,9 +314,11 @@ function reconcileCoverageScript(
   result.previousCoverage = previousCoverage;
   result.previousTestScript = previousTestScript;
   result.previousC8DevDependency = previousC8DevDependency;
-  result.matchesRequiredCoverageBefore = previousCoverage === requiredCoverageScript;
+  result.matchesRequiredCoverageBefore =
+    previousCoverage === requiredCoverageScript;
   result.hasRequiredTestScriptBefore = previousTestScript !== null;
-  result.matchesRequiredC8DevDependencyBefore = previousC8DevDependency === requiredC8Version;
+  result.matchesRequiredC8DevDependencyBefore =
+    previousC8DevDependency === requiredC8Version;
 
   if (
     (!result.matchesRequiredCoverageBefore ||
@@ -291,7 +333,11 @@ function reconcileCoverageScript(
     devDependencies.c8 = requiredC8Version;
     pkg.scripts = scripts;
     pkg.devDependencies = devDependencies;
-    fs.writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
     result.updated = true;
   }
 
@@ -308,9 +354,11 @@ function reconcileCoverageScript(
       ? requiredC8Version
       : previousC8DevDependency;
 
-  result.matchesRequiredCoverageAfter = result.updated || result.matchesRequiredCoverageBefore;
+  result.matchesRequiredCoverageAfter =
+    result.updated || result.matchesRequiredCoverageBefore;
   result.hasRequiredTestScriptAfter =
-    (mode === 'sync' && !result.hasRequiredTestScriptBefore) || result.hasRequiredTestScriptBefore;
+    (mode === 'sync' && !result.hasRequiredTestScriptBefore) ||
+    result.hasRequiredTestScriptBefore;
   result.matchesRequiredC8DevDependencyAfter =
     result.updated || result.matchesRequiredC8DevDependencyBefore;
   return result;
@@ -321,9 +369,11 @@ export function runSyncCoverage(options) {
   const check = hasFlag(options, '--check');
   const dryRun = hasFlag(options, '--dry-run');
   const jsonFile = getSingle(options, '--json', '');
-  const { baseline: toolingBaseline, toolingBaselinePath } = loadToolingBaseline();
+  const { baseline: toolingBaseline, toolingBaselinePath } =
+    loadToolingBaseline();
   const requiredCoverageScript = buildRequiredCoverageScript(toolingBaseline);
   const requiredC8Version = buildRequiredC8DevDependency(toolingBaseline);
+  const requiredC8ConfigContent = loadRequiredC8ConfigContent();
 
   if (!fs.existsSync(cwd)) {
     console.error(`CWD does not exist: ${cwd}`);
@@ -331,7 +381,12 @@ export function runSyncCoverage(options) {
   }
 
   const mode = dryRun ? 'dry-run' : check ? 'check' : 'sync';
-  const root = syncRootCoverage(cwd, mode, requiredC8Version);
+  const root = syncRootCoverage(
+    cwd,
+    mode,
+    requiredC8Version,
+    requiredC8ConfigContent,
+  );
   const workspacePaths = resolveWorkspacePaths(cwd, options);
 
   const report = {

package/bin/command/sync-coverage/required-c8-config.json

@@ -0,0 +1,15 @@
+{
+  "check-coverage": true,
+  "exclude": [
+    "**/node_modules/**",
+    "**/coverage/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/out/**"
+  ],
+  "reporter": ["lcov", "html", "text-summary"],
+  "branches": 99.5,
+  "functions": 99.5,
+  "statements": 99.5,
+  "lines": 99.5
+}

package/bin/command/sync-editorconfig/index.mjs

@@ -39,7 +39,8 @@ export function runSyncEditorconfig(options) {
   const editorconfigPath = path.resolve(cwd, EDITORCONFIG_FILE);
   const currentContent = readFileIfExists(editorconfigPath);
   const fileExists = currentContent !== null;
-  const upToDate = fileExists && currentContent === REQUIRED_EDITORCONFIG_CONTENT;
+  const upToDate =
+    fileExists && currentContent === REQUIRED_EDITORCONFIG_CONTENT;
 
   const mismatches = [];
   if (!upToDate) {

package/bin/command/sync-format/index.mjs

@@ -10,13 +10,23 @@ const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
 const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
 const REPO_ROOT = path.resolve(PACKAGE_ROOT, '../..');
 const TOOLING_BASELINE_CANDIDATE_PATHS = [
-  path.resolve(REPO_ROOT, '.github/distribution/produck/tooling-version-baseline.json'),
-  path.resolve(PACKAGE_ROOT, 'publish-assets/instructions/produck/tooling-version-baseline.json'),
+  path.resolve(
+    REPO_ROOT,
+    '.github/distribution/produck/tooling-version-baseline.json',
+  ),
+  path.resolve(
+    PACKAGE_ROOT,
+    'publish-assets/instructions/produck/tooling-version-baseline.json',
+  ),
 ];
 const PRETTIER_CONFIG_FILE = '.prettierrc';
 const PRETTIER_IGNORE_FILE = '.prettierignore';
 const REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY = 'prettier';
 
+const PRETTIER_CONFIG_SOURCE_CANDIDATE_PATHS = [
+  path.resolve(REPO_ROOT, '.prettierrc'),
+  path.resolve(PACKAGE_ROOT, 'publish-assets/prettierrc'),
+];
 const PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS = [
   path.resolve(REPO_ROOT, '.prettierignore'),
   path.resolve(PACKAGE_ROOT, 'publish-assets/prettierignore'),
@@ -25,26 +35,37 @@ const PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS = [
 const REQUIRED_FORMAT_SCRIPT_KEY = 'produck:format';
 const REQUIRED_FORMAT_SCRIPT_VALUE =
   'prettier --write . --ignore-path .prettierignore --ignore-path .gitignore';
-const REQUIRED_PRETTIER_CONFIG = `${JSON.stringify(
-  {
-    semi: true,
-    singleQuote: true,
-    tabWidth: 2,
-    useTabs: false,
-    trailingComma: 'all',
-    bracketSpacing: true,
-    arrowParens: 'always',
-    printWidth: 100,
-  },
-  null,
-  2,
-)}\n`;
+
+function loadPrettierConfigContent() {
+  const sourcePath = PRETTIER_CONFIG_SOURCE_CANDIDATE_PATHS.find((p) =>
+    fs.existsSync(p),
+  );
+
+  if (!sourcePath) {
+    console.error('Org .prettierrc source not found in expected locations:');
+    for (const p of PRETTIER_CONFIG_SOURCE_CANDIDATE_PATHS) {
+      console.error(`- ${p}`);
+    }
+    process.exit(2);
+  }
+
+  const parsed = parseJsonFile(sourcePath, '.prettierrc source');
+
+  return {
+    sourcePath,
+    content: `${JSON.stringify(parsed, null, 2)}\n`,
+  };
+}
 
 function loadPrettierIgnoreContent() {
-  const sourcePath = PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS.find((p) => fs.existsSync(p));
+  const sourcePath = PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS.find((p) =>
+    fs.existsSync(p),
+  );
 
   if (!sourcePath) {
-    console.error('Org .prettierignore source not found in expected locations:');
+    console.error(
+      'Org .prettierignore source not found in expected locations:',
+    );
     for (const p of PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS) {
       console.error(`- ${p}`);
     }
@@ -79,12 +100,16 @@ function parseJsonFile(filePath, label) {
 }
 
 function loadToolingBaseline() {
-  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find((candidatePath) => {
-    return fs.existsSync(candidatePath);
-  });
+  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
+    (candidatePath) => {
+      return fs.existsSync(candidatePath);
+    },
+  );
 
   if (!toolingBaselinePath) {
-    console.error('Tooling baseline file does not exist in expected locations:');
+    console.error(
+      'Tooling baseline file does not exist in expected locations:',
+    );
     for (const candidatePath of TOOLING_BASELINE_CANDIDATE_PATHS) {
       console.error(`- ${candidatePath}`);
     }
@@ -92,7 +117,9 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const prettierVersion = String(baseline?.tools?.prettier?.version || '').trim();
+  const prettierVersion = String(
+    baseline?.tools?.prettier?.version || '',
+  ).trim();
 
   if (!prettierVersion) {
     console.error(
@@ -125,10 +152,18 @@ export function runSyncFormat(options) {
   const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
   const toolingBaseline = loadToolingBaseline();
   const requiredPrettierVersion = toolingBaseline.prettierVersion;
-  const { sourcePath: prettierIgnoreSourcePath, content: REQUIRED_PRETTIER_IGNORE_CONTENT } =
-    loadPrettierIgnoreContent();
+  const {
+    sourcePath: prettierConfigSourcePath,
+    content: requiredPrettierConfigContent,
+  } = loadPrettierConfigContent();
+  const {
+    sourcePath: prettierIgnoreSourcePath,
+    content: REQUIRED_PRETTIER_IGNORE_CONTENT,
+  } = loadPrettierIgnoreContent();
   const scripts =
-    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+    pkg.scripts &&
+    typeof pkg.scripts === 'object' &&
+    !Array.isArray(pkg.scripts)
       ? { ...pkg.scripts }
       : {};
   const devDependencies =
@@ -153,9 +188,12 @@ export function runSyncFormat(options) {
   const previousPrettierIgnore = readFileIfExists(prettierIgnorePath);
 
   const matchesRequiredFormat = previousFormat === REQUIRED_FORMAT_SCRIPT_VALUE;
-  const matchesRequiredPrettierConfig = previousPrettierConfig === REQUIRED_PRETTIER_CONFIG;
-  const matchesRequiredPrettierDep = previousPrettierDep === requiredPrettierVersion;
-  const matchesRequiredPrettierIgnore = previousPrettierIgnore === REQUIRED_PRETTIER_IGNORE_CONTENT;
+  const matchesRequiredPrettierConfig =
+    previousPrettierConfig === requiredPrettierConfigContent;
+  const matchesRequiredPrettierDep =
+    previousPrettierDep === requiredPrettierVersion;
+  const matchesRequiredPrettierIgnore =
+    previousPrettierIgnore === REQUIRED_PRETTIER_IGNORE_CONTENT;
 
   const requiresUpdate =
     !matchesRequiredFormat ||
@@ -167,12 +205,21 @@ export function runSyncFormat(options) {
     scripts[REQUIRED_FORMAT_SCRIPT_KEY] = REQUIRED_FORMAT_SCRIPT_VALUE;
     pkg.scripts = scripts;
 
-    devDependencies[REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY] = requiredPrettierVersion;
+    devDependencies[REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY] =
+      requiredPrettierVersion;
     pkg.devDependencies = devDependencies;
 
-    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
-    fs.writeFileSync(prettierConfigPath, REQUIRED_PRETTIER_CONFIG, 'utf8');
-    fs.writeFileSync(prettierIgnorePath, REQUIRED_PRETTIER_IGNORE_CONTENT, 'utf8');
+    fs.writeFileSync(
+      rootPackageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
+    fs.writeFileSync(prettierConfigPath, requiredPrettierConfigContent, 'utf8');
+    fs.writeFileSync(
+      prettierIgnorePath,
+      REQUIRED_PRETTIER_IGNORE_CONTENT,
+      'utf8',
+    );
   }
 
   const report = {
@@ -185,22 +232,30 @@ export function runSyncFormat(options) {
       formatScriptKey: REQUIRED_FORMAT_SCRIPT_KEY,
       formatScriptValue: REQUIRED_FORMAT_SCRIPT_VALUE,
       prettierConfigPath: path.relative(cwd, prettierConfigPath),
+      prettierConfigSourcePath,
       prettierIgnorePath: path.relative(cwd, prettierIgnorePath),
       prettierIgnoreSourcePath,
-      managedDevDependencies: { [REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY]: requiredPrettierVersion },
+      managedDevDependencies: {
+        [REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY]: requiredPrettierVersion,
+      },
     },
     status: {
       matchesRequiredFormatBefore: matchesRequiredFormat,
       matchesRequiredPrettierConfigBefore: matchesRequiredPrettierConfig,
       matchesRequiredPrettierDepBefore: matchesRequiredPrettierDep,
       matchesRequiredPrettierIgnoreBefore: matchesRequiredPrettierIgnore,
-      matchesRequiredFormatAfter: requiresUpdate && mode === 'sync' ? true : matchesRequiredFormat,
+      matchesRequiredFormatAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredFormat,
       matchesRequiredPrettierConfigAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierConfig,
+        requiresUpdate && mode === 'sync'
+          ? true
+          : matchesRequiredPrettierConfig,
       matchesRequiredPrettierDepAfter:
         requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierDep,
       matchesRequiredPrettierIgnoreAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierIgnore,
+        requiresUpdate && mode === 'sync'
+          ? true
+          : matchesRequiredPrettierIgnore,
       updated: requiresUpdate && mode === 'sync',
     },
   };