@produck/agent-toolkit 0.9.2 → 0.11.0

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

@@ -26,6 +26,8 @@ const REQUIRED_PUBLISH_SCRIPT_VALUE = [
   'npm run produck:publish:check',
   'npm run publish --',
 ].join(' && ');
+const REQUIRED_ROOT_PUBLISH_SCRIPT_KEY = 'publish';
+const REQUIRED_ROOT_PUBLISH_SCRIPT_VALUE = 'lerna publish';
 const REQUIRED_LERNA_VERSION_COMMIT_HOOKS = false;
 
 export function printSyncPublishHelp() {
@@ -175,31 +177,49 @@ export function runSyncPublish(options) {
     typeof scripts[REQUIRED_PUBLISH_SCRIPT_KEY] === 'string'
       ? scripts[REQUIRED_PUBLISH_SCRIPT_KEY]
       : null;
+  const previousRootPublish =
+    typeof scripts[REQUIRED_ROOT_PUBLISH_SCRIPT_KEY] === 'string' &&
+    scripts[REQUIRED_ROOT_PUBLISH_SCRIPT_KEY].trim() !== ''
+      ? scripts[REQUIRED_ROOT_PUBLISH_SCRIPT_KEY]
+      : null;
 
   const matchesRequiredPublishCheck =
     previousPublishCheck === REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
   const matchesRequiredPublish =
     previousPublish === REQUIRED_PUBLISH_SCRIPT_VALUE;
+  const hasRequiredRootPublishBefore = previousRootPublish !== null;
   const lernaRequiresCreation = !lernaExistedBefore && !lernaDefaultCreated;
   const requiresUpdate =
     !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',
-    );
+    !matchesRequiredLernaCommitHooks ||
+    !hasRequiredRootPublishBefore;
+
+  if (mode === 'sync') {
+    let needsWrite = false;
+
+    if (!matchesRequiredPublishCheck || !matchesRequiredPublish) {
+      scripts[REQUIRED_PUBLISH_CHECK_SCRIPT_KEY] =
+        REQUIRED_PUBLISH_CHECK_SCRIPT_VALUE;
+      scripts[REQUIRED_PUBLISH_SCRIPT_KEY] = REQUIRED_PUBLISH_SCRIPT_VALUE;
+      needsWrite = true;
+    }
+
+    if (!hasRequiredRootPublishBefore) {
+      scripts[REQUIRED_ROOT_PUBLISH_SCRIPT_KEY] =
+        REQUIRED_ROOT_PUBLISH_SCRIPT_VALUE;
+      needsWrite = true;
+    }
+
+    if (needsWrite) {
+      pkg.scripts = scripts;
+      fs.writeFileSync(
+        rootPackageJsonPath,
+        `${JSON.stringify(pkg, null, 2)}\n`,
+        'utf8',
+      );
+    }
   }
 
   const report = {
@@ -232,6 +252,9 @@ export function runSyncPublish(options) {
         !matchesRequiredPublish && mode === 'sync'
           ? true
           : matchesRequiredPublish,
+      hasRequiredRootPublishBefore,
+      hasRequiredRootPublishAfter:
+        mode === 'sync' ? true : hasRequiredRootPublishBefore,
       updated: requiresUpdate && mode === 'sync',
     },
   };

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);
+  }
+}

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

