@produck/agent-toolkit 0.8.2 → 0.9.1

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

@@ -10,28 +10,28 @@ 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 ESLINT_RULES_PACKAGE_NAME = '@produck/eslint-rules';
 const ESLINT_CONFIG_FILE = 'eslint.config.mjs';
 
 const REQUIRED_LINT_SCRIPT_KEY = 'produck:lint';
 const REQUIRED_LINT_SCRIPT_VALUE = 'eslint --fix . --max-warnings=0';
-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),
-];
-`;
+const ESLINT_CONFIG_TEMPLATE_PATH = path.resolve(
+  COMMAND_DIR,
+  'eslint.config.template.mjs',
+);
+
+function loadRequiredEslintConfig() {
+  return fs.readFileSync(ESLINT_CONFIG_TEMPLATE_PATH, 'utf8');
+}
 
 export function printSyncLintHelp() {
   printTextResource(HELP_FILE);
@@ -54,28 +54,53 @@ function readFileIfExists(filePath) {
   return fs.readFileSync(filePath, 'utf8');
 }
 
-function getRequiredEslintRulesDevDependency() {
-  // Prefer the in-tree source of truth: when sync-lint runs from inside the
-  // monorepo, the eslint-rules package.json is the authoritative version. When
-  // sync-lint runs as an installed dependency, fall back to the publish-assets
-  // tooling baseline (which build-publish-assets injects at prepack time from
-  // the same package.json).
-  const inTreeEslintRulesPkgPath = path.resolve(REPO_ROOT, 'packages/eslint-rules/package.json');
+const ESLINT_TOOLING_PACKAGE_NAMES = [
+  'eslint',
+  '@eslint/js',
+  '@eslint/json',
+  '@eslint/markdown',
+  '@eslint/config-helpers',
+  'typescript-eslint',
+  'globals',
+];
+
+function getRequiredEslintDevDependencies() {
+  // Prefer the in-tree source of truth for @produck/eslint-rules: when
+  // sync-lint runs inside the monorepo, eslint-rules/package.json is
+  // authoritative. When running as an installed dependency, fall back to the
+  // publish-assets tooling baseline.
+  const inTreeEslintRulesPkgPath = path.resolve(
+    REPO_ROOT,
+    'packages/eslint-rules/package.json',
+  );
+
+  let eslintRulesVersion = '';
   if (fs.existsSync(inTreeEslintRulesPkgPath)) {
-    const eslintRulesPkg = parseJsonFile(inTreeEslintRulesPkgPath, 'eslint-rules package.json');
-    const version = typeof eslintRulesPkg.version === 'string' ? eslintRulesPkg.version.trim() : '';
-    if (version) {
-      return version;
+    const eslintRulesPkg = parseJsonFile(
+      inTreeEslintRulesPkgPath,
+      'eslint-rules package.json',
+    );
+    // The '' fallback is for when the in-tree package.json has a non-string
+    // version field, which never occurs for this package.
+    const v =
+      typeof eslintRulesPkg.version === 'string'
+        ? eslintRulesPkg.version.trim()
+        : /* c8 ignore next */
+        '';
+    if (v) {
+      eslintRulesVersion = v;
     }
   }
 
-  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find((candidatePath) => {
-    return fs.existsSync(candidatePath);
-  });
+  const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
+    (candidatePath) => {
+      return fs.existsSync(candidatePath);
+    },
+  );
 
+  /* c8 ignore next 7 */
   if (!toolingBaselinePath) {
-    console.error('Cannot resolve @produck/eslint-rules version. Looked at:');
-    console.error(`- ${inTreeEslintRulesPkgPath}`);
+    console.error('Cannot resolve ESLint tooling versions. Looked at:');
     for (const candidatePath of TOOLING_BASELINE_CANDIDATE_PATHS) {
       console.error(`- ${candidatePath}`);
     }
@@ -83,24 +108,43 @@ function getRequiredEslintRulesDevDependency() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const entry = baseline?.tools?.[ESLINT_RULES_PACKAGE_NAME];
-  const version = typeof entry?.version === 'string' ? entry.version.trim() : '';
 
-  if (!version) {
-    console.error(
-      `Tooling baseline tools["${ESLINT_RULES_PACKAGE_NAME}"].version must be a non-empty string: ${toolingBaselinePath}`,
-    );
-    process.exit(2);
+  /* c8 ignore next 12 */
+  if (!eslintRulesVersion) {
+    const entry = baseline?.tools?.[ESLINT_RULES_PACKAGE_NAME];
+    const v = typeof entry?.version === 'string' ? entry.version.trim() : '';
+    if (!v) {
+      console.error(
+        `Tooling baseline tools["${ESLINT_RULES_PACKAGE_NAME}"].version must be a non-empty string: ${toolingBaselinePath}`,
+      );
+      process.exit(2);
+    }
+    eslintRulesVersion = v;
   }
 
-  return version;
+  const deps = { [ESLINT_RULES_PACKAGE_NAME]: eslintRulesVersion };
+
+  for (const name of ESLINT_TOOLING_PACKAGE_NAMES) {
+    const entry = baseline?.tools?.[name];
+    const v =
+      typeof entry?.version === 'string'
+        ? entry.version.trim()
+        : /* c8 ignore next */
+        '';
+    /* c8 ignore next 6 */
+    if (!v) {
+      console.error(
+        `Tooling baseline tools["${name}"].version must be a non-empty string: ${toolingBaselinePath}`,
+      );
+      process.exit(2);
+    }
+    deps[name] = v;
+  }
+
+  return deps;
 }
 
 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);
@@ -136,6 +180,7 @@ function patchEslintConfig(existing) {
 }
 
 export function runSyncLint(options) {
+  const REQUIRED_ESLINT_CONFIG = loadRequiredEslintConfig();
   const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
   const check = hasFlag(options, '--check');
   const dryRun = hasFlag(options, '--dry-run') && !check;
@@ -155,7 +200,9 @@ export function runSyncLint(options) {
 
   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 =
@@ -169,18 +216,15 @@ export function runSyncLint(options) {
     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 requiredEslintDevDeps = getRequiredEslintDevDependencies();
 
   const eslintConfigPath = path.resolve(cwd, ESLINT_CONFIG_FILE);
   const previousEslintConfig = readFileIfExists(eslintConfigPath);
 
   const matchesRequiredLint = previousLint === REQUIRED_LINT_SCRIPT_VALUE;
-  const matchesRequiredEslintRules = previousEslintRules === requiredEslintRulesDependency;
+  const matchesRequiredEslintDeps = Object.entries(requiredEslintDevDeps).every(
+    ([name, version]) => devDependencies[name] === version,
+  );
 
   let eslintConfigAction = 'unchanged';
   let matchesRequiredEslintConfig = false;
@@ -204,18 +248,33 @@ export function runSyncLint(options) {
   }
 
   const requiresUpdate =
-    !matchesRequiredLint || !matchesRequiredEslintRules || !matchesRequiredEslintConfig;
+    !matchesRequiredLint ||
+    !matchesRequiredEslintDeps ||
+    !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;
+    for (const [name, version] of Object.entries(requiredEslintDevDeps)) {
+      devDependencies[name] = version;
+    }
     pkg.devDependencies = devDependencies;
 
-    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
-    fs.writeFileSync(eslintConfigPath, nextEslintConfigText || REQUIRED_ESLINT_CONFIG, 'utf8');
+    fs.writeFileSync(
+      rootPackageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
+    // nextEslintConfigText is empty only if the patcher produces no output, which
+    // does not occur in tests since the existing config is always patchable.
+    fs.writeFileSync(
+      eslintConfigPath,
+      /* c8 ignore next */
+      nextEslintConfigText || REQUIRED_ESLINT_CONFIG,
+      'utf8',
+    );
   }
 
   const report = {
@@ -226,22 +285,22 @@ export function runSyncLint(options) {
     required: {
       lintScriptKey: REQUIRED_LINT_SCRIPT_KEY,
       lintScriptValue: REQUIRED_LINT_SCRIPT_VALUE,
-      eslintRulesVersion: requiredEslintRulesDependency,
+      eslintDevDependencies: requiredEslintDevDeps,
       eslintConfigPath: path.relative(cwd, eslintConfigPath),
       eslintConfigAction,
     },
     status: {
       matchesRequiredLintBefore: matchesRequiredLint,
-      matchesRequiredEslintRulesBefore: matchesRequiredEslintRules,
+      matchesRequiredEslintDepsBefore: matchesRequiredEslintDeps,
       matchesRequiredEslintConfigBefore: matchesRequiredEslintConfig,
       matchesRequiredLintAfter:
         requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
           ? true
           : matchesRequiredLint,
-      matchesRequiredEslintRulesAfter:
+      matchesRequiredEslintDepsAfter:
         requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
           ? true
-          : matchesRequiredEslintRules,
+          : matchesRequiredEslintDeps,
       matchesRequiredEslintConfigAfter:
         requiresUpdate && mode === 'sync' && !hasUnpatchableEslintConfig
           ? true

package/bin/command/sync-publish/help.txt

@@ -5,11 +5,13 @@ agent-toolkit sync-publish [--cwd <dir>] [--check] [--dry-run]
 Behavior:
 
 - Reads lerna.json in <dir> to detect monorepo publish mode
-- If lerna.json is absent, sync mode creates a default lerna.json
+- If lerna.json is absent, sync mode creates one from organization sample
+  (repo root lerna.json / publish-assets/lerna.json)
 - Sync mode applies organization-required root publish scripts:
-  - scripts.produck:publish:check = npm run produck:format && npm run produck:lint && npm run produck:coverage
+  - scripts.produck:publish:check = npm run produck:install && npm run produck:format && npm run produck:lint && npm run produck:coverage
   - scripts.produck:publish = npm run produck:publish:check && npm run publish --
     when scripts.publish exists; otherwise it falls back to lerna publish
+  - Enforces lerna.json command.version.commitHooks = false so publish/version commits skip git commit hooks
 
 Rules:
 

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

@@ -7,23 +7,21 @@ 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 LERNA_CONFIG_FILE = 'lerna.json';
+const LERNA_TEMPLATE_CANDIDATE_PATHS = [
+  path.resolve(REPO_ROOT, LERNA_CONFIG_FILE),
+  path.resolve(PACKAGE_ROOT, 'publish-assets', LERNA_CONFIG_FILE),
+];
 
 const REQUIRED_PUBLISH_CHECK_SCRIPT_KEY = 'produck:publish:check';
 const REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE =
-  'npm run produck:install && npm run produck:format && npm run produck:lint && npm run produck:coverage';
-const USER_PUBLISH_SCRIPT_KEY = 'publish';
+  'npm run produck:install && npm run produck:coverage && npm run produck:commit:check';
 const REQUIRED_PUBLISH_SCRIPT_KEY = 'produck:publish';
-const REQUIRED_PUBLISH_SCRIPT_FALLBACK_VALUE = 'npm run produck:publish:check && lerna publish';
-
-const REQUIRED_LERNA_DEFAULT_CONFIG = `${JSON.stringify(
-  {
-    $schema: 'node_modules/lerna/schemas/lerna-schema.json',
-    version: 'independent',
-  },
-  null,
-  2,
-)}\n`;
+const REQUIRED_PUBLISH_SCRIPT_VALUE =
+  'npm run produck:publish:check && npm run publish --';
+const REQUIRED_LERNA_VERSION_COMMIT_HOOKS = false;
 
 export function printSyncPublishHelp() {
   printTextResource(HELP_FILE);
@@ -38,12 +36,51 @@ function parseJsonFile(filePath, label) {
   }
 }
 
-function buildRequiredPublishScriptValue(hasUserPublishScript) {
-  if (hasUserPublishScript) {
-    return 'npm run produck:publish:check && npm run publish --';
+function loadRequiredLernaTemplate() {
+  const templatePath = LERNA_TEMPLATE_CANDIDATE_PATHS.find((candidatePath) => {
+    return fs.existsSync(candidatePath);
+  });
+
+  if (!templatePath) {
+    console.error('lerna template does not exist in expected locations:');
+    for (const candidatePath of LERNA_TEMPLATE_CANDIDATE_PATHS) {
+      console.error(`- ${candidatePath}`);
+    }
+    process.exit(2);
+  }
+
+  const template = parseJsonFile(templatePath, 'lerna template');
+  if (typeof template.version !== 'string') {
+    console.error(
+      `lerna template must have a "version" field: ${templatePath}`,
+    );
+    process.exit(2);
   }
 
-  return REQUIRED_PUBLISH_SCRIPT_FALLBACK_VALUE;
+  // The {} fallbacks below guard against templates that omit 'command' or
+  // 'command.version'; the canonical lerna template always provides both.
+  const normalizedTemplate = {
+    ...template,
+    command: {
+      ...(template.command && typeof template.command === 'object'
+        ? template.command
+        : /* c8 ignore next */
+        {}),
+      version: {
+        ...(template?.command?.version &&
+        typeof template.command.version === 'object'
+          ? template.command.version
+          : /* c8 ignore next */
+          {}),
+        commitHooks: REQUIRED_LERNA_VERSION_COMMIT_HOOKS,
+      },
+    },
+  };
+
+  return {
+    templatePath,
+    content: `${JSON.stringify(normalizedTemplate, null, 2)}\n`,
+  };
 }
 
 export function runSyncPublish(options) {
@@ -52,6 +89,7 @@ export function runSyncPublish(options) {
   const dryRun = hasFlag(options, '--dry-run') && !check;
   const jsonFile = getSingle(options, '--json', '');
   const mode = check ? 'check' : dryRun ? 'dry-run' : 'sync';
+  const requiredLernaTemplate = loadRequiredLernaTemplate();
 
   if (!fs.existsSync(cwd)) {
     console.error(`CWD does not exist: ${cwd}`);
@@ -61,19 +99,53 @@ export function runSyncPublish(options) {
   const lernaConfigPath = path.resolve(cwd, LERNA_CONFIG_FILE);
   const lernaExistedBefore = fs.existsSync(lernaConfigPath);
   let lernaDefaultCreated = false;
+  let matchesRequiredLernaCommitHooks = false;
+  let matchesRequiredLernaCommitHooksBefore = false;
 
   if (!lernaExistedBefore) {
     if (mode === 'sync') {
-      fs.writeFileSync(lernaConfigPath, REQUIRED_LERNA_DEFAULT_CONFIG, 'utf8');
+      fs.writeFileSync(lernaConfigPath, requiredLernaTemplate.content, 'utf8');
       lernaDefaultCreated = true;
+      matchesRequiredLernaCommitHooks = true;
     }
   } else {
     const lernaConfig = parseJsonFile(lernaConfigPath, 'lerna.json');
 
     if (typeof lernaConfig.version !== 'string') {
-      console.error(`lerna.json must have a "version" field: ${lernaConfigPath}`);
+      console.error(
+        `lerna.json must have a "version" field: ${lernaConfigPath}`,
+      );
       process.exit(2);
     }
+
+    const currentCommitHooks = lernaConfig?.command?.version?.commitHooks;
+    matchesRequiredLernaCommitHooks =
+      currentCommitHooks === REQUIRED_LERNA_VERSION_COMMIT_HOOKS;
+    matchesRequiredLernaCommitHooksBefore = matchesRequiredLernaCommitHooks;
+
+    if (mode === 'sync' && !matchesRequiredLernaCommitHooks) {
+      const nextLernaConfig = {
+        ...lernaConfig,
+        command: {
+          ...(lernaConfig.command && typeof lernaConfig.command === 'object'
+            ? lernaConfig.command
+            : {}),
+          version: {
+            ...(lernaConfig?.command?.version &&
+            typeof lernaConfig.command.version === 'object'
+              ? lernaConfig.command.version
+              : {}),
+            commitHooks: REQUIRED_LERNA_VERSION_COMMIT_HOOKS,
+          },
+        },
+      };
+      fs.writeFileSync(
+        lernaConfigPath,
+        `${JSON.stringify(nextLernaConfig, null, 2)}\n`,
+        'utf8',
+      );
+      matchesRequiredLernaCommitHooks = true;
+    }
   }
 
   const rootPackageJsonPath = path.resolve(cwd, 'package.json');
@@ -84,13 +156,11 @@ export function runSyncPublish(options) {
 
   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 hasUserPublishScript =
-    typeof scripts[USER_PUBLISH_SCRIPT_KEY] === 'string' &&
-    scripts[USER_PUBLISH_SCRIPT_KEY].trim() !== '';
-  const requiredPublishScriptValue = buildRequiredPublishScriptValue(hasUserPublishScript);
 
   const previousPublishCheck =
     typeof scripts[REQUIRED_PUBLISH_CHECK_SCRIPT_KEY] === 'string'
@@ -101,17 +171,30 @@ export function runSyncPublish(options) {
       ? scripts[REQUIRED_PUBLISH_SCRIPT_KEY]
       : null;
 
-  const matchesRequiredPublishCheck = previousPublishCheck === REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
-  const matchesRequiredPublish = previousPublish === requiredPublishScriptValue;
+  const matchesRequiredPublishCheck =
+    previousPublishCheck === REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
+  const matchesRequiredPublish =
+    previousPublish === REQUIRED_PUBLISH_SCRIPT_VALUE;
   const lernaRequiresCreation = !lernaExistedBefore && !lernaDefaultCreated;
   const requiresUpdate =
-    !matchesRequiredPublishCheck || !matchesRequiredPublish || lernaRequiresCreation;
-
-  if (mode === 'sync' && (!matchesRequiredPublishCheck || !matchesRequiredPublish)) {
-    scripts[REQUIRED_PUBLISH_CHECK_SCRIPT_KEY] = REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
-    scripts[REQUIRED_PUBLISH_SCRIPT_KEY] = requiredPublishScriptValue;
+    !matchesRequiredPublishCheck ||
+    !matchesRequiredPublish ||
+    lernaRequiresCreation ||
+    !matchesRequiredLernaCommitHooks;
+
+  if (
+    mode === 'sync' &&
+    (!matchesRequiredPublishCheck || !matchesRequiredPublish)
+  ) {
+    scripts[REQUIRED_PUBLISH_CHECK_SCRIPT_KEY] =
+      REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
+    scripts[REQUIRED_PUBLISH_SCRIPT_KEY] = REQUIRED_PUBLISH_SCRIPT_VALUE;
     pkg.scripts = scripts;
-    fs.writeFileSync(rootPackageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(
+      rootPackageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
   }
 
   const report = {
@@ -121,21 +204,29 @@ export function runSyncPublish(options) {
     lernaConfigPath,
     rootPackageJsonPath,
     required: {
+      lernaTemplatePath: requiredLernaTemplate.templatePath,
       publishCheckScriptKey: REQUIRED_PUBLISH_CHECK_SCRIPT_KEY,
       publishCheckScriptValue: REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE,
       publishScriptKey: REQUIRED_PUBLISH_SCRIPT_KEY,
-      publishScriptValue: requiredPublishScriptValue,
+      publishScriptValue: REQUIRED_PUBLISH_SCRIPT_VALUE,
+      lernaVersionCommitHooks: REQUIRED_LERNA_VERSION_COMMIT_HOOKS,
     },
     status: {
-      hasUserPublishScript,
       lernaExistedBefore,
       lernaDefaultCreated,
+      matchesRequiredLernaCommitHooksBefore:
+        matchesRequiredLernaCommitHooksBefore,
+      matchesRequiredLernaCommitHooksAfter: matchesRequiredLernaCommitHooks,
       matchesRequiredPublishCheckBefore: matchesRequiredPublishCheck,
       matchesRequiredPublishCheckAfter:
-        !matchesRequiredPublishCheck && mode === 'sync' ? true : matchesRequiredPublishCheck,
+        !matchesRequiredPublishCheck && mode === 'sync'
+          ? true
+          : matchesRequiredPublishCheck,
       matchesRequiredPublishBefore: matchesRequiredPublish,
       matchesRequiredPublishAfter:
-        !matchesRequiredPublish && mode === 'sync' ? true : matchesRequiredPublish,
+        !matchesRequiredPublish && mode === 'sync'
+          ? true
+          : matchesRequiredPublish,
       updated: requiresUpdate && mode === 'sync',
     },
   };

package/bin/command/validate-commit-msg/index.mjs

@@ -5,12 +5,31 @@ import { fileURLToPath } from 'node:url';
 import { getSingle } from '../shared/args.mjs';
 import { printTextResource } from '../shared/text-resource.mjs';
 
-const ALLOWED_TAGS = ['INIT', 'ADD', 'REMOVE', 'FIX', 'REFACTOR', 'UPGRADE', 'PUBLISH'];
-const ALLOWED_TARGETS = ['docs', 'test', 'ci', 'deps', 'api', 'schema', 'infra', 'fmt'];
+const ALLOWED_TAGS = [
+  'INIT',
+  'ADD',
+  'REMOVE',
+  'FIX',
+  'REFACTOR',
+  'UPGRADE',
+  'PUBLISH',
+];
+const ALLOWED_TARGETS = [
+  'docs',
+  'test',
+  'ci',
+  'deps',
+  'api',
+  'schema',
+  'infra',
+  'fmt',
+];
 const SECTION_HEADER_RE = /^(?:\*|(?:@[\w.-]+\/)?[\w.-]+):$/;
 const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
 const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
-const ROOT_PACKAGE_FILE = path.resolve(COMMAND_DIR, '../../../../../package.json');
+const ROOT_PACKAGE_FILE =
+  process.env._AGENT_TOOLKIT_TEST_ROOT_PKG ||
+  path.resolve(COMMAND_DIR, '../../../../../package.json');
 const WORKSPACE_SCOPE = 'workspace';
 const WILDCARD_SCOPE = '*';
 const DEFAULT_COMMENT_CHAR = '#';
@@ -65,42 +84,38 @@ function isMonorepoRoot() {
 
   try {
     const rootPackage = JSON.parse(fs.readFileSync(ROOT_PACKAGE_FILE, 'utf8'));
-    return Array.isArray(rootPackage.workspaces) && rootPackage.workspaces.length > 0;
+    return (
+      Array.isArray(rootPackage.workspaces) && rootPackage.workspaces.length > 0
+    );
   } catch {
     return false;
   }
 }
 
 function getMonorepoAllowedSectionScopes() {
-  if (!fs.existsSync(ROOT_PACKAGE_FILE)) {
-    return null;
-  }
-
-  let rootPackage;
-  try {
-    rootPackage = JSON.parse(fs.readFileSync(ROOT_PACKAGE_FILE, 'utf8'));
-  } catch {
-    return null;
-  }
-
-  if (!Array.isArray(rootPackage.workspaces) || rootPackage.workspaces.length === 0) {
-    return null;
-  }
-
+  const rootPackage = JSON.parse(fs.readFileSync(ROOT_PACKAGE_FILE, 'utf8'));
   const rootDir = path.dirname(ROOT_PACKAGE_FILE);
   const allowedScopes = new Set([WORKSPACE_SCOPE, WILDCARD_SCOPE]);
 
   for (const workspaceEntry of rootPackage.workspaces) {
     const workspacePath = path.resolve(rootDir, String(workspaceEntry));
-    const workspacePackageJsonPath = path.resolve(workspacePath, 'package.json');
+    const workspacePackageJsonPath = path.resolve(
+      workspacePath,
+      'package.json',
+    );
 
     if (!fs.existsSync(workspacePackageJsonPath)) {
       continue;
     }
 
     try {
-      const workspacePackage = JSON.parse(fs.readFileSync(workspacePackageJsonPath, 'utf8'));
-      if (typeof workspacePackage.name === 'string' && workspacePackage.name.trim() !== '') {
+      const workspacePackage = JSON.parse(
+        fs.readFileSync(workspacePackageJsonPath, 'utf8'),
+      );
+      if (
+        typeof workspacePackage.name === 'string' &&
+        workspacePackage.name.trim() !== ''
+      ) {
         allowedScopes.add(workspacePackage.name.trim());
       }
     } catch {
@@ -220,7 +235,9 @@ export function runValidateCommitMsg(options) {
   }
 
   const mustUseSectionHeaders = isMonorepoRoot();
-  const allowedSectionScopes = mustUseSectionHeaders ? getMonorepoAllowedSectionScopes() : null;
+  const allowedSectionScopes = mustUseSectionHeaders
+    ? getMonorepoAllowedSectionScopes()
+    : null;
   const hasSectionHeaders = lines.some((line) => isSectionHeaderLine(line));
 
   // [PUBLISH] is generated by lerna and is always a repo-wide tag.
@@ -235,11 +252,15 @@ export function runValidateCommitMsg(options) {
 
   if (mustUseSectionHeaders && !hasSectionHeaders) {
     console.error('Commit message validation failed:');
-    console.error('- Line 1: section header is required before tagged lines in monorepo mode');
+    console.error(
+      '- Line 1: section header is required before tagged lines in monorepo mode',
+    );
     process.exit(1);
   }
 
-  const errors = hasSectionHeaders ? validateSectionFormat(lines, allowedSectionScopes) : [];
+  const errors = hasSectionHeaders
+    ? validateSectionFormat(lines, allowedSectionScopes)
+    : [];
   if (!hasSectionHeaders) {
     for (let i = 0; i < lines.length; i += 1) {
       const err = validateCommitLine(lines[i], i + 1);