@produck/agent-toolkit 0.4.0 → 0.5.0

package/bin/command/sync-eslint-config/index.mjs

@@ -0,0 +1,248 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { getSingle, hasFlag } from '../shared/args.mjs';
+import { printTextResource } from '../shared/text-resource.mjs';
+
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
+const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
+const TOOLKIT_PACKAGE_JSON = path.resolve(PACKAGE_ROOT, 'package.json');
+const ESLINT_CONFIG_FILE = 'eslint.config.mjs';
+
+const REQUIRED_LINT_SCRIPT_KEY = 'produck:lint';
+const REQUIRED_LINT_SCRIPT_VALUE =
+  'npm exec -- eslint --fix . --max-warnings=0 && npm run lint --if-present';
+const REQUIRED_ESLINT_CONFIG = `import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import * as ProduckRule from '@produck/eslint-rules';
+
+export default [
+  { files: ['**/*.{js,mjs,cjs,ts,mts}'] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  ProduckRule.config,
+  ProduckRule.excludeGitIgnore(import.meta.url),
+];
+`;
+
+export function printSyncEslintConfigHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function parseJsonFile(filePath, label) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    console.error(`${label} is not valid JSON: ${filePath}`);
+    process.exit(2);
+  }
+}
+
+function readFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function getRequiredEslintRulesDevDependency() {
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const latestResult = spawnSync(npmCommand, ['view', '@produck/eslint-rules', 'version'], {
+    encoding: 'utf8',
+  });
+
+  const latestVersion = String(latestResult.stdout || '').trim();
+  if (latestResult.status === 0 && latestVersion) {
+    return latestVersion;
+  }
+
+  const pkg = parseJsonFile(TOOLKIT_PACKAGE_JSON, 'Toolkit package.json');
+  const version = typeof pkg.version === 'string' ? pkg.version.trim() : '';
+
+  if (!version) {
+    console.error(`Toolkit package version is missing: ${TOOLKIT_PACKAGE_JSON}`);
+    process.exit(2);
+  }
+
+  return version;
+}
+
+function patchEslintConfig(existing) {
+  if (existing.includes('@produck/eslint-rules')) {
+    return { ok: true, patched: false, output: existing };
+  }
+
+  const importRegex = /^import\s.+;\s*$/gm;
+  let lastImport = null;
+  let match = importRegex.exec(existing);
+  while (match) {
+    lastImport = match;
+    match = importRegex.exec(existing);
+  }
+
+  if (!lastImport) {
+    return { ok: false, patched: false, output: existing };
+  }
+
+  const importInsertAt = lastImport.index + lastImport[0].length;
+  let output =
+    `${existing.slice(0, importInsertAt)}\nimport * as ProduckRule from '@produck/eslint-rules';` +
+    existing.slice(importInsertAt);
+
+  const exportStart = output.indexOf('export default [');
+  const exportEnd = output.lastIndexOf('];');
+  if (exportStart === -1 || exportEnd === -1 || exportEnd < exportStart) {
+    return { ok: false, patched: false, output: existing };
+  }
+
+  output =
+    `${output.slice(0, exportEnd)}  ProduckRule.config,\n  ProduckRule.excludeGitIgnore(import.meta.url),\n` +
+    output.slice(exportEnd);
+
+  if (!output.endsWith('\n')) {
+    output = `${output}\n`;
+  }
+
+  return { ok: true, patched: true, output };
+}
+
+export function runSyncEslintConfig(options) {
+  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
+  const check = hasFlag(options, '--check');
+  const dryRun = hasFlag(options, '--dry-run') && !check;
+  const jsonFile = getSingle(options, '--json', '');
+  const mode = check ? 'check' : dryRun ? 'dry-run' : 'sync';
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
+  if (!fs.existsSync(rootPackageJsonPath)) {
+    console.error(`Root package.json does not exist: ${rootPackageJsonPath}`);
+    process.exit(2);
+  }
+
+  const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
+  const scripts =
+    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+      ? { ...pkg.scripts }
+      : {};
+  const devDependencies =
+    pkg.devDependencies &&
+    typeof pkg.devDependencies === 'object' &&
+    !Array.isArray(pkg.devDependencies)
+      ? { ...pkg.devDependencies }
+      : {};
+
+  const previousLint =
+    typeof scripts[REQUIRED_LINT_SCRIPT_KEY] === 'string'
+      ? scripts[REQUIRED_LINT_SCRIPT_KEY]
+      : null;
+  const previousEslintRules =
+    typeof devDependencies['@produck/eslint-rules'] === 'string'
+      ? devDependencies['@produck/eslint-rules']
+      : null;
+
+  const requiredEslintRulesDependency = getRequiredEslintRulesDevDependency();
+
+  const eslintConfigPath = path.resolve(cwd, ESLINT_CONFIG_FILE);
+  const previousEslintConfig = readFileIfExists(eslintConfigPath);
+
+  const matchesRequiredLint = previousLint === REQUIRED_LINT_SCRIPT_VALUE;
+  const matchesRequiredEslintRules = previousEslintRules === requiredEslintRulesDependency;
+
+  let eslintConfigAction = 'unchanged';
+  let matchesRequiredEslintConfig = false;
+  let nextEslintConfigText = previousEslintConfig;
+
+  if (previousEslintConfig === null) {
+    eslintConfigAction = 'initialized';
+    nextEslintConfigText = REQUIRED_ESLINT_CONFIG;
+  } else if (previousEslintConfig === REQUIRED_ESLINT_CONFIG) {
+    matchesRequiredEslintConfig = true;
+  } else if (previousEslintConfig.includes('@produck/eslint-rules')) {
+    matchesRequiredEslintConfig = true;
+  } else {
+    const patched = patchEslintConfig(previousEslintConfig);
+    if (patched.ok) {
+      eslintConfigAction = 'patched';
+      nextEslintConfigText = patched.output;
+    } else {
+      eslintConfigAction = 'unpatchable';
+    }
+  }
+
+  const requiresUpdate =
+    !matchesRequiredLint || !matchesRequiredEslintRules || !matchesRequiredEslintConfig;
+  const hasUnpatchableEslintConfig = eslintConfigAction === 'unpatchable';
+
+  if (mode === 'sync' && requiresUpdate && !hasUnpatchableEslintConfig) {
+    scripts[REQUIRED_LINT_SCRIPT_KEY] = REQUIRED_LINT_SCRIPT_VALUE;
+    pkg.scripts = scripts;
+
+    devDependencies['@produck/eslint-rules'] = requiredEslintRulesDependency;
+    pkg.devDependencies = devDependencies;
+
+    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(eslintConfigPath, nextEslintConfigText || REQUIRED_ESLINT_CONFIG, 'utf8');
+  }
+
+  const report = {
+    cwd,
+    mode,
+    ok: true,
+    rootPackageJsonPath,
+    required: {
+      lintScriptKey: REQUIRED_LINT_SCRIPT_KEY,
+      lintScriptValue: REQUIRED_LINT_SCRIPT_VALUE,
+      eslintRulesVersion: requiredEslintRulesDependency,
+      eslintConfigPath: path.relative(cwd, eslintConfigPath),
+      eslintConfigAction,
+    },
+    status: {
+      matchesRequiredLintBefore: matchesRequiredLint,
+      matchesRequiredEslintRulesBefore: matchesRequiredEslintRules,
+      matchesRequiredEslintConfigBefore: matchesRequiredEslintConfig,
+      matchesRequiredLintAfter:
+        requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
+          ? true
+          : matchesRequiredLint,
+      matchesRequiredEslintRulesAfter:
+        requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
+          ? true
+          : matchesRequiredEslintRules,
+      matchesRequiredEslintConfigAfter:
+        requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
+          ? true
+          : matchesRequiredEslintConfig,
+      updated: requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig,
+      hasUnpatchableEslintConfig,
+    },
+  };
+
+  if (mode === 'check' && (requiresUpdate || hasUnpatchableEslintConfig)) {
+    report.ok = false;
+  }
+  if ((mode === 'sync' || mode === 'dry-run') && hasUnpatchableEslintConfig) {
+    report.ok = false;
+  }
+
+  if (jsonFile) {
+    const outPath = path.resolve(cwd, jsonFile);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ok) {
+    process.exit(2);
+  }
+}