@@ -0,0 +1,22 @@
+Usage:
+  agent-toolkit sync-workspace [--cwd <dir>]
+    [--workspace <path>] ... [--check] [--dry-run] [--json <file>]
+
+Behavior:
+  - Adds or updates scripts.produck:coverage and devDependencies.c8
+    in each workspace package.json.
+  - Enforces scripts.test in each workspace package.json.
+  - If scripts.test is missing, generates:
+    node -e "console.log('No tests configured')"
+  - The produck:coverage script in workspaces is for local and AI
+    development use only.
+  - Organization-reserved script key is scripts.produck:coverage
+  - c8 version is resolved from organization tooling baseline file
+
+Rules:
+  - When --workspace is omitted, root package.json workspaces are used
+  - Single-level glob patterns (e.g. packages/*) are expanded automatically
+  - Recursive glob patterns (e.g. packages/**) are rejected
+  - Workspace package.json files must pin devDependencies.c8 to baseline version
+  - --check validates without writing and exits non-zero on mismatch
+  - --dry-run prints planned changes without writing

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

@@ -0,0 +1,379 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { getMulti, 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 GLOB_TOKEN_PATTERN = /[*?{}[\]]/;
+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 printSyncWorkspaceHelp() {
+  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 resolveSemverExact(text) {
+  return text.replace(/^[\^~>=<]+\s*/, '').trim();
+}
+
+function resolveToolVersionFromDevDeps(baseline, toolName) {
+  const baselineVersion = String(
+    baseline?.tools?.[toolName]?.version || '',
+  ).trim();
+  if (baselineVersion && baselineVersion !== 'auto') {
+    return baselineVersion;
+  }
+
+  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) => 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');
+  if (typeof baseline.schemaVersion !== 'number') {
+    console.error(
+      `Tooling baseline schemaVersion must be a number: ${toolingBaselinePath}`,
+    );
+    process.exit(2);
+  }
+
+  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}`,
+    );
+    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}`,
+    );
+    process.exit(2);
+  }
+
+  return { baseline, toolingBaselinePath };
+}
+
+function buildRequiredCoverageScript(baseline) {
+  const c8Version = String(baseline.tools.c8.version);
+  const coverageTemplate = String(baseline.coverage.scriptTemplate);
+  return coverageTemplate.replace(/\{c8\.version\}/g, c8Version);
+}
+
+function buildRequiredC8DevDependency(baseline) {
+  return String(baseline.tools.c8.version);
+}
+
+function expandGlobPatterns(cwd, entries) {
+  const result = [];
+  for (const entry of entries) {
+    // Reject recursive glob patterns (**) as too dangerous to auto-expand
+    if (entry.includes('**')) {
+      console.error(
+        `Recursive glob pattern '${entry}' is not allowed in workspaces. ` +
+          'Use explicit paths or single-level globs (e.g. packages/*).',
+      );
+      process.exit(2);
+    }
+
+    const starIndex = entry.indexOf('*');
+    if (starIndex === -1) {
+      result.push(entry);
+      continue;
+    }
+
+    // entry is like "packages/*" → split at first *
+    const baseDir = entry.slice(0, starIndex);
+    const basePath = path.resolve(cwd, baseDir);
+
+    if (!fs.existsSync(basePath)) {
+      continue;
+    }
+
+    const dirEntries = fs.readdirSync(basePath, { withFileTypes: true });
+    const remainder = entry.slice(starIndex + 1);
+
+    for (const dirent of dirEntries) {
+      if (dirent.isDirectory()) {
+        const subpath = `${baseDir}${dirent.name}${remainder}`;
+        result.push(subpath);
+      }
+    }
+  }
+  return result.sort();
+}
+
+function resolveWorkspacePaths(cwd, options) {
+  const manual = getMulti(options, '--workspace');
+  if (manual.length > 0) {
+    return manual;
+  }
+
+  const rootPackageJsonPath = path.resolve(cwd, 'package.json');
+  const rootPackageJson = parseJsonFile(
+    rootPackageJsonPath,
+    'Root package.json',
+  );
+  if (!Array.isArray(rootPackageJson.workspaces)) {
+    return [];
+  }
+
+  const raw = rootPackageJson.workspaces.map((entry) => String(entry));
+  if (raw.length === 0) {
+    return [];
+  }
+
+  const hasGlob = raw.some((entry) => GLOB_TOKEN_PATTERN.test(entry));
+  if (hasGlob) {
+    return expandGlobPatterns(cwd, raw);
+  }
+
+  return raw;
+}
+
+function reconcileWorkspace(
+  cwd,
+  workspacePath,
+  mode,
+  requiredCoverageScript,
+  requiredC8Version,
+) {
+  const packageDir = path.resolve(cwd, workspacePath);
+  const packageJsonPath = path.resolve(packageDir, 'package.json');
+
+  const result = {
+    workspacePath,
+    packageDir,
+    packageJsonPath,
+    exists: false,
+    validJson: false,
+    previousCoverage: null,
+    coverageScript: null,
+    previousTestScript: null,
+    testScript: null,
+    previousC8DevDependency: null,
+    c8DevDependency: null,
+    matchesRequiredCoverageBefore: false,
+    matchesRequiredCoverageAfter: false,
+    hasRequiredTestScriptBefore: false,
+    hasRequiredTestScriptAfter: false,
+    matchesRequiredC8DevDependencyBefore: false,
+    matchesRequiredC8DevDependencyAfter: false,
+    updated: false,
+    error: '',
+  };
+
+  if (!fs.existsSync(packageJsonPath)) {
+    result.error = `Workspace package.json does not exist: ${workspacePath}`;
+    return result;
+  }
+  result.exists = true;
+
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    result.validJson = true;
+  } catch {
+    result.error = `Workspace package.json is not valid JSON: ${workspacePath}`;
+    return result;
+  }
+
+  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 previousCoverage =
+    typeof scripts[REQUIRED_COVERAGE_SCRIPT_KEY] === 'string'
+      ? scripts[REQUIRED_COVERAGE_SCRIPT_KEY]
+      : null;
+  const previousTestScript =
+    typeof scripts[REQUIRED_TEST_SCRIPT_KEY] === 'string' &&
+    scripts[REQUIRED_TEST_SCRIPT_KEY].trim() !== ''
+      ? scripts[REQUIRED_TEST_SCRIPT_KEY]
+      : null;
+  const previousC8DevDependency =
+    typeof devDependencies.c8 === 'string' ? devDependencies.c8 : null;
+  result.previousCoverage = previousCoverage;
+  result.previousTestScript = previousTestScript;
+  result.previousC8DevDependency = previousC8DevDependency;
+  result.matchesRequiredCoverageBefore =
+    previousCoverage === requiredCoverageScript;
+  result.hasRequiredTestScriptBefore = previousTestScript !== null;
+  result.matchesRequiredC8DevDependencyBefore =
+    previousC8DevDependency === requiredC8Version;
+
+  if (
+    (!result.matchesRequiredCoverageBefore ||
+      !result.hasRequiredTestScriptBefore ||
+      !result.matchesRequiredC8DevDependencyBefore) &&
+    mode === 'sync'
+  ) {
+    scripts[REQUIRED_COVERAGE_SCRIPT_KEY] = requiredCoverageScript;
+    if (!result.hasRequiredTestScriptBefore) {
+      scripts[REQUIRED_TEST_SCRIPT_KEY] = DEFAULT_TEST_SCRIPT_VALUE;
+    }
+    devDependencies.c8 = requiredC8Version;
+    pkg.scripts = scripts;
+    pkg.devDependencies = devDependencies;
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(pkg, null, 2)}\n`,
+      'utf8',
+    );
+    result.updated = true;
+  }
+
+  result.coverageScript =
+    mode === 'sync' && !result.matchesRequiredCoverageBefore
+      ? requiredCoverageScript
+      : previousCoverage;
+  result.testScript =
+    mode === 'sync' && !result.hasRequiredTestScriptBefore
+      ? DEFAULT_TEST_SCRIPT_VALUE
+      : previousTestScript;
+  result.c8DevDependency =
+    mode === 'sync' && !result.matchesRequiredC8DevDependencyBefore
+      ? requiredC8Version
+      : previousC8DevDependency;
+
+  result.matchesRequiredCoverageAfter =
+    result.updated || result.matchesRequiredCoverageBefore;
+  result.hasRequiredTestScriptAfter =
+    (mode === 'sync' && !result.hasRequiredTestScriptBefore) ||
+    result.hasRequiredTestScriptBefore;
+  result.matchesRequiredC8DevDependencyAfter =
+    result.updated || result.matchesRequiredC8DevDependencyBefore;
+  return result;
+}
+
+export function runSyncWorkspace(options) {
+  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
+  const check = hasFlag(options, '--check');
+  const dryRun = hasFlag(options, '--dry-run');
+  const jsonFile = getSingle(options, '--json', '');
+  const { baseline: toolingBaseline, toolingBaselinePath } =
+    loadToolingBaseline();
+  const requiredCoverageScript = buildRequiredCoverageScript(toolingBaseline);
+  const requiredC8Version = buildRequiredC8DevDependency(toolingBaseline);
+
+  if (!fs.existsSync(cwd)) {
+    console.error(`CWD does not exist: ${cwd}`);
+    process.exit(2);
+  }
+
+  const mode = dryRun ? 'dry-run' : check ? 'check' : 'sync';
+  const workspacePaths = resolveWorkspacePaths(cwd, options);
+
+  const report = {
+    cwd,
+    mode,
+    toolingBaselinePath,
+    toolingBaseline: {
+      schemaVersion: toolingBaseline.schemaVersion,
+      c8Version: toolingBaseline.tools.c8.version,
+    },
+    requiredCoverageScript,
+    requiredTestScript: DEFAULT_TEST_SCRIPT_VALUE,
+    requiredC8DevDependency: requiredC8Version,
+    workspaces: workspacePaths,
+    results: [],
+    ok: true,
+  };
+
+  for (const workspacePath of workspacePaths) {
+    const effectiveMode = mode === 'sync' ? 'sync' : 'check';
+    const item = reconcileWorkspace(
+      cwd,
+      workspacePath,
+      effectiveMode,
+      requiredCoverageScript,
+      requiredC8Version,
+    );
+    report.results.push(item);
+
+    if (item.error) {
+      report.ok = false;
+      continue;
+    }
+
+    if (
+      mode === 'check' &&
+      (!item.matchesRequiredCoverageAfter ||
+        !item.hasRequiredTestScriptAfter ||
+        !item.matchesRequiredC8DevDependencyAfter)
+    ) {
+      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);
+  }
+}