@produck/agent-toolkit 0.2.0 → 0.3.3

package/bin/agent-toolkit.mjs

@@ -1,613 +1,71 @@
 #!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
-
-const ALLOWED_TAGS = ['INIT', 'ADD', 'REMOVE', 'FIX', 'REFACTOR', 'UPGRADE'];
-const ALLOWED_TARGETS = ['docs', 'test', 'ci', 'deps', 'api', 'schema', 'infra'];
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATE_ROOT = path.resolve(SCRIPT_DIR, '../templates');
-const PUBLISH_ASSETS_ROOT = path.resolve(SCRIPT_DIR, '../publish-assets');
-const PUBLISH_INSTRUCTIONS_ROOT = path.resolve(PUBLISH_ASSETS_ROOT, 'instructions');
-const PUBLISH_NAMESPACE_ROOT = path.resolve(PUBLISH_INSTRUCTIONS_ROOT, 'produck');
-const MANAGED_MARKER = '<!-- managed-by: @produck/agent-toolkit -->';
-const DEFAULT_NAMESPACE_OUT_DIR = '.github/instructions/produck';
-const USER_SPACE_ENTRYPOINT = '.github/copilot-instructions.md';
-
-function loadTemplateFile(relativePath) {
-  const templatePath = path.resolve(TEMPLATE_ROOT, relativePath);
-  if (!fs.existsSync(templatePath)) {
-    console.error(`Template file not found: ${templatePath}`);
-    process.exit(2);
-  }
-
-  return fs.readFileSync(templatePath, 'utf8');
-}
-
-function printTemplate(relativePath) {
-  let content = loadTemplateFile(relativePath);
-  if (!content.endsWith('\n')) {
-    content = `${content}\n`;
-  }
-  process.stdout.write(content);
-}
-
-function parseCommonArgs(argv) {
-  const positional = [];
-  const options = {};
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const token = argv[i];
-    if (token.startsWith('--')) {
-      const next = argv[i + 1];
-      if (!next || next.startsWith('--')) {
-        if (!options[token]) {
-          options[token] = [];
-        }
-        options[token].push(true);
-      } else {
-        if (!options[token]) {
-          options[token] = [];
-        }
-        options[token].push(next);
-        i += 1;
-      }
-      continue;
-    }
-    positional.push(token);
-  }
-
-  return { positional, options };
-}
-
-function getSingle(options, key, fallback = '') {
-  if (!options[key] || options[key].length === 0) {
-    return fallback;
-  }
-  return String(options[key][options[key].length - 1]);
-}
-
-function getMulti(options, key) {
-  if (!options[key]) {
-    return [];
-  }
-  return options[key].map((v) => String(v));
-}
-
-function hasFlag(options, key) {
-  return Boolean(options[key]);
-}
-
-function printMainHelp() {
-  printTemplate('help/main.txt');
-}
-
-function printPreflightHelp() {
-  printTemplate('help/preflight.txt');
-}
-
-function printRunCaptureHelp() {
-  printTemplate('help/run-capture.txt');
-}
-
-function printSummarizeHelp() {
-  printTemplate('help/summarize-log.txt');
-}
-
-function printValidateHelp() {
-  printTemplate('help/validate-commit-msg.txt');
-}
-
-function printSyncInstructionsHelp() {
-  printTemplate('help/sync-instructions.txt');
-}
-
-function loadDefaultInstructionsTemplate() {
-  if (fs.existsSync(PUBLISH_NAMESPACE_ROOT)) {
-    const names = fs
-      .readdirSync(PUBLISH_NAMESPACE_ROOT)
-      .filter((name) => name.endsWith('.instructions.md'))
-      .sort((a, b) => a.localeCompare(b));
-    const entries = names.map((name) => {
-      const abs = path.resolve(PUBLISH_NAMESPACE_ROOT, name);
-      let text = fs.readFileSync(abs, 'utf8');
-      if (!text.endsWith('\n')) {
-        text = `${text}\n`;
-      }
-      return {
-        fileName: name,
-        content: text,
-        sourcePath: abs,
-      };
-    });
-    return {
-      type: 'dir',
-      sourcePath: PUBLISH_NAMESPACE_ROOT,
-      entries,
-    };
-  }
-
-  console.error('No built-in instruction assets found.');
-  console.error('Run prepack/publish to generate publish-assets, or pass --source explicitly.');
-  process.exit(2);
-}
-
-function readInstructionEntriesFromDirectory(sourceDir) {
-  const names = fs
-    .readdirSync(sourceDir)
-    .filter((name) => name.endsWith('.instructions.md'))
-    .sort((a, b) => a.localeCompare(b));
-  return names.map((name) => {
-    const sourcePath = path.resolve(sourceDir, name);
-    let content = fs.readFileSync(sourcePath, 'utf8');
-    if (!content.endsWith('\n')) {
-      content = `${content}\n`;
-    }
-    return {
-      fileName: name,
-      content,
-      sourcePath,
-    };
-  });
-}
-
-function isManagedFile(filePath) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  return content.includes(MANAGED_MARKER);
-}
-
-function buildUserSpaceBootstrapContent(namespaceDirPath, cwd) {
-  const namespaceDisplayPath = path.relative(cwd, namespaceDirPath).replace(/\\/g, '/');
-  let content = loadTemplateFile('user-space-bootstrap.md');
-  content = content.replace(/\{\{NAMESPACE_GLOB\}\}/g, `${namespaceDisplayPath}/*.instructions.md`);
-  if (!content.endsWith('\n')) {
-    content = `${content}\n`;
-  }
-  return content;
-}
-
-function runPreflight(options) {
-  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
-  const required = getMulti(options, '--require');
-  const ensureDir = getMulti(options, '--ensure-dir');
-  const jsonFile = getSingle(options, '--json', '');
-
-  if (!fs.existsSync(cwd)) {
-    console.error(`CWD does not exist: ${cwd}`);
-    process.exit(2);
-  }
-
-  const report = {
-    cwd,
-    required: [],
-    ensuredDirectories: [],
-    ok: true,
-  };
-
-  for (const rel of required) {
-    const resolved = path.resolve(cwd, rel);
-    const exists = fs.existsSync(resolved);
-    report.required.push({ path: rel, resolved, exists });
-    if (!exists) {
-      report.ok = false;
-    }
-  }
-
-  for (const rel of ensureDir) {
-    const resolved = path.resolve(cwd, rel);
-    fs.mkdirSync(resolved, { recursive: true });
-    report.ensuredDirectories.push({ path: rel, resolved, created: true });
-  }
-
-  if (jsonFile) {
-    const out = path.resolve(cwd, jsonFile);
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
-  }
-
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-  if (!report.ok) {
-    process.exit(2);
-  }
-}
-
-function runCapture(options) {
-  const out = getSingle(options, '--out', '');
-  const cmd = getSingle(options, '--cmd', '');
-  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
-  const meta = getSingle(options, '--meta', '');
-  const allowPipe = hasFlag(options, '--allow-pipe');
-
-  if (!out || !cmd) {
-    printRunCaptureHelp();
-    process.exit(2);
-  }
-
-  if (!allowPipe && cmd.includes('|')) {
-    console.error('Blocked command containing pipe. Use --allow-pipe if needed.');
-    process.exit(2);
-  }
-
-  const outPath = path.resolve(out);
-  const metaPath = meta ? path.resolve(meta) : `${outPath}.meta.json`;
-
-  fs.mkdirSync(path.dirname(outPath), { recursive: true });
-  fs.mkdirSync(path.dirname(metaPath), { recursive: true });
-
-  const startAt = Date.now();
-  const outStream = fs.createWriteStream(outPath, { encoding: 'utf8' });
-
-  outStream.write(`# command: ${cmd}\n`);
-  outStream.write(`# cwd: ${cwd}\n`);
-  outStream.write(`# startedAt: ${new Date(startAt).toISOString()}\n\n`);
-
-  const child = spawn(cmd, {
-    cwd,
-    shell: true,
-    env: process.env,
-  });
-
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-
-  child.stdout.on('data', (chunk) => {
-    stdoutBytes += chunk.length;
-    outStream.write(chunk);
-  });
-
-  child.stderr.on('data', (chunk) => {
-    stderrBytes += chunk.length;
-    outStream.write(chunk);
-  });
-
-  child.on('error', (error) => {
-    outStream.write(`\n[agent-toolkit] spawn error: ${error.message}\n`);
-  });
-
-  child.on('close', (code, signal) => {
-    const endAt = Date.now();
-    const durationMs = endAt - startAt;
-
-    outStream.write('\n');
-    outStream.write(`# finishedAt: ${new Date(endAt).toISOString()}\n`);
-    outStream.write(`# exitCode: ${String(code)}\n`);
-    outStream.write(`# signal: ${signal ? String(signal) : 'none'}\n`);
-    outStream.end();
-
-    const report = {
-      command: cmd,
-      cwd,
-      startedAt: new Date(startAt).toISOString(),
-      finishedAt: new Date(endAt).toISOString(),
-      durationMs,
-      exitCode: code,
-      signal,
-      stdoutBytes,
-      stderrBytes,
-      outputFile: outPath,
-    };
-
-    fs.writeFileSync(metaPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
-
-    if (typeof code === 'number') {
-      process.exit(code);
-    }
-    process.exit(1);
-  });
-}
-
-function runSummarize(options) {
-  const file = getSingle(options, '--file', '');
-  const last = Number(getSingle(options, '--last', '0')) || 0;
-  const match = getSingle(options, '--match', '');
-  const max = Number(getSingle(options, '--max', '200')) || 200;
-
-  if (!file) {
-    printSummarizeHelp();
-    process.exit(2);
-  }
-
-  const filePath = path.resolve(file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Log file does not exist: ${filePath}`);
-    process.exit(2);
-  }
-
-  const raw = fs.readFileSync(filePath, 'utf8');
-  const allLines = raw.split(/\r?\n/);
-
-  let lines = allLines;
-  let mode = 'all';
-
-  if (match) {
-    const pattern = new RegExp(match, 'i');
-    lines = allLines.filter((line) => pattern.test(line));
-    mode = 'match';
-  }
-
-  if (last > 0) {
-    lines = lines.slice(-last);
-    mode = mode === 'match' ? 'match+last' : 'last';
-  }
-
-  if (max > 0 && lines.length > max) {
-    lines = lines.slice(0, max);
-  }
-
-  const header = [
-    `# file: ${filePath}`,
-    `# totalLines: ${allLines.length}`,
-    `# selectedLines: ${lines.length}`,
-    `# mode: ${mode}`,
-    '',
-  ].join('\n');
-
-  process.stdout.write(header);
-  process.stdout.write(lines.join('\n'));
-  process.stdout.write('\n');
-}
-
-function validateCommitLine(line, lineNo) {
-  if (line.trim() === '') {
-    return `Line ${lineNo}: empty line is not allowed`;
-  }
-
-  const head = line.match(/^\[([A-Z]+)\]\s+/);
-  if (!head) {
-    return `Line ${lineNo}: must start with [TAG] followed by a space`;
-  }
-
-  const tag = head[1];
-  if (!ALLOWED_TAGS.includes(tag)) {
-    return `Line ${lineNo}: tag [${tag}] is not allowed`;
-  }
-
-  const rest = line.slice(head[0].length);
-  if (rest.trim() === '') {
-    return `Line ${lineNo}: summary is required after tag`;
-  }
-
-  const targetMatch = rest.match(/^<([^>]+)>:\s+(.+)$/);
-  if (targetMatch) {
-    const target = targetMatch[1];
-    const summary = targetMatch[2];
-    if (!ALLOWED_TARGETS.includes(target)) {
-      return `Line ${lineNo}: target <${target}> is not allowed`;
-    }
-    if (summary.trim() === '') {
-      return `Line ${lineNo}: summary is required after target`;
-    }
-  }
-
-  return null;
-}
-
-function runValidateCommitMsg(options) {
-  const file = getSingle(options, '--file', '');
-  if (!file) {
-    printValidateHelp();
-    process.exit(2);
-  }
-
-  const filePath = path.resolve(file);
-  if (!fs.existsSync(filePath)) {
-    console.error(`Message file not found: ${filePath}`);
-    process.exit(2);
-  }
-
-  const raw = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
-  const lines = raw.endsWith('\n') ? raw.slice(0, -1).split('\n') : raw.split('\n');
-
-  if (lines.length === 0 || (lines.length === 1 && lines[0].trim() === '')) {
-    console.error('Commit message is empty');
-    process.exit(2);
-  }
-
-  const errors = [];
-  for (let i = 0; i < lines.length; i += 1) {
-    const err = validateCommitLine(lines[i], i + 1);
-    if (err) {
-      errors.push(err);
-    }
-  }
-
-  if (errors.length > 0) {
-    console.error('Commit message validation failed:');
-    for (const err of errors) {
-      console.error(`- ${err}`);
-    }
-    process.exit(1);
-  }
-
-  console.log('Commit message validation passed');
-}
-
-function runSyncInstructions(options) {
-  const cwd = path.resolve(getSingle(options, '--cwd', process.cwd()));
-  const outArg = getSingle(options, '--out', DEFAULT_NAMESPACE_OUT_DIR);
-  const sourceArg = getSingle(options, '--source', '');
-  const force = hasFlag(options, '--force');
-  const dryRun = hasFlag(options, '--dry-run');
-  const prune = hasFlag(options, '--prune');
-
-  if (!fs.existsSync(cwd)) {
-    console.error(`CWD does not exist: ${cwd}`);
-    process.exit(2);
-  }
-
-  const defaults = loadDefaultInstructionsTemplate();
-  let sourceType = defaults.type;
-  let sourceResolved = defaults.sourcePath;
-  let entries = defaults.entries;
-
-  if (sourceArg) {
-    const sourcePath = path.resolve(cwd, sourceArg);
-    if (!fs.existsSync(sourcePath)) {
-      console.error(`Source path does not exist: ${sourcePath}`);
-      process.exit(2);
-    }
-    const stat = fs.statSync(sourcePath);
-    if (stat.isDirectory()) {
-      sourceType = 'dir';
-      sourceResolved = sourcePath;
-      entries = readInstructionEntriesFromDirectory(sourcePath);
-      if (entries.length === 0) {
-        console.error(`No .instructions.md files in source directory: ${sourcePath}`);
-        process.exit(2);
-      }
-    } else {
-      sourceType = 'file';
-      sourceResolved = sourcePath;
-      let content = fs.readFileSync(sourcePath, 'utf8');
-      if (!content.endsWith('\n')) {
-        content = `${content}\n`;
-      }
-      entries = [
-        {
-          fileName: path.basename(sourcePath),
-          content,
-          sourcePath,
-        },
-      ];
-    }
-  }
-
-  const outPath = path.resolve(cwd, outArg);
-  const outLooksLikeFile = outArg.endsWith('.md');
-
-  if (outLooksLikeFile && entries.length > 1) {
-    console.error('Target --out is a file path but source has multiple instruction files.');
-    console.error('Use an output directory for multi-file sync.');
-    process.exit(2);
-  }
-
-  if (outLooksLikeFile) {
-    const entry = entries[0];
-    const exists = fs.existsSync(outPath);
-    if (exists && !force) {
-      const current = fs.readFileSync(outPath, 'utf8');
-      if (current !== entry.content) {
-        console.error(`Target already exists: ${outPath}`);
-        console.error('Use --force to overwrite.');
-        process.exit(2);
-      }
-    }
-
-    const report = {
-      mode: 'single-file',
-      cwd,
-      sourceType,
-      source: sourceResolved,
-      outPath,
-      exists,
-      overwritten: exists && force,
-      dryRun,
-      prune: false,
-      initializedUserSpaceEntry: false,
-      userSpaceEntryPath: null,
-    };
-
-    if (dryRun) {
-      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-      process.exit(0);
-    }
-
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, entry.content, 'utf8');
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+import { printMainHelp } from './command/main/index.mjs';
+import {
+  printEnforceNodeBaselineHelp,
+  runEnforceNodeBaseline,
+} from './command/enforce-node-baseline/index.mjs';
+import { printPreflightHelp, runPreflight } from './command/preflight/index.mjs';
+import { printRunCaptureHelp, runCapture } from './command/run-capture/index.mjs';
+import { printSummarizeHelp, runSummarize } from './command/summarize-log/index.mjs';
+import {
+  printSyncCoverageScriptHelp,
+  runSyncCoverageScript,
+} from './command/sync-coverage-script/index.mjs';
+import { printSyncHuskyHooksHelp, runSyncHuskyHooks } from './command/sync-husky-hooks/index.mjs';
+import {
+  printSyncInstructionsHelp,
+  runSyncInstructions,
+} from './command/sync-instructions/index.mjs';
+import { hasFlag, parseCommonArgs } from './command/shared/args.mjs';
+import {
+  printValidateCommitMsgHelp,
+  runValidateCommitMsg,
+} from './command/validate-commit-msg/index.mjs';
+
+const COMMANDS = {
+  'enforce-node-baseline': {
+    printHelp: printEnforceNodeBaselineHelp,
+    run: runEnforceNodeBaseline,
+  },
+  preflight: {
+    printHelp: printPreflightHelp,
+    run: runPreflight,
+  },
+  'run-capture': {
+    printHelp: printRunCaptureHelp,
+    run: runCapture,
+  },
+  'summarize-log': {
+    printHelp: printSummarizeHelp,
+    run: runSummarize,
+  },
+  'sync-coverage-script': {
+    printHelp: printSyncCoverageScriptHelp,
+    run: runSyncCoverageScript,
+  },
+  'sync-husky-hooks': {
+    printHelp: printSyncHuskyHooksHelp,
+    run: runSyncHuskyHooks,
+  },
+  'validate-commit-msg': {
+    printHelp: printValidateCommitMsgHelp,
+    run: runValidateCommitMsg,
+  },
+  'sync-instructions': {
+    printHelp: printSyncInstructionsHelp,
+    run: runSyncInstructions,
+  },
+};
+
+const DEFAULT_COMMAND = 'enforce-node-baseline';
+
+function printCommandHelp(command) {
+  const entry = COMMANDS[command];
+  if (!entry) {
+    printMainHelp();
     return;
   }
-
-  const outDir = outPath;
-  const planned = entries.map((entry) => {
-    return {
-      fileName: entry.fileName,
-      sourcePath: entry.sourcePath,
-      targetPath: path.resolve(outDir, entry.fileName),
-      content: entry.content,
-    };
-  });
-
-  const targetSet = new Set(planned.map((item) => item.targetPath));
-  const unchanged = [];
-  for (const item of planned) {
-    if (fs.existsSync(item.targetPath)) {
-      const current = fs.readFileSync(item.targetPath, 'utf8');
-      if (current === item.content) {
-        unchanged.push(item.targetPath);
-      }
-    }
-  }
-
-  const toWrite = planned.filter((item) => !unchanged.includes(item.targetPath));
-  const conflicts = toWrite.filter((item) => fs.existsSync(item.targetPath));
-  if (conflicts.length > 0 && !force) {
-    console.error('Some target files already exist and would change:');
-    for (const item of conflicts) {
-      console.error(`- ${item.targetPath}`);
-    }
-    console.error('Use --force to overwrite.');
-    process.exit(2);
-  }
-
-  const pruneDeletes = [];
-  if (prune && fs.existsSync(outDir)) {
-    const existing = fs
-      .readdirSync(outDir)
-      .filter((name) => name.endsWith('.instructions.md'))
-      .map((name) => path.resolve(outDir, name));
-    for (const existingPath of existing) {
-      if (!targetSet.has(existingPath) && isManagedFile(existingPath)) {
-        pruneDeletes.push(existingPath);
-      }
-    }
-  }
-
-  const userSpaceEntryPath = path.resolve(cwd, USER_SPACE_ENTRYPOINT);
-  const shouldInitUserSpaceEntry = !fs.existsSync(userSpaceEntryPath);
-
-  const report = {
-    mode: 'directory',
-    cwd,
-    sourceType,
-    source: sourceResolved,
-    outDir,
-    dryRun,
-    force,
-    prune,
-    initializedUserSpaceEntry: shouldInitUserSpaceEntry,
-    userSpaceEntryPath,
-    files: planned.map((item) => ({
-      fileName: item.fileName,
-      sourcePath: item.sourcePath,
-      targetPath: item.targetPath,
-      unchanged: unchanged.includes(item.targetPath),
-    })),
-    deleteFiles: pruneDeletes,
-  };
-
-  if (dryRun) {
-    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    process.exit(0);
-  }
-
-  fs.mkdirSync(outDir, { recursive: true });
-  for (const item of toWrite) {
-    fs.writeFileSync(item.targetPath, item.content, 'utf8');
-  }
-
-  if (shouldInitUserSpaceEntry) {
-    fs.mkdirSync(path.dirname(userSpaceEntryPath), { recursive: true });
-    const userSpaceBootstrap = buildUserSpaceBootstrapContent(outDir, cwd);
-    fs.writeFileSync(userSpaceEntryPath, userSpaceBootstrap, 'utf8');
-  }
-
-  for (const filePath of pruneDeletes) {
-    fs.unlinkSync(filePath);
-  }
-
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  entry.printHelp();
 }
 
 function main() {
@@ -615,62 +73,26 @@ function main() {
   const command = parsed.positional[0] || '';
   const options = parsed.options;
 
-  if (!command || command === '--help' || command === '-h') {
+  if (command === '--help' || command === '-h' || (!command && hasFlag(options, '--help'))) {
     printMainHelp();
     process.exit(0);
   }
 
-  if (hasFlag(options, '--help') || hasFlag(options, '-h')) {
-    if (command === 'preflight') {
-      printPreflightHelp();
-      process.exit(0);
-    }
-    if (command === 'run-capture') {
-      printRunCaptureHelp();
-      process.exit(0);
-    }
-    if (command === 'summarize-log') {
-      printSummarizeHelp();
-      process.exit(0);
-    }
-    if (command === 'validate-commit-msg') {
-      printValidateHelp();
-      process.exit(0);
-    }
-    if (command === 'sync-instructions') {
-      printSyncInstructionsHelp();
-      process.exit(0);
-    }
-  }
-
-  if (command === 'preflight') {
-    runPreflight(options);
-    return;
-  }
-
-  if (command === 'run-capture') {
-    runCapture(options);
-    return;
-  }
-
-  if (command === 'summarize-log') {
-    runSummarize(options);
-    return;
-  }
+  const effectiveCommand = command || DEFAULT_COMMAND;
 
-  if (command === 'validate-commit-msg') {
-    runValidateCommitMsg(options);
-    return;
+  if (hasFlag(options, '--help') || hasFlag(options, '-h')) {
+    printCommandHelp(effectiveCommand);
+    process.exit(0);
   }
 
-  if (command === 'sync-instructions') {
-    runSyncInstructions(options);
-    return;
+  const entry = COMMANDS[effectiveCommand];
+  if (!entry) {
+    console.error(`Unknown command: ${command}`);
+    printMainHelp();
+    process.exit(2);
   }
 
-  console.error(`Unknown command: ${command}`);
-  printMainHelp();
-  process.exit(2);
+  entry.run(options);
 }
 
 main();