@produck/agent-toolkit 0.6.0 → 0.8.0

package/bin/command/{sync-coverage-script → sync-coverage}/index.mjs

@@ -14,14 +14,42 @@ const TOOLING_BASELINE_CANDIDATE_PATHS = [
   path.resolve(PACKAGE_ROOT, 'publish-assets/instructions/produck/tooling-version-baseline.json'),
 ];
 const GLOB_TOKEN_PATTERN = /[*?{}[\]]/;
+const REQUIRED_ROOT_COVERAGE_SCRIPT_KEY = 'produck:coverage';
+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\')"';
-
-export function printSyncCoverageScriptHelp() {
+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`;
+
+export function printSyncCoverageHelp() {
   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 loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find((candidatePath) => {
     return fs.existsSync(candidatePath);
@@ -36,14 +64,12 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const c8Version = baseline?.tools?.c8?.version;
-  const coverageTemplate = baseline?.coverage?.scriptTemplate;
-
   if (typeof baseline.schemaVersion !== 'number') {
     console.error(`Tooling baseline schemaVersion must be a number: ${toolingBaselinePath}`);
     process.exit(2);
   }
 
+  const c8Version = baseline?.tools?.c8?.version;
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
     console.error(
       `Tooling baseline tools.c8.version must be a non-empty string: ${toolingBaselinePath}`,
@@ -51,6 +77,7 @@ function loadToolingBaseline() {
     process.exit(2);
   }
 
+  const coverageTemplate = baseline?.coverage?.scriptTemplate;
   if (typeof coverageTemplate !== 'string' || coverageTemplate.trim() === '') {
     console.error(
       `Tooling baseline coverage.scriptTemplate must be a non-empty string: ${toolingBaselinePath}`,
@@ -74,13 +101,12 @@ function buildRequiredC8DevDependency(baseline) {
   return String(baseline.tools.c8.version);
 }
 
-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 resolveWorkspacePaths(cwd, options) {
@@ -91,20 +117,17 @@ function resolveWorkspacePaths(cwd, options) {
 
   const rootPackageJsonPath = path.resolve(cwd, 'package.json');
   if (!fs.existsSync(rootPackageJsonPath)) {
-    console.error(`Root package.json does not exist: ${rootPackageJsonPath}`);
-    process.exit(2);
+    return [];
   }
 
   const rootPackageJson = parseJsonFile(rootPackageJsonPath, 'Root package.json');
   if (!Array.isArray(rootPackageJson.workspaces)) {
-    console.error('Root package.json `workspaces` must be an explicit array');
-    process.exit(2);
+    return [];
   }
 
   const workspaces = rootPackageJson.workspaces.map((entry) => String(entry));
   if (workspaces.length === 0) {
-    console.error('Root package.json `workspaces` must not be empty');
-    process.exit(2);
+    return [];
   }
 
   const hasGlob = workspaces.some((entry) => GLOB_TOKEN_PATTERN.test(entry));
@@ -116,6 +139,69 @@ function resolveWorkspacePaths(cwd, options) {
   return workspaces;
 }
 
+function syncRootCoverage(cwd, mode, requiredC8Version) {
+  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 }
+      : {};
+  const devDependencies =
+    pkg.devDependencies &&
+    typeof pkg.devDependencies === 'object' &&
+    !Array.isArray(pkg.devDependencies)
+      ? { ...pkg.devDependencies }
+      : {};
+  const previousRootCoverageScript =
+    typeof scripts[REQUIRED_ROOT_COVERAGE_SCRIPT_KEY] === 'string'
+      ? scripts[REQUIRED_ROOT_COVERAGE_SCRIPT_KEY]
+      : null;
+  const previousC8DevDependency =
+    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 requiresUpdate =
+    !matchesRequiredRootCoverageBefore ||
+    !matchesRequiredC8DevDependencyBefore ||
+    !matchesRequiredC8ConfigBefore;
+
+  if (mode === 'sync' && requiresUpdate) {
+    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');
+  }
+
+  return {
+    rootPackageJsonPath,
+    required: {
+      rootCoverageScriptKey: REQUIRED_ROOT_COVERAGE_SCRIPT_KEY,
+      rootCoverageScriptValue: REQUIRED_ROOT_COVERAGE_SCRIPT_VALUE,
+      c8ConfigFile: REQUIRED_C8_CONFIG_FILE,
+      c8ConfigContent: REQUIRED_C8_CONFIG_CONTENT,
+      c8DevDependency: requiredC8Version,
+    },
+    status: {
+      matchesRequiredRootCoverageBefore,
+      matchesRequiredC8DevDependencyBefore,
+      matchesRequiredC8ConfigBefore,
+      matchesRequiredRootCoverageAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredRootCoverageBefore,
+      matchesRequiredC8DevDependencyAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredC8DevDependencyBefore,
+      matchesRequiredC8ConfigAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredC8ConfigBefore,
+      updated: requiresUpdate && mode === 'sync',
+    },
+  };
+}
+
 function reconcileCoverageScript(
   cwd,
   workspacePath,
@@ -230,7 +316,7 @@ function reconcileCoverageScript(
   return result;
 }
 
-export function runSyncCoverageScript(options) {
+export function runSyncCoverage(options) {
   const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
   const check = hasFlag(options, '--check');
   const dryRun = hasFlag(options, '--dry-run');
@@ -244,8 +330,9 @@ export function runSyncCoverageScript(options) {
     process.exit(2);
   }
 
-  const workspacePaths = resolveWorkspacePaths(cwd, options);
   const mode = dryRun ? 'dry-run' : check ? 'check' : 'sync';
+  const root = syncRootCoverage(cwd, mode, requiredC8Version);
+  const workspacePaths = resolveWorkspacePaths(cwd, options);
 
   const report = {
     cwd,
@@ -258,11 +345,21 @@ export function runSyncCoverageScript(options) {
     requiredCoverageScript,
     requiredTestScript: DEFAULT_TEST_SCRIPT_VALUE,
     requiredC8DevDependency: requiredC8Version,
+    root,
     workspaces: workspacePaths,
     results: [],
     ok: true,
   };
 
+  if (
+    mode === 'check' &&
+    (!root.status.matchesRequiredRootCoverageAfter ||
+      !root.status.matchesRequiredC8DevDependencyAfter ||
+      !root.status.matchesRequiredC8ConfigAfter)
+  ) {
+    report.ok = false;
+  }
+
   for (const workspacePath of workspacePaths) {
     const effectiveMode = mode === 'sync' ? 'sync' : 'check';
     const item = reconcileCoverageScript(

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

@@ -12,154 +12,10 @@ const TEMPLATE_FILE = path.resolve(COMMAND_DIR, 'editorconfig.template');
 
 const REQUIRED_EDITORCONFIG_CONTENT = fs.readFileSync(TEMPLATE_FILE, 'utf8');
 
-// Required key-value pairs for validation
-const REQUIRED_SECTIONS = {
-  root: {
-    line: 'root = true',
-  },
-  '*': {
-    keys: {
-      charset: 'utf-8',
-      indent_style: 'space',
-      indent_size: '2',
-      trim_trailing_whitespace: 'true',
-    },
-  },
-  '*.{yml,yaml}': {
-    keys: {
-      indent_style: 'space',
-      indent_size: '2',
-    },
-  },
-  '*.md': {
-    keys: {
-      trim_trailing_whitespace: 'false',
-      max_line_length: '80',
-    },
-  },
-};
-
 export function printSyncEditorconfigHelp() {
   printTextResource(HELP_FILE);
 }
 
-function parseEditorconfig(content) {
-  const sections = {};
-  let currentSection = null;
-
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-
-    // Skip empty lines and comments
-    if (trimmed === '' || trimmed.startsWith('#') || trimmed.startsWith(';')) {
-      continue;
-    }
-
-    // Check for section header
-    const sectionMatch = trimmed.match(/^\[(.+)\]$/);
-    if (sectionMatch) {
-      currentSection = sectionMatch[1];
-      sections[currentSection] = {};
-      continue;
-    }
-
-    // Check for root = true
-    const rootMatch = trimmed.match(/^root\s*=\s*(.+)$/i);
-    if (rootMatch && !currentSection) {
-      sections._root = rootMatch[1].trim().toLowerCase();
-      continue;
-    }
-
-    // Parse key-value pair
-    if (currentSection) {
-      const kvMatch = trimmed.match(/^([^=]+)\s*=\s*(.+)$/);
-      if (kvMatch) {
-        sections[currentSection][kvMatch[1].trim().toLowerCase()] = kvMatch[2].trim().toLowerCase();
-      }
-    }
-  }
-
-  return sections;
-}
-
-function validateEditorconfig(sections) {
-  const mismatches = [];
-
-  // Check root
-  if (sections._root !== 'true') {
-    mismatches.push({ section: '_root', expected: 'true', actual: sections._root || 'missing' });
-  }
-
-  // Check each required section
-  for (const [sectionName, config] of Object.entries(REQUIRED_SECTIONS)) {
-    if (sectionName === 'root') continue;
-
-    if (!sections[sectionName]) {
-      mismatches.push({ section: `[${sectionName}]`, expected: 'present', actual: 'missing' });
-      continue;
-    }
-
-    if (config.keys) {
-      for (const [key, expectedValue] of Object.entries(config.keys)) {
-        const actualValue = sections[sectionName][key];
-        if (actualValue !== expectedValue) {
-          mismatches.push({
-            section: `[${sectionName}]`,
-            key,
-            expected: expectedValue,
-            actual: actualValue || 'missing',
-          });
-        }
-      }
-    }
-  }
-
-  return mismatches;
-}
-
-function buildUpdatedContent(existingContent) {
-  const existingSections = parseEditorconfig(existingContent);
-  const lines = [];
-
-  // Add root if missing
-  if (existingSections._root !== 'true') {
-    lines.push('root = true');
-  }
-
-  // Process each required section
-  for (const [sectionName, config] of Object.entries(REQUIRED_SECTIONS)) {
-    if (sectionName === 'root') continue;
-
-    const existingSection = existingSections[sectionName] || {};
-    const missingKeys = [];
-
-    if (config.keys) {
-      for (const [key, expectedValue] of Object.entries(config.keys)) {
-        if (existingSection[key] !== expectedValue) {
-          missingKeys.push({ key, value: expectedValue });
-        }
-      }
-    }
-
-    if (missingKeys.length > 0 || !existingSections[sectionName]) {
-      lines.push('');
-      lines.push(`[${sectionName}]`);
-      for (const { key, value } of missingKeys) {
-        lines.push(`${key} = ${value}`);
-      }
-    }
-  }
-
-  // If no updates needed, return original
-  // c8 ignore next 3
-  if (lines.length === 0) {
-    return existingContent;
-  }
-
-  // Append missing entries to existing content
-  return existingContent.trimEnd() + lines.join('\n') + '\n';
-}
-
 function readFileIfExists(filePath) {
   if (!fs.existsSync(filePath)) {
     return null;
@@ -183,17 +39,18 @@ 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 sections = currentContent ? parseEditorconfig(currentContent) : {};
-  const mismatches = validateEditorconfig(sections);
-  const requiresUpdate = mismatches.length > 0 || !fileExists;
-
-  let plannedContent = null;
-  if (requiresUpdate) {
-    plannedContent = fileExists
-      ? buildUpdatedContent(currentContent)
-      : REQUIRED_EDITORCONFIG_CONTENT;
+  const mismatches = [];
+  if (!upToDate) {
+    mismatches.push({
+      file: EDITORCONFIG_FILE,
+      expected: 'exact required content',
+      actual: fileExists ? 'different content' : 'missing',
+    });
   }
+  const requiresUpdate = mismatches.length > 0;
+  const plannedContent = requiresUpdate ? REQUIRED_EDITORCONFIG_CONTENT : null;
 
   if (mode === 'sync' && requiresUpdate && plannedContent) {
     fs.writeFileSync(editorconfigPath, plannedContent, 'utf8');

package/bin/command/{sync-prettier-config → sync-format}/help.txt

@@ -1,12 +1,14 @@
 Usage:
-  agent-toolkit sync-prettier-config [--cwd <dir>] [--check] [--dry-run]
+  agent-toolkit sync-format [--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
+    - scripts.produck:format = prettier --write . --ignore-path .prettierignore --ignore-path .gitignore
   - Applies organization-required root Prettier config file:
     - .prettierrc
+  - Applies organization-required root Prettier ignore file:
+    - .prettierignore (prettier-specific patterns; .gitignore is also used via --ignore-path)
 
 Rules:
   - --check validates without writing and exits non-zero on mismatch

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

@@ -0,0 +1,222 @@
+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 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'),
+];
+const PRETTIER_CONFIG_FILE = '.prettierrc';
+const PRETTIER_IGNORE_FILE = '.prettierignore';
+const REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY = 'prettier';
+
+const PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS = [
+  path.resolve(REPO_ROOT, '.prettierignore'),
+  path.resolve(PACKAGE_ROOT, 'publish-assets/prettierignore'),
+];
+
+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 loadPrettierIgnoreContent() {
+  const sourcePath = PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS.find((p) => fs.existsSync(p));
+
+  if (!sourcePath) {
+    console.error('Org .prettierignore source not found in expected locations:');
+    for (const p of PRETTIER_IGNORE_SOURCE_CANDIDATE_PATHS) {
+      console.error(`- ${p}`);
+    }
+    process.exit(2);
+  }
+
+  return {
+    sourcePath,
+    content: fs.readFileSync(sourcePath, 'utf8'),
+  };
+}
+
+export function printSyncFormatHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function readFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+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 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 prettierVersion = String(baseline?.tools?.prettier?.version || '').trim();
+
+  if (!prettierVersion) {
+    console.error(
+      `Tooling baseline must define fixed tools.prettier.version: ${toolingBaselinePath}`,
+    );
+    process.exit(2);
+  }
+
+  return { toolingBaselinePath, prettierVersion };
+}
+
+export function runSyncFormat(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 toolingBaseline = loadToolingBaseline();
+  const requiredPrettierVersion = toolingBaseline.prettierVersion;
+  const { sourcePath: prettierIgnoreSourcePath, content: REQUIRED_PRETTIER_IGNORE_CONTENT } =
+    loadPrettierIgnoreContent();
+  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 previousFormat =
+    typeof scripts[REQUIRED_FORMAT_SCRIPT_KEY] === 'string'
+      ? scripts[REQUIRED_FORMAT_SCRIPT_KEY]
+      : null;
+  const previousPrettierDep =
+    typeof devDependencies[REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY] === 'string'
+      ? devDependencies[REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY]
+      : null;
+
+  const prettierConfigPath = path.resolve(cwd, PRETTIER_CONFIG_FILE);
+  const prettierIgnorePath = path.resolve(cwd, PRETTIER_IGNORE_FILE);
+  const previousPrettierConfig = readFileIfExists(prettierConfigPath);
+  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 requiresUpdate =
+    !matchesRequiredFormat ||
+    !matchesRequiredPrettierConfig ||
+    !matchesRequiredPrettierDep ||
+    !matchesRequiredPrettierIgnore;
+
+  if (mode === 'sync' && requiresUpdate) {
+    scripts[REQUIRED_FORMAT_SCRIPT_KEY] = REQUIRED_FORMAT_SCRIPT_VALUE;
+    pkg.scripts = scripts;
+
+    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');
+  }
+
+  const report = {
+    cwd,
+    mode,
+    ok: true,
+    rootPackageJsonPath,
+    toolingBaselinePath: toolingBaseline.toolingBaselinePath,
+    required: {
+      formatScriptKey: REQUIRED_FORMAT_SCRIPT_KEY,
+      formatScriptValue: REQUIRED_FORMAT_SCRIPT_VALUE,
+      prettierConfigPath: path.relative(cwd, prettierConfigPath),
+      prettierIgnorePath: path.relative(cwd, prettierIgnorePath),
+      prettierIgnoreSourcePath,
+      managedDevDependencies: { [REQUIRED_PRETTIER_DEV_DEPENDENCY_KEY]: requiredPrettierVersion },
+    },
+    status: {
+      matchesRequiredFormatBefore: matchesRequiredFormat,
+      matchesRequiredPrettierConfigBefore: matchesRequiredPrettierConfig,
+      matchesRequiredPrettierDepBefore: matchesRequiredPrettierDep,
+      matchesRequiredPrettierIgnoreBefore: matchesRequiredPrettierIgnore,
+      matchesRequiredFormatAfter: requiresUpdate && mode === 'sync' ? true : matchesRequiredFormat,
+      matchesRequiredPrettierConfigAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierConfig,
+      matchesRequiredPrettierDepAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierDep,
+      matchesRequiredPrettierIgnoreAfter:
+        requiresUpdate && mode === 'sync' ? true : matchesRequiredPrettierIgnore,
+      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 → sync-git}/help.txt

@@ -1,19 +1,23 @@
 Usage:
-  agent-toolkit sync-workspace-config [--cwd <dir>] [--check] [--dry-run]
+  agent-toolkit sync-git [--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
+    - scripts.produck:commit:check = npm run produck:format && npm run produck:lint
   - 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>
+  - Applies organization-required root .gitattributes file (exact replacement)
+  - Normalizes line endings for text files
+  - Keeps Windows script entrypoints on CRLF
+  - Ensures root .gitignore contains all org-baseline required entries
+    (downstream can extend; missing entries are appended)
+  - Applies organization-required hook files:
+    - .husky/pre-commit
+    - .husky/commit-msg
 
 Rules:
   - --check validates without writing and exits non-zero on mismatch