package/bin/command/sync-husky-hooks/help.txt

@@ -3,15 +3,7 @@ Usage:
     [--json <file>]
 
 Behavior:
-  - Applies organization-required root scripts for local hook gates:
-    - scripts.prepare = husky
-    - scripts.produck:precommit-check = npm run format:check && npm run lint
-  - Applies organization-required root managed devDependencies:
-    - devDependencies.c8 = <fixed-version-from-baseline>
-    - devDependencies.husky = <fixed-version-from-baseline>
-    - devDependencies.lerna = <fixed-version-from-baseline>
-    - devDependencies.@produck/agent-toolkit = <latest-version-resolved-at-runtime>
-  - Applies organization-required hook files:
+  - Applies organization-required hook files only:
     - .husky/pre-commit
     - .husky/commit-msg
   - commit-msg hook validates message via local node_modules toolkit path

package/bin/command/sync-husky-hooks/index.mjs

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 import { getSingle, hasFlag } from '../shared/args.mjs';
@@ -8,17 +7,6 @@ import { printTextResource } from '../shared/text-resource.mjs';
 
 const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
 const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
-const PACKAGE_ROOT = path.resolve(COMMAND_DIR, '../../..');
-const REPO_ROOT = path.resolve(PACKAGE_ROOT, '../..');
-const TOOLKIT_PACKAGE_JSON = path.resolve(PACKAGE_ROOT, 'package.json');
-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'),
-];
-
-const REQUIRED_PREPARE_SCRIPT = 'husky';
-const REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY = 'produck:precommit-check';
-const REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE = 'npm run format:check && npm run lint';
 
 const REQUIRED_PRE_COMMIT_HOOK = '#!/usr/bin/env sh\nnpm run produck:precommit-check\n';
 const REQUIRED_COMMIT_MSG_HOOK =
@@ -28,75 +16,6 @@ export function printSyncHuskyHooksHelp() {
   printTextResource(HELP_FILE);
 }
 
-function parseJsonFile(filePath, label) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    console.error(`${label} is not valid JSON: ${filePath}`);
-    process.exit(2);
-  }
-}
-
-function getRequiredToolkitDevDependency() {
-  const overrideVersion = String(process.env.PRODUCK_TOOLKIT_VERSION_OVERRIDE || '').trim();
-  if (overrideVersion) {
-    return overrideVersion;
-  }
-
-  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const latestResult = spawnSync(npmCommand, ['view', '@produck/agent-toolkit', 'version'], {
-    encoding: 'utf8',
-  });
-
-  const latestVersion = String(latestResult.stdout || '').trim();
-  if (latestResult.status === 0 && latestVersion) {
-    return latestVersion;
-  }
-
-  const pkg = parseJsonFile(TOOLKIT_PACKAGE_JSON, 'Toolkit package.json');
-  const version = typeof pkg.version === 'string' ? pkg.version.trim() : '';
-
-  if (!version) {
-    console.error(`Toolkit package version is missing: ${TOOLKIT_PACKAGE_JSON}`);
-    process.exit(2);
-  }
-
-  return version;
-}
-
-function loadToolingBaseline() {
-  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:');
-    for (const candidatePath of TOOLING_BASELINE_CANDIDATE_PATHS) {
-      console.error(`- ${candidatePath}`);
-    }
-    process.exit(2);
-  }
-
-  const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const c8Version = String(baseline?.tools?.c8?.version || '').trim();
-  const huskyVersion = String(baseline?.tools?.husky?.version || '').trim();
-  const lernaVersion = String(baseline?.tools?.lerna?.version || '').trim();
-
-  if (!c8Version || !huskyVersion || !lernaVersion) {
-    console.error(
-      `Tooling baseline must define fixed tools.c8/husky/lerna.version: ${toolingBaselinePath}`,
-    );
-    process.exit(2);
-  }
-
-  return {
-    toolingBaselinePath,
-    c8Version,
-    huskyVersion,
-    lernaVersion,
-  };
-}
-
 function readFileIfExists(filePath) {
   if (!fs.existsSync(filePath)) {
     return null;
@@ -105,44 +24,6 @@ function readFileIfExists(filePath) {
   return fs.readFileSync(filePath, 'utf8');
 }
 
-function buildScriptState(pkg) {
-  const scripts =
-    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
-      ? { ...pkg.scripts }
-      : {};
-
-  return {
-    scripts,
-    previousPrepare: typeof scripts.prepare === 'string' ? scripts.prepare : null,
-    previousPrecommitCheck:
-      typeof scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY] === 'string'
-        ? scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY]
-        : null,
-  };
-}
-
-function buildDevDependencyState(pkg) {
-  const devDependencies =
-    pkg.devDependencies &&
-    typeof pkg.devDependencies === 'object' &&
-    !Array.isArray(pkg.devDependencies)
-      ? { ...pkg.devDependencies }
-      : {};
-
-  return {
-    devDependencies,
-    previousManaged: {
-      c8: typeof devDependencies.c8 === 'string' ? devDependencies.c8 : null,
-      husky: typeof devDependencies.husky === 'string' ? devDependencies.husky : null,
-      lerna: typeof devDependencies.lerna === 'string' ? devDependencies.lerna : null,
-      '@produck/agent-toolkit':
-        typeof devDependencies['@produck/agent-toolkit'] === 'string'
-          ? devDependencies['@produck/agent-toolkit']
-          : null,
-    },
-  };
-}
-
 export function runSyncHuskyHooks(options) {
   const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
   const check = hasFlag(options, '--check');
@@ -155,24 +36,6 @@ export function runSyncHuskyHooks(options) {
     process.exit(2);
   }
 
-  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
-  if (!fs.existsSync(rootPackageJsonPath)) {
-    console.error(`Root package.json does not exist: ${rootPackageJsonPath}`);
-    process.exit(2);
-  }
-
-  const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
-  const toolingBaseline = loadToolingBaseline();
-  const requiredToolkitDependency = getRequiredToolkitDevDependency();
-  const requiredDevDependencies = {
-    c8: toolingBaseline.c8Version,
-    husky: toolingBaseline.huskyVersion,
-    lerna: toolingBaseline.lernaVersion,
-    '@produck/agent-toolkit': requiredToolkitDependency,
-  };
-  const scriptState = buildScriptState(pkg);
-  const dependencyState = buildDevDependencyState(pkg);
-
   const huskyDir = path.resolve(cwd, '.husky');
   const preCommitHookPath = path.resolve(huskyDir, 'pre-commit');
   const commitMsgHookPath = path.resolve(huskyDir, 'commit-msg');
@@ -180,37 +43,11 @@ export function runSyncHuskyHooks(options) {
   const previousPreCommitHook = readFileIfExists(preCommitHookPath);
   const previousCommitMsgHook = readFileIfExists(commitMsgHookPath);
 
-  const matchesRequiredPrepare = scriptState.previousPrepare === REQUIRED_PREPARE_SCRIPT;
-  const matchesRequiredPrecommitCheck =
-    scriptState.previousPrecommitCheck === REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE;
-  const matchesRequiredManagedDevDependencies = Object.entries(requiredDevDependencies).every(
-    ([name, version]) => {
-      return dependencyState.previousManaged[name] === version;
-    },
-  );
   const matchesRequiredPreCommitHook = previousPreCommitHook === REQUIRED_PRE_COMMIT_HOOK;
   const matchesRequiredCommitMsgHook = previousCommitMsgHook === REQUIRED_COMMIT_MSG_HOOK;
-
-  const requiresUpdate =
-    !matchesRequiredPrepare ||
-    !matchesRequiredPrecommitCheck ||
-    !matchesRequiredManagedDevDependencies ||
-    !matchesRequiredPreCommitHook ||
-    !matchesRequiredCommitMsgHook;
+  const requiresUpdate = !matchesRequiredPreCommitHook || !matchesRequiredCommitMsgHook;
 
   if (mode === 'sync' && requiresUpdate) {
-    scriptState.scripts.prepare = REQUIRED_PREPARE_SCRIPT;
-    scriptState.scripts[REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY] =
-      REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE;
-    pkg.scripts = scriptState.scripts;
-
-    for (const [name, version] of Object.entries(requiredDevDependencies)) {
-      dependencyState.devDependencies[name] = version;
-    }
-    pkg.devDependencies = dependencyState.devDependencies;
-
-    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
-
     fs.mkdirSync(huskyDir, { recursive: true });
     fs.writeFileSync(preCommitHookPath, REQUIRED_PRE_COMMIT_HOOK, 'utf8');
     fs.writeFileSync(commitMsgHookPath, REQUIRED_COMMIT_MSG_HOOK, 'utf8');
@@ -220,28 +57,13 @@ export function runSyncHuskyHooks(options) {
     cwd,
     mode,
     ok: true,
-    rootPackageJsonPath,
-    toolingBaselinePath: toolingBaseline.toolingBaselinePath,
     required: {
-      prepareScript: REQUIRED_PREPARE_SCRIPT,
-      precommitCheckScriptKey: REQUIRED_PRECOMMIT_CHECK_SCRIPT_KEY,
-      precommitCheckScriptValue: REQUIRED_PRECOMMIT_CHECK_SCRIPT_VALUE,
-      managedDevDependencies: requiredDevDependencies,
       preCommitHookPath: path.relative(cwd, preCommitHookPath),
       commitMsgHookPath: path.relative(cwd, commitMsgHookPath),
     },
     status: {
-      matchesRequiredPrepareBefore: matchesRequiredPrepare,
-      matchesRequiredPrecommitCheckBefore: matchesRequiredPrecommitCheck,
-      matchesRequiredManagedDevDependenciesBefore: matchesRequiredManagedDevDependencies,
       matchesRequiredPreCommitHookBefore: matchesRequiredPreCommitHook,
       matchesRequiredCommitMsgHookBefore: matchesRequiredCommitMsgHook,
-      matchesRequiredPrepareAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrepare,
-      matchesRequiredPrecommitCheckAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrecommitCheck,
-      matchesRequiredManagedDevDependenciesAfter:
-        requiresUpdate && mode === 'sync' ? true : matchesRequiredManagedDevDependencies,
       matchesRequiredPreCommitHookAfter:
         requiresUpdate && mode === 'sync' ? true : matchesRequiredPreCommitHook,
       matchesRequiredCommitMsgHookAfter:

package/bin/command/sync-prettier-config/help.txt

@@ -0,0 +1,14 @@
+Usage:
+  agent-toolkit sync-prettier-config [--cwd <dir>] [--check] [--dry-run]
+    [--json <file>]
+
+Behavior:
+  - Applies organization-required root format script:
+    - scripts.produck:format = npm exec -- prettier --check . && npm run format --if-present
+  - Applies organization-required root Prettier config file:
+    - .prettierrc
+
+Rules:
+  - --check validates without writing and exits non-zero on mismatch
+  - --dry-run prints planned changes without writing
+  - --check takes precedence over --dry-run

package/bin/command/sync-prettier-config/index.mjs

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { getSingle, hasFlag } from '../shared/args.mjs';
+import { printTextResource } from '../shared/text-resource.mjs';
+
+const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
+const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
+const PRETTIER_CONFIG_FILE = '.prettierrc';
+
+const REQUIRED_FORMAT_SCRIPT_KEY = 'produck:format';
+const REQUIRED_FORMAT_SCRIPT_VALUE =
+  'npm exec -- prettier --check . && npm run format --if-present';
+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`;
+
+export function printSyncPrettierConfigHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function parseJsonFile(filePath, label) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    console.error(`${label} is not valid JSON: ${filePath}`);
+    process.exit(2);
+  }
+}
+
+function readFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+export function runSyncPrettierConfig(options) {
+  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
+  const check = hasFlag(options, '--check');
+  const dryRun = hasFlag(options, '--dry-run') && !check;
+  const jsonFile = getSingle(options, '--json', '');
+  const mode = check ? 'check' : dryRun ? 'dry-run' : 'sync';
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
+  if (!fs.existsSync(rootPackageJsonPath)) {
+    console.error(`Root package.json does not exist: ${rootPackageJsonPath}`);
+    process.exit(2);
+  }
+
+  const pkg = parseJsonFile(rootPackageJsonPath, 'Root package.json');
+  const scripts =
+    pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts)
+      ? { ...pkg.scripts }
+      : {};
+
+  const previousFormat =
+    typeof scripts[REQUIRED_FORMAT_SCRIPT_KEY] === 'string'
+      ? scripts[REQUIRED_FORMAT_SCRIPT_KEY]
+      : null;
+
+  const prettierConfigPath = path.resolve(cwd, PRETTIER_CONFIG_FILE);
+  const previousPrettierConfig = readFileIfExists(prettierConfigPath);
+
+  const matchesRequiredFormat = previousFormat === REQUIRED_FORMAT_SCRIPT_VALUE;
+  const matchesRequiredPrettierConfig = previousPrettierConfig === REQUIRED_PRETTIER_CONFIG;
+
+  const requiresUpdate = !matchesRequiredFormat || !matchesRequiredPrettierConfig;
+
+  if (mode === 'sync' && requiresUpdate) {
+    scripts[REQUIRED_FORMAT_SCRIPT_KEY] = REQUIRED_FORMAT_SCRIPT_VALUE;
+    pkg.scripts = scripts;
+
+    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(prettierConfigPath, REQUIRED_PRETTIER_CONFIG, 'utf8');
+  }
+
+  const report = {
+    cwd,
+    mode,
+    ok: true,
+    rootPackageJsonPath,
+    required: {
+      formatScriptKey: REQUIRED_FORMAT_SCRIPT_KEY,
+      formatScriptValue: REQUIRED_FORMAT_SCRIPT_VALUE,
+      prettierConfigPath: path.relative(cwd, prettierConfigPath),
+    },
+    status: {
+      matchesRequiredFormatBefore: matchesRequiredFormat,
+      matchesRequiredPrettierConfigBefore: matchesRequiredPrettierConfig,
+      matchesRequiredFormatAfter: requiresUpdate && mode === 'sync' ? true : matchesRequiredFormat,
+      matchesRequiredPrettierConfigAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierConfig,
+      updated: requiresUpdate && mode === 'sync',
+    },
+  };
+
+  if (mode === 'check' && requiresUpdate) {
+    report.ok = false;
+  }
+
+  if (jsonFile) {
+    const outPath = path.resolve(cwd, jsonFile);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  }
+
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ok) {
+    process.exit(2);
+  }
+}

package/bin/command/sync-workspace-config/help.txt

@@ -0,0 +1,21 @@
+Usage:
+  agent-toolkit sync-workspace-config [--cwd <dir>] [--check] [--dry-run]
+    [--json <file>]
+
+Behavior:
+  - Applies organization-required root shared scripts:
+    - scripts.produck:baseline = npm exec --package=@produck/agent-toolkit@latest -- agent-toolkit enforce-node-baseline --cwd .
+    - scripts.produck:coverage = c8 --config .c8rc.json npm run test --workspaces --if-present
+    - scripts.produck:precommit-check = npm run produck:format && npm run produck:lint
+  - Applies organization-required root c8 config file:
+    - .c8rc.json
+  - Applies organization-required root shared managed devDependencies:
+    - devDependencies.c8 = <fixed-version-from-baseline>
+    - devDependencies.husky = <fixed-version-from-baseline>
+    - devDependencies.lerna = <fixed-version-from-baseline>
+    - devDependencies.@produck/agent-toolkit = <latest-version-resolved-at-runtime>
+
+Rules:
+  - --check validates without writing and exits non-zero on mismatch
+  - --dry-run prints planned changes without writing
+  - --check takes precedence over --dry-run