@produck/agent-toolkit 0.9.1 → 0.10.0

package/bin/agent-toolkit.mjs

@@ -42,6 +42,10 @@ import {
   printSyncPublishHelp,
   runSyncPublish,
 } from './command/sync-publish/index.mjs';
+import {
+  printSyncTypescriptHelp,
+  runSyncTypescript,
+} from './command/sync-typescript/index.mjs';
 import { hasFlag, parseCommonArgs } from './command/shared/args.mjs';
 import {
   printValidateCommitMsgHelp,
@@ -101,6 +105,10 @@ const COMMANDS = {
     printHelp: printSyncPublishHelp,
     run: runSyncPublish,
   },
+  'sync-typescript': {
+    printHelp: printSyncTypescriptHelp,
+    run: runSyncTypescript,
+  },
 };
 
 const DEFAULT_COMMAND = 'enforce-node-baseline';

package/bin/build-publish-assets.mjs

@@ -49,6 +49,7 @@ const OUTPUT_LERNA_PATH = path.resolve(
   PACKAGE_ROOT,
   'publish-assets/lerna.json',
 );
+const ROOT_PACKAGE_JSON_PATH = path.resolve(REPO_ROOT, 'package.json');
 const LEGACY_OUTPUT_PATH = path.resolve(
   PACKAGE_ROOT,
   'publish-assets/instructions/org.instructions.md',
@@ -80,6 +81,10 @@ function validateSourceFile(fileName, text) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
 function readAndValidateToolingBaseline() {
   if (!fs.existsSync(SOURCE_TOOLING_BASELINE_PATH)) {
     throw new Error(
@@ -98,25 +103,40 @@ function readAndValidateToolingBaseline() {
     );
   }
 
-  const c8Version = baseline?.tools?.c8?.version;
-  const lernaVersion = baseline?.tools?.lerna?.version;
-  const coverageScriptTemplate = baseline?.coverage?.scriptTemplate;
-
   if (typeof baseline.schemaVersion !== 'number') {
     throw new Error(
       `Invalid tooling baseline schemaVersion in: ${SOURCE_TOOLING_BASELINE_PATH}`,
     );
   }
 
+  // Auto-resolve tool versions: only override version when set to "auto"
+  const rootPkg = JSON.parse(fs.readFileSync(ROOT_PACKAGE_JSON_PATH, 'utf8'));
+  const devDeps = rootPkg.devDependencies || {};
+
+  for (const [toolName, entry] of Object.entries(baseline.tools)) {
+    if (entry.version === 'auto') {
+      const depVersion = devDeps[toolName];
+      if (typeof depVersion === 'string' && depVersion.trim()) {
+        entry.version = resolveSemverExact(depVersion);
+      }
+    }
+  }
+
+  const c8Version = baseline?.tools?.c8?.version;
+  const lernaVersion = baseline?.tools?.lerna?.version;
+  const coverageScriptTemplate = baseline?.coverage?.scriptTemplate;
+
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
     throw new Error(
-      `Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+      `Invalid tools.c8.version in: ${SOURCE_TOOLING_BASELINE_PATH} ` +
+        '(c8 must be listed in root package.json devDependencies)',
     );
   }
 
   if (typeof lernaVersion !== 'string' || lernaVersion.trim() === '') {
     throw new Error(
-      `Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH}`,
+      `Invalid tools.lerna.version in: ${SOURCE_TOOLING_BASELINE_PATH} ` +
+        '(lerna must be listed in root package.json devDependencies)',
     );
   }
 
@@ -129,6 +149,7 @@ function readAndValidateToolingBaseline() {
     );
   }
 
+  // Dynamically inject @produck/eslint-rules version from its own package.json
   const eslintRulesPkgPath = path.resolve(
     PACKAGE_ROOT,
     '../eslint-rules/package.json',
@@ -146,6 +167,7 @@ function readAndValidateToolingBaseline() {
       };
     }
   }
+
   return `${JSON.stringify(baseline, null, 2)}\n`;
 }
 

package/bin/command/main/help.txt

@@ -7,6 +7,7 @@ agent-toolkit commands:
   sync-editorconfig
   sync-git
   sync-format
+  sync-typescript
   sync-install
   sync-lint
   sync-publish

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

@@ -21,8 +21,13 @@ const TOOLING_BASELINE_CANDIDATE_PATHS = [
 ];
 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_ROOT_COVERAGE_SCRIPT_VALUE = [
+  'c8',
+  '--config .c8rc.json',
+  'npm run test',
+  '--workspaces',
+  '--if-present',
+].join(' ');
 const REQUIRED_COVERAGE_SCRIPT_KEY = 'produck:coverage';
 const REQUIRED_TEST_SCRIPT_KEY = 'test';
 const DEFAULT_TEST_SCRIPT_VALUE =
@@ -46,6 +51,35 @@ function parseJsonFile(filePath, label) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -71,7 +105,7 @@ function loadToolingBaseline() {
     process.exit(2);
   }
 
-  const c8Version = baseline?.tools?.c8?.version;
+  const c8Version = resolveToolVersionFromDevDeps(baseline, 'c8');
   if (typeof c8Version !== 'string' || c8Version.trim() === '') {
     console.error(
       `Tooling baseline tools.c8.version must be a non-empty string: ${toolingBaselinePath}`,

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

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

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

@@ -99,6 +99,35 @@ function parseJsonFile(filePath, label) {
   }
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -117,9 +146,7 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const prettierVersion = String(
-    baseline?.tools?.prettier?.version || '',
-  ).trim();
+  const prettierVersion = resolveToolVersionFromDevDeps(baseline, 'prettier');
 
   if (!prettierVersion) {
     console.error(

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

@@ -4,7 +4,7 @@ Usage:
 
 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:baseline = npm exec --package=@produck/agent-toolkit@latest -- agent-toolkit enforce-node-baseline --cwd . && npm run produck:install
     - scripts.produck:commit:check = npm run produck:format && npm run produck:lint
     - scripts.prepare = husky
   - Applies organization-required root shared managed devDependencies:

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

@@ -29,11 +29,22 @@ const HUSKY_DIR = '.husky';
 const PRE_COMMIT_HOOK_FILE = 'pre-commit';
 const COMMIT_MSG_HOOK_FILE = 'commit-msg';
 const REQUIRED_BASELINE_SCRIPT_KEY = 'produck:baseline';
-const REQUIRED_BASELINE_SCRIPT_VALUE =
-  'npm exec --package=@produck/agent-toolkit@latest -- agent-toolkit enforce-node-baseline --cwd .';
+const REQUIRED_BASELINE_SCRIPT_VALUE = [
+  [
+    'npm exec',
+    '--package=@produck/agent-toolkit@latest',
+    '--',
+    'agent-toolkit',
+    'enforce-node-baseline',
+    '--cwd .',
+  ].join(' '),
+  'npm run produck:install',
+].join(' && ');
 const REQUIRED_COMMIT_CHECK_SCRIPT_KEY = 'produck:commit:check';
-const REQUIRED_COMMIT_CHECK_SCRIPT_VALUE =
-  'npm run produck:format && npm run produck:lint';
+const REQUIRED_COMMIT_CHECK_SCRIPT_VALUE = [
+  'npm run produck:format',
+  'npm run produck:lint',
+].join(' && ');
 const REQUIRED_PREPARE_SCRIPT_KEY = 'prepare';
 const REQUIRED_PREPARE_SCRIPT_VALUE = 'husky';
 
@@ -105,6 +116,35 @@ function getRequiredToolkitDevDependency() {
   return version;
 }
 
+function resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  // If baseline has a concrete version (not "auto"), use it directly.
+  // This is the case when reading the published publish-assets baseline.
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  // Fall back to resolving from local root package.json devDependencies.
+  // This covers source baseline with version="auto" during local dev.
+  const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+  const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+    const dep = pkg?.devDependencies?.[toolName];
+    if (typeof dep === 'string' && dep.trim()) {
+      return resolveSemverExact(dep);
+    }
+  }
+
+  return '';
+}
+
 function loadToolingBaseline() {
   const toolingBaselinePath = TOOLING_BASELINE_CANDIDATE_PATHS.find(
     (candidatePath) => {
@@ -123,8 +163,8 @@ function loadToolingBaseline() {
   }
 
   const baseline = parseJsonFile(toolingBaselinePath, 'Tooling baseline file');
-  const huskyVersion = String(baseline?.tools?.husky?.version || '').trim();
-  const lernaVersion = String(baseline?.tools?.lerna?.version || '').trim();
+  const huskyVersion = resolveToolVersionFromDevDeps(baseline, 'husky');
+  const lernaVersion = resolveToolVersionFromDevDeps(baseline, 'lerna');
 
   if (!huskyVersion || !lernaVersion) {
     console.error(

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

@@ -9,7 +9,7 @@ const COMMAND_DIR = path.dirname(fileURLToPath(import.meta.url));
 const HELP_FILE = path.resolve(COMMAND_DIR, 'help.txt');
 const LEGACY_INSTALL_SCRIPT_KEY = 'deps:install';
 const REQUIRED_INSTALL_SCRIPT_KEY = 'produck:install';
-const REQUIRED_INSTALL_SCRIPT_VALUE = 'npm -v && npm install';
+const REQUIRED_INSTALL_SCRIPT_VALUE = ['npm -v', 'npm install'].join(' && ');
 
 export function printSyncInstallHelp() {
   printTextResource(HELP_FILE);

package/bin/command/sync-lint/eslint.config.template.mjs

@@ -1,8 +1,6 @@
 import js from '@eslint/js';
 import globals from 'globals';
 import tseslint from 'typescript-eslint';
-import json from '@eslint/json';
-import markdown from '@eslint/markdown';
 import { defineConfig } from 'eslint/config';
 import * as ProduckRule from '@produck/eslint-rules';
 
@@ -14,19 +12,8 @@ export default defineConfig([
     languageOptions: { globals: { ...globals.browser, ...globals.node } },
   },
   tseslint.configs.recommended,
-  {
-    files: ['**/*.json'],
-    ignores: ['**/package-lock.json'],
-    plugins: { json },
-    language: 'json/json',
-    extends: ['json/recommended'],
-  },
-  {
-    files: ['**/*.md'],
-    plugins: { markdown },
-    language: 'markdown/gfm',
-    extends: ['markdown/recommended'],
-  },
-  ProduckRule.config,
+  ProduckRule.config.ecma,
+  ProduckRule.config.json,
+  ProduckRule.config.markdown,
   ProduckRule.excludeGitIgnore(import.meta.url),
 ]);

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

@@ -21,6 +21,12 @@ const TOOLING_BASELINE_CANDIDATE_PATHS = [
 ];
 const ESLINT_RULES_PACKAGE_NAME = '@produck/eslint-rules';
 const ESLINT_CONFIG_FILE = 'eslint.config.mjs';
+const REQUIRED_ESLINT_ENTRIES = [
+  'ProduckRule.config.ecma',
+  'ProduckRule.config.json',
+  'ProduckRule.config.markdown',
+  'ProduckRule.excludeGitIgnore(import.meta.url)',
+];
 
 const REQUIRED_LINT_SCRIPT_KEY = 'produck:lint';
 const REQUIRED_LINT_SCRIPT_VALUE = 'eslint --fix . --max-warnings=0';
@@ -122,16 +128,38 @@ function getRequiredEslintDevDependencies() {
     eslintRulesVersion = v;
   }
 
+  function resolveSemverExact(text) {
+    return text.replace(/^[\^~>=<]+\s*/, '').trim();
+  }
+
+  function resolveToolVersionFromDevDeps(name) {
+    // If baseline has a concrete version (not "auto"), use it directly.
+    // This is the case when reading the published publish-assets baseline.
+    const entry = baseline?.tools?.[name];
+    const v = typeof entry?.version === 'string' ? entry.version.trim() : '';
+    if (v && v !== 'auto') {
+      return v;
+    }
+
+    // Fall back to resolving from local root package.json devDependencies.
+    // This covers source baseline with version="auto" during local dev.
+    const repoRoot = path.resolve(PACKAGE_ROOT, '../..');
+    const pkgJsonPath = path.resolve(repoRoot, 'package.json');
+    if (fs.existsSync(pkgJsonPath)) {
+      const pkg = parseJsonFile(pkgJsonPath, 'root package.json');
+      const dep = pkg?.devDependencies?.[name];
+      if (typeof dep === 'string' && dep.trim()) {
+        return resolveSemverExact(dep);
+      }
+    }
+
+    return '';
+  }
+
   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 */
+    const v = resolveToolVersionFromDevDeps(name);
     if (!v) {
       console.error(
         `Tooling baseline tools["${name}"].version must be a non-empty string: ${toolingBaselinePath}`,
@@ -169,7 +197,7 @@ function patchEslintConfig(existing) {
   }
 
   output =
-    `${output.slice(0, exportEnd)}  ProduckRule.config,\n  ProduckRule.excludeGitIgnore(import.meta.url),\n` +
+    `${output.slice(0, exportEnd)}  ProduckRule.config.ecma,\n  ProduckRule.config.json,\n  ProduckRule.config.markdown,\n  ProduckRule.excludeGitIgnore(import.meta.url),\n` +
     output.slice(exportEnd);
 
   if (!output.endsWith('\n')) {
@@ -235,8 +263,14 @@ export function runSyncLint(options) {
     nextEslintConfigText = REQUIRED_ESLINT_CONFIG;
   } else if (previousEslintConfig === REQUIRED_ESLINT_CONFIG) {
     matchesRequiredEslintConfig = true;
-  } else if (previousEslintConfig.includes('@produck/eslint-rules')) {
+  } else if (
+    previousEslintConfig.includes(ESLINT_RULES_PACKAGE_NAME) &&
+    REQUIRED_ESLINT_ENTRIES.every((e) => previousEslintConfig.includes(e))
+  ) {
     matchesRequiredEslintConfig = true;
+  } else if (previousEslintConfig.includes(ESLINT_RULES_PACKAGE_NAME)) {
+    eslintConfigAction = 'replaced';
+    nextEslintConfigText = REQUIRED_ESLINT_CONFIG;
   } else {
     const patched = patchEslintConfig(previousEslintConfig);
     if (patched.ok) {

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

@@ -16,11 +16,16 @@ const LERNA_TEMPLATE_CANDIDATE_PATHS = [
 ];
 
 const REQUIRED_PUBLISH_CHECK_SCRIPT_KEY = 'produck:publish:check';
-const REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE =
-  'npm run produck:install && npm run produck:coverage && npm run produck:commit:check';
+const REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE = [
+  'npm run produck:install',
+  'npm run produck:coverage',
+  'npm run produck:commit:check',
+].join(' && ');
 const REQUIRED_PUBLISH_SCRIPT_KEY = 'produck:publish';
-const REQUIRED_PUBLISH_SCRIPT_VALUE =
-  'npm run produck:publish:check && npm run publish --';
+const REQUIRED_PUBLISH_SCRIPT_VALUE = [
+  'npm run produck:publish:check',
+  'npm run publish --',
+].join(' && ');
 const REQUIRED_LERNA_VERSION_COMMIT_HOOKS = false;
 
 export function printSyncPublishHelp() {

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

@@ -0,0 +1,14 @@
+Usage:
+  agent-toolkit sync-typescript --package-root <pkg> [--cwd <dir>]
+    [--check] [--dry-run] [--json <file>]
+
+Behavior:
+  - Creates a tsconfig.json for a sub-package that extends the root
+    tsconfig.json with the correct relative path
+  - If tsconfig.json already exists, skips without modifying
+
+Rules:
+  - --package-root is required
+  - --check validates without writing and exits non-zero if file is missing
+  - --dry-run prints planned changes without writing
+  - --check takes precedence over --dry-run

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

@@ -0,0 +1,154 @@
+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 TSCONFIG_FILE = 'tsconfig.json';
+
+const PACKAGE_TSCONFIG_TEMPLATE = {
+  compilerOptions: {
+    lib: ['ESNext'],
+    types: ['node'],
+    strictNullChecks: true,
+    allowJs: true,
+    noEmit: true,
+    module: 'NodeNext',
+  },
+};
+
+export function printSyncTypescriptHelp() {
+  printTextResource(HELP_FILE);
+}
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function computeExtendsPath(packageRoot, repoRoot) {
+  const relative = path.relative(packageRoot, repoRoot);
+  const normalized = relative.replace(/\\/g, '/');
+  if (!normalized || normalized === '.') {
+    return './tsconfig.json';
+  }
+  return normalized.startsWith('..')
+    ? `${normalized}/tsconfig.json`
+    : `./${normalized}/tsconfig.json`;
+}
+
+export function runSyncTypescript(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 packageRoot = getSingle(options, '--package-root', '');
+  const mode = check ? 'check' : dryRun ? 'dry-run' : 'sync';
+
+  if (!packageRoot) {
+    console.error('--package-root is required');
+    process.exit(2);
+  }
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const pkgDir = path.resolve(cwd, packageRoot);
+  if (!fs.existsSync(pkgDir)) {
+    console.error(`Package root does not exist: ${pkgDir}`);
+    process.exit(2);
+  }
+
+  const tsconfigPath = path.resolve(pkgDir, TSCONFIG_FILE);
+  const current = readJsonIfExists(tsconfigPath);
+  const fileExists = current !== null;
+
+  // If tsconfig.json already exists, skip without checking content
+  if (fileExists) {
+    const report = {
+      cwd,
+      mode,
+      ok: true,
+      tsconfigPath,
+      required: {
+        file: path.join(packageRoot, TSCONFIG_FILE),
+      },
+      status: {
+        fileExistsBefore: true,
+        mismatchesBefore: [],
+        fileExistsAfter: true,
+        mismatchesAfter: [],
+        updated: false,
+        skipped: true,
+      },
+    };
+
+    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`);
+    return;
+  }
+
+  const expectedExtends = computeExtendsPath(pkgDir, cwd);
+  const expectedPkgConfig = {
+    extends: expectedExtends,
+    ...PACKAGE_TSCONFIG_TEMPLATE,
+  };
+
+  const plannedContent = `${JSON.stringify(expectedPkgConfig, null, 2)}\n`;
+
+  if (mode === 'sync') {
+    fs.writeFileSync(tsconfigPath, plannedContent, 'utf8');
+  }
+
+  const mismatches = [
+    {
+      file: path.join(packageRoot, TSCONFIG_FILE),
+      expected: JSON.stringify(expectedPkgConfig, null, 2),
+      actual: 'missing',
+    },
+  ];
+
+  const report = {
+    cwd,
+    mode,
+    ok: mode !== 'check',
+    tsconfigPath,
+    required: {
+      file: path.join(packageRoot, TSCONFIG_FILE),
+    },
+    status: {
+      fileExistsBefore: false,
+      mismatchesBefore: mismatches,
+      fileExistsAfter: mode === 'sync',
+      mismatchesAfter: mode === 'sync' ? [] : mismatches,
+      updated: mode === 'sync',
+    },
+  };
+
+  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);
+  }
+